-

50 files changed, 9887 insertions, 0 deletions

diff --git a/tinyRTP/Makefile.am b/tinyRTP/Makefile.am
new file mode 100644
index 0000000..02fc587
--- /dev/null
+++ b/tinyRTP/Makefile.am
@@ -0,0 +1,49 @@
+lib_LTLIBRARIES         = libtinyRTP.la
+libtinyRTP_la_LIBADD = ../tinySAK/libtinySAK.la ../tinyNET/libtinyNET.la ../tinyMEDIA/libtinyMEDIA.la
+libtinyRTP_la_CPPFLAGS = -I../tinySAK/src -I../tinyNET/src -I../tinyMEDIA/include -Iinclude
+
+if USE_SRTP
+libtinyRTP_la_LIBADD += ${LIBSRTP_LIBADD}
+libtinyRTP_la_CPPFLAGS += -DHAVE_SRTP=1
+endif
+	
+libtinyRTP_la_SOURCES = \
+	src/trtp.c \
+	src/trtp_manager.c \
+	src/trtp_srtp.c
+
+libtinyRTP_la_SOURCES += src/rtcp/trtp_rtcp_header.c \
+	src/rtcp/trtp_rtcp_packet.c \
+	src/rtcp/trtp_rtcp_rblock.c \
+	src/rtcp/trtp_rtcp_report.c \
+	src/rtcp/trtp_rtcp_report_bye.c \
+	src/rtcp/trtp_rtcp_report_fb.c \
+	src/rtcp/trtp_rtcp_report_rr.c \
+	src/rtcp/trtp_rtcp_report_sdes.c \
+	src/rtcp/trtp_rtcp_report_sr.c \
+	src/rtcp/trtp_rtcp_report_xr.c \
+	src/rtcp/trtp_rtcp_sdes_chunck.c \
+	src/rtcp/trtp_rtcp_sdes_item.c \
+	src/rtcp/trtp_rtcp_session.c
+
+libtinyRTP_la_SOURCES += src/rtp/trtp_rtp_header.c \
+	src/rtp/trtp_rtp_packet.c \
+	src/rtp/trtp_rtp_session.c
+
+
+libtinyRTP_la_LDFLAGS = $LDFLAGS -no-undefined
+if TARGET_OS_IS_ANDROID
+libtinyRTP_la_LDFLAGS += -static
+endif
+
+_includedir = $(includedir)/tinyrtp
+_include_HEADERS = include/*.h
+__includedir = $(includedir)/tinyrtp/tinyrtp
+__include_HEADERS = include/tinyrtp/*.h
+rtcp_includedir = $(includedir)/tinyrtp/tinyrtp/rtcp
+rtcp_include_HEADERS = include/tinyrtp/rtcp/*.h
+rtp_includedir = $(includedir)/tinyrtp/tinyrtp/rtp
+rtp_include_HEADERS = include/tinyrtp/rtp/*.h
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = tinyRTP.pc
\ No newline at end of file
diff --git a/tinyRTP/droid-makefile b/tinyRTP/droid-makefile
new file mode 100644
index 0000000..a56b89f
--- /dev/null
+++ b/tinyRTP/droid-makefile
@@ -0,0 +1,59 @@
+APP := lib$(PROJECT)_$(MARCH).$(EXT)
+
+# SRTP (Default: enabled)
+ifeq ($(SRTP),no)
+	LIBSRTP_CFLAGS := -DHAVE_SRTP=0
+else
+	LIBSRTP_CFLAGS := -DHAVE_SRTP=1
+	LIBSRTP_LDFLAGS := -lsrtp
+endif
+
+THIRDPARTIES_INC := ../thirdparties/android/include
+CFLAGS := $(CFLAGS_LIB) -I$(THIRDPARTIES_INC) $(LIBSRTP_CFLAGS) -I../tinySAK/src -I../tinyNET/src -I./include -I../tinyMEDIA/include
+LDFLAGS := $(LDFLAGS_LIB) $(LIBSRTP_LDFLAGS) -ltinySAK_$(MARCH) -ltinyNET_$(MARCH) -ltinyMEDIA_$(MARCH)
+
+all: $(APP)
+
+OBJS = \
+	src/trtp.o \
+	src/trtp_manager.o \
+	src/trtp_srtp.o
+	
+## RTCP
+OBJS += src/rtcp/trtp_rtcp_header.o \
+	src/rtcp/trtp_rtcp_packet.o \
+	src/rtcp/trtp_rtcp_rblock.o \
+	src/rtcp/trtp_rtcp_report.o \
+	src/rtcp/trtp_rtcp_report_bye.o \
+	src/rtcp/trtp_rtcp_report_fb.o \
+	src/rtcp/trtp_rtcp_report_rr.o \
+	src/rtcp/trtp_rtcp_report_sdes.o \
+	src/rtcp/trtp_rtcp_report_sr.o \
+	src/rtcp/trtp_rtcp_report_xr.o \
+	src/rtcp/trtp_rtcp_sdes_chunck.o \
+	src/rtcp/trtp_rtcp_sdes_item.o \
+	src/rtcp/trtp_rtcp_session.o
+
+## RTP
+OBJS += src/rtp/trtp_rtp_header.o \
+	src/rtp/trtp_rtp_packet.o \
+	src/rtp/trtp_rtp_session.o
+	
+
+$(APP): $(OBJS)
+ifeq ($(EXT), a)
+	$(AR) rcs $@ $^
+else
+	$(CC) $(LDFLAGS) -o $@ $^
+endif
+
+%.o: %.c
+	$(CC) -c $(INCLUDE) $(CFLAGS) $< -o $@
+	
+install: $(APP)
+	$(ANDROID_SDK_ROOT)/tools/adb remount
+	$(ANDROID_SDK_ROOT)/tools/adb push $(APP) $(LIB_DIR)/$(APP)
+	$(ANDROID_SDK_ROOT)/tools/adb shell chmod 777 $(LIB_DIR)/$(APP)
+	
+clean:
+	@rm -f $(OBJS) $(APP)
\ No newline at end of file
diff --git a/tinyRTP/include/tinyrtp.h b/tinyRTP/include/tinyrtp.h
new file mode 100644
index 0000000..8707f81
--- /dev/null
+++ b/tinyRTP/include/tinyrtp.h
@@ -0,0 +1,43 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+
+/**@file tinyrtp.h
+ * @brief tinyRTP (Real-time Transport Protocol) API.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#ifndef TINYRTP_TINYRTP_H
+#define TINYRTP_TINYRTP_H
+
+/* === tinyNET (tinyNET/src) === */
+#include "tnet.h"
+
+/* === tinySAK (tinySAK/src)=== */
+#include "tsk.h"
+
+#include "tinyrtp/rtp/trtp_rtp_header.h"
+#include "tinyrtp/rtp/trtp_rtp_packet.h"
+#include "tinyrtp/trtp_manager.h"
+
+#endif /* TINYRTP_TINYRTP_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_header.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_header.h
new file mode 100644
index 0000000..9cf6a1a
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_header.h
@@ -0,0 +1,62 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_HEADER_H
+#define TINYRTP_RTCP_HEADER_H
+
+#include "tinyrtp_config.h"
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+
+#include "tsk_buffer.h"
+#include "tsk_list.h"
+
+#define TRTP_RTCP_HEADER_SIZE				4
+#define TRTP_RTCP_HEADER_VERSION_DEFAULT	2
+
+TRTP_BEGIN_DECLS
+
+typedef struct trtp_rtcp_header_s
+{
+	TSK_DECLARE_OBJECT;
+	
+	unsigned version:2;
+	unsigned padding:1;
+	unsigned rc:5;
+	trtp_rtcp_packet_type_t type; /**< Packet Type on 8bits */
+	uint16_t length_in_words_minus1; /**< The length of this RTCP packet in 32-bit words minus one */
+	uint32_t length_in_bytes;
+}
+trtp_rtcp_header_t;
+
+#define TRTP_DECLARE_RTCP_HEADER trtp_rtcp_header_t __header__
+typedef tsk_list_t trtp_rtcp_headers_L_t; /**< List of @ref trtp_rtcp_header_t elements */
+
+TINYRTP_API trtp_rtcp_header_t* trtp_rtcp_header_create_null();
+TINYRTP_API trtp_rtcp_header_t* trtp_rtcp_header_create(uint8_t version, uint8_t padding, uint8_t rc, trtp_rtcp_packet_type_t type, uint16_t length_in_bytes);
+TINYRTP_API int trtp_rtcp_header_serialize_to(const trtp_rtcp_header_t *self, void* data, tsk_size_t size);
+TINYRTP_API trtp_rtcp_header_t* trtp_rtcp_header_deserialize(const void *data, tsk_size_t size);
+TINYRTP_API int trtp_rtcp_header_deserialize_to(trtp_rtcp_header_t** self, const void *data, tsk_size_t size);
+
+TINYRTP_GEXTERN const tsk_object_def_t *trtp_rtcp_header_def_t;
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_HEADER_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_packet.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_packet.h
new file mode 100644
index 0000000..9045be7
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_packet.h
@@ -0,0 +1,74 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_PACKET_H
+#define TINYRTP_RTCP_PACKET_H
+
+#include "tinyrtp_config.h"
+
+#include "tsk_buffer.h"
+#include "tsk_list.h"
+
+TRTP_BEGIN_DECLS
+
+#define TRTP_RTCP_PACKET(self)	((trtp_rtcp_packet_t*)(self))
+#define TRTP_DECLARE_RTCP_PACKET trtp_rtcp_packet_t __packet__
+
+// RFC 3550 12.1 RTCP Packet Types
+// RFC 4585
+// RFC 5104 (FIXME: not supported yet!)
+typedef enum trtp_rtcp_packet_type_e
+{
+	trtp_rtcp_packet_type_sr = 200,
+	trtp_rtcp_packet_type_rr = 201,
+	trtp_rtcp_packet_type_sdes = 202,
+	trtp_rtcp_packet_type_bye = 203,
+	trtp_rtcp_packet_type_app = 204,
+	trtp_rtcp_packet_type_rtpfb = 205,
+	trtp_rtcp_packet_type_psfb = 206
+}
+trtp_rtcp_packet_type_t;
+
+typedef struct trtp_rtcp_packet_s
+{
+	TSK_DECLARE_OBJECT;
+
+	struct trtp_rtcp_header_s *header;
+}
+trtp_rtcp_packet_t;
+
+typedef tsk_list_t trtp_rtcp_packets_L_t; /**< List of @ref trtp_rtcp_packet_t elements */
+
+trtp_rtcp_packet_t* trtp_rtcp_packet_create(struct trtp_rtcp_header_s* header);
+int trtp_rtcp_packet_init(trtp_rtcp_packet_t* self, uint8_t version, uint8_t padding, uint8_t rc, trtp_rtcp_packet_type_t type, uint16_t length_in_bytes);
+trtp_rtcp_packet_t* trtp_rtcp_packet_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_packet_serialize_to(const trtp_rtcp_packet_t* self, void* data, tsk_size_t size);
+tsk_buffer_t* trtp_rtcp_packet_serialize(const trtp_rtcp_packet_t* self, tsk_size_t num_bytes_pad);
+int trtp_rtcp_packet_add_packet(trtp_rtcp_packet_t* self, trtp_rtcp_packet_t* packet, tsk_bool_t front);
+TINYRTP_API const trtp_rtcp_packet_t* trtp_rtcp_packet_get_at(const trtp_rtcp_packet_t* self, trtp_rtcp_packet_type_t type, tsk_size_t index);
+TINYRTP_API const trtp_rtcp_packet_t* trtp_rtcp_packet_get(const trtp_rtcp_packet_t* self, trtp_rtcp_packet_type_t type);
+tsk_size_t trtp_rtcp_packet_get_size(const trtp_rtcp_packet_t* self);
+
+int trtp_rtcp_packet_deinit(trtp_rtcp_packet_t* self);
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_PACKET_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_rblock.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_rblock.h
new file mode 100644
index 0000000..5ea54e6
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_rblock.h
@@ -0,0 +1,59 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_RB_H
+#define TINYRTP_RTCP_REPORT_RB_H
+
+#include "tinyrtp_config.h"
+
+#include "tsk_list.h"
+
+TRTP_BEGIN_DECLS
+
+#define TRTP_RTCP_RBLOCK_SIZE 24
+
+#define TRTP_RTCP_RBLOCK(self) ((trtp_rtcp_rblock_t*)(self))
+
+// RFC 3550 6.4.1 SR: Sender Report RTCP Packet => Report block part
+typedef struct trtp_rtcp_rblock_s
+{
+	TSK_DECLARE_OBJECT;
+
+	uint32_t ssrc;				/* data source being reported */
+	unsigned int fraction:8;	/* fraction lost since last SR/RR */
+	int cumulative_no_lost:24;  /* cumul. no. pkts lost (signed!) */
+	uint32_t last_seq;			/* extended last seq. no. received */
+	uint32_t jitter;			/* interarrival jitter */
+	uint32_t lsr;				/* last SR packet from this source */
+	uint32_t dlsr;				/* delay since last SR packet */
+}
+trtp_rtcp_rblock_t;
+
+typedef tsk_list_t trtp_rtcp_rblocks_L_t; /**< List of @ref trtp_rtcp_rblock_t elements */
+
+trtp_rtcp_rblock_t* trtp_rtcp_rblock_create_null();
+trtp_rtcp_rblock_t* trtp_rtcp_rblock_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_rblock_deserialize_list(const void* data, tsk_size_t size, trtp_rtcp_rblocks_L_t* dest_list);
+int trtp_rtcp_rblock_serialize_to(const trtp_rtcp_rblock_t* self, void* data, tsk_size_t size);
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_REPORT_RB_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report.h
new file mode 100644
index 0000000..c30351f
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report.h
@@ -0,0 +1,32 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_H
+#define TINYRTP_RTCP_REPORT_H
+
+#include "tinyrtp_config.h"
+
+TRTP_BEGIN_DECLS
+
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_REPORT_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_bye.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_bye.h
new file mode 100644
index 0000000..796e9fc
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_bye.h
@@ -0,0 +1,45 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_BYE_H
+#define TINYRTP_RTCP_REPORT_BYE_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+
+typedef struct trtp_rtcp_report_bye_s
+{
+	TRTP_DECLARE_RTCP_PACKET;
+
+	uint32_t *ssrc_list;
+	trtp_rtcp_packets_L_t* packets;
+}
+trtp_rtcp_report_bye_t;
+
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_create_null();
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_create(struct trtp_rtcp_header_s* header);
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_create_2(uint32_t ssrc);
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_report_bye_serialize_to(const trtp_rtcp_report_bye_t* self, void* data, tsk_size_t size);
+tsk_size_t trtp_rtcp_report_bye_get_size(const trtp_rtcp_report_bye_t* self);
+
+#endif /* TINYRTP_RTCP_REPORT_BYE_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_fb.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_fb.h
new file mode 100644
index 0000000..1ad30b4
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_fb.h
@@ -0,0 +1,152 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_FB_H
+#define TINYRTP_RTCP_REPORT_FB_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+
+#define TRTP_RTCP_REPORT_FB(self) ((trtp_rtcp_report_fb_t*)(self))
+#define TRTP_DECLARE_RTCP_FB_PACKET trtp_rtcp_report_fb_t __packet_fb__
+
+// RFC 4585 6.1. Common Packet Format for Feedback Messages
+typedef struct trtp_rtcp_report_fb_s
+{
+	TRTP_DECLARE_RTCP_PACKET;
+
+	uint32_t ssrc_sender; /* SSRC of packet sender */
+	uint32_t ssrc_media; /* SSRC of media source */
+}
+trtp_rtcp_report_fb_t;
+
+typedef enum trtp_rtcp_rtpfb_fci_type_e
+{
+	trtp_rtcp_rtpfb_fci_type_nack = 1, // RFC 4585
+	trtp_rtcp_rtpfb_fci_type_tmmbn = 4, // RFC 5104
+}
+trtp_rtcp_rtpfb_fci_type_t;
+
+// Transport layer FB message
+typedef struct trtp_rtcp_report_rtpfb_s
+{
+	TRTP_DECLARE_RTCP_FB_PACKET;
+	
+	trtp_rtcp_rtpfb_fci_type_t fci_type;
+	union{
+		struct{
+			tsk_size_t count; // not part of the specification
+			uint16_t* pid; // 16 bits
+			uint16_t* blp; // 16 bits
+		}nack;
+		struct{
+			tsk_size_t count; // not part of the specification
+			uint32_t* ssrc; // 32 bits
+			uint8_t* MxTBR_Exp; // 6 bits
+			uint32_t* MxTBR_Mantissa; // 17 bits
+			uint16_t* MeasuredOverhead; // 9 bits
+		}tmmbn;
+	};
+}
+trtp_rtcp_report_rtpfb_t;
+
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create_null();
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create(struct trtp_rtcp_header_s* header);
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create_2(trtp_rtcp_rtpfb_fci_type_t fci_type, uint32_t ssrc_sender, uint32_t ssrc_media_src);
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create_nack(uint32_t ssrc_sender, uint32_t ssrc_media_src, const uint16_t* seq_nums, tsk_size_t count);
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_report_rtpfb_serialize_to(const trtp_rtcp_report_rtpfb_t* self, void* data, tsk_size_t size);
+tsk_size_t trtp_rtcp_report_rtpfb_get_size(const trtp_rtcp_report_rtpfb_t* self);
+
+
+typedef enum trtp_rtcp_psfb_fci_type_e
+{
+	trtp_rtcp_psfb_fci_type_pli = 1, /* rfc 4585: Picture Loss Indication (PLI) */
+	trtp_rtcp_psfb_fci_type_sli = 2, /* rfc 4585: Slice Loss Indication (SLI) */
+	trtp_rtcp_psfb_fci_type_rpsi = 3, /* rfc 4585: Reference Picture Selection Indication (RPSI) */
+	trtp_rtcp_psfb_fci_type_fir = 4, /* rfc 5104: Full Intra Request (FIR) Command*/
+	trtp_rtcp_psfb_fci_type_afb = 15, /* rfc 4585: Application layer FB (AFB) message */
+}
+trtp_rtcp_psfb_fci_type_t;
+
+/* rfc 4585: Application layer FB (AFB) message */
+typedef enum trtp_rtcp_psfb_afb_type_e
+{
+	trtp_rtcp_psfb_afb_type_none,
+	trtp_rtcp_psfb_afb_type_remb // draft-alvestrand-rmcat-remb-02
+}
+trtp_rtcp_psfb_afb_type_t;
+
+// Payload-specific FB message
+typedef struct trtp_rtcp_report_psfb_s
+{
+	TRTP_DECLARE_RTCP_FB_PACKET;
+	
+	trtp_rtcp_psfb_fci_type_t fci_type;
+	union{
+		// struct{ //rfc 4585: 6.3.1.2
+		// } pli;
+		struct{ // rfc 4585: 6.3.2.2
+			uint16_t* first;
+			uint16_t* number;
+			uint8_t* pic_id; 
+		} sli;
+		struct{ // rfc 4585: 6.3.3.2
+			unsigned pb:8;
+			unsigned pt:7;
+			uint8_t* bytes;
+		} rpsi;
+		struct{// rfc 5104: 4.3.1.1
+			tsk_size_t count;
+			uint32_t* ssrc; // 32 bits
+			uint8_t* seq_num; // 8 bits
+		}fir;
+		struct{ // rfc 4585: 6.4
+			trtp_rtcp_psfb_afb_type_t type;
+			union{
+				struct{ // draft-alvestrand-rmcat-remb-02: 2.2
+					// MxTBR = mantissa * 2^exp = (mantissa << exp) bps
+					uint8_t num_ssrc;
+					uint8_t exp; // 6bits
+					uint32_t mantissa; // 18bits
+					uint32_t* ssrc_feedbacks; // 'num_ssrc'nth SSRC entries
+				}remb;
+				struct{
+					uint8_t* bytes; // store bytes to allow reconstruction
+				}none; // unknown type
+			};
+		}afb;
+	};
+}
+trtp_rtcp_report_psfb_t;
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_null();
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create(struct trtp_rtcp_header_s* header);
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_2(trtp_rtcp_psfb_fci_type_t fci_type, uint32_t ssrc_sender, uint32_t ssrc_media_src);
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_pli(uint32_t ssrc_sender, uint32_t ssrc_media_src);
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_fir(uint8_t seq_num, uint32_t ssrc_sender, uint32_t ssrc_media_src);
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_afb_remb(uint32_t ssrc_sender, const uint32_t* ssrc_media_src_list, uint32_t ssrc_media_src_list_count, uint32_t bitrate/*in bps*/);
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_report_psfb_serialize_to(const trtp_rtcp_report_psfb_t* self, void* data, tsk_size_t size);
+tsk_size_t trtp_rtcp_report_psfb_get_size(const trtp_rtcp_report_psfb_t* self);
+
+#endif /* TINYRTP_RTCP_REPORT_FB_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_rr.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_rr.h
new file mode 100644
index 0000000..2f25779
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_rr.h
@@ -0,0 +1,54 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_RR_H
+#define TINYRTP_RTCP_REPORT_RR_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+#include "tinyrtp/rtcp/trtp_rtcp_rblock.h"
+
+TRTP_BEGIN_DECLS
+
+#define TRTP_RTCP_REPORT_RR(self)	((trtp_rtcp_report_rr_t*)(self))
+
+// RFC 3550 6.4.2 RR: Receiver Report RTCP Packet
+typedef struct trtp_rtcp_report_rr_s
+{
+	TRTP_DECLARE_RTCP_PACKET;
+	
+	uint32_t ssrc;
+	trtp_rtcp_rblocks_L_t* blocks;
+	trtp_rtcp_packets_L_t* packets;
+}
+trtp_rtcp_report_rr_t;
+
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_create_null();
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_create(struct trtp_rtcp_header_s* header);
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_create_2(uint32_t ssrc);
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_report_rr_serialize_to(const trtp_rtcp_report_rr_t* self, void* data, tsk_size_t size);
+tsk_size_t trtp_rtcp_report_rr_get_size(const trtp_rtcp_report_rr_t* self);
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_REPORT_RR_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_sdes.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_sdes.h
new file mode 100644
index 0000000..04efb5c
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_sdes.h
@@ -0,0 +1,53 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_SDES_H
+#define TINYRTP_RTCP_REPORT_SDES_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+#include "tinyrtp/rtcp/trtp_rtcp_sdes_chunck.h"
+
+TRTP_BEGIN_DECLS
+
+#define TRTP_RTCP_REPORT_SDES(self) ((trtp_rtcp_report_sdes_t*)(self))
+
+/* RFC 3550 6.5 SDES: Source Description RTCP Packet */
+typedef struct trtp_rtcp_report_sdes_s
+{
+	TRTP_DECLARE_RTCP_PACKET;
+	trtp_rtcp_sdes_chuncks_L_t* chuncks;
+}
+trtp_rtcp_report_sdes_t;
+
+typedef tsk_list_t trtp_rtcp_report_sdess_L_t; /**< List of @ref trtp_rtcp_report_sdes_t elements */
+
+trtp_rtcp_report_sdes_t* trtp_rtcp_report_sdes_create_null();
+trtp_rtcp_report_sdes_t* trtp_rtcp_report_sdes_create(struct trtp_rtcp_header_s* header);
+trtp_rtcp_report_sdes_t* trtp_rtcp_report_sdes_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_report_sdes_serialize_to(const trtp_rtcp_report_sdes_t* self, void* data, tsk_size_t size);
+int trtp_rtcp_report_sdes_add_chunck(trtp_rtcp_report_sdes_t* self, trtp_rtcp_sdes_chunck_t* chunck);
+tsk_size_t trtp_rtcp_report_sdes_get_size(const trtp_rtcp_report_sdes_t* self);
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_REPORT_SDES_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_sr.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_sr.h
new file mode 100644
index 0000000..09d442f
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_sr.h
@@ -0,0 +1,62 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_SR_H
+#define TINYRTP_RTCP_REPORT_SR_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+#include "tinyrtp/rtcp/trtp_rtcp_rblock.h"
+
+TRTP_BEGIN_DECLS
+
+#define TRTP_RTCP_REPORT_SR(self)	((trtp_rtcp_report_sr_t*)(self))
+
+// RFC 3550 6.4.1 SR: Sender Report RTCP Packet
+typedef struct trtp_rtcp_report_sr_s
+{
+	TRTP_DECLARE_RTCP_PACKET;
+
+	uint32_t ssrc;
+	struct{
+		uint32_t ntp_msw; /**< NTP timestamp, most significant word */
+		uint32_t ntp_lsw; /**< NTP timestamp, least significant word */
+		uint32_t rtp_timestamp;/**< RTP timestamp */
+		uint32_t sender_pcount; /**< sender's packet count */
+		uint32_t sender_ocount; /**< sender's octet count */
+	} sender_info;
+
+	trtp_rtcp_rblocks_L_t* blocks;
+	trtp_rtcp_packets_L_t* packets;
+}
+trtp_rtcp_report_sr_t;
+
+trtp_rtcp_report_sr_t* trtp_rtcp_report_sr_create_null();
+trtp_rtcp_report_sr_t* trtp_rtcp_report_sr_create(struct trtp_rtcp_header_s* header);
+trtp_rtcp_report_sr_t* trtp_rtcp_report_sr_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_report_sr_serialize_to(const trtp_rtcp_report_sr_t* self, void* data, tsk_size_t size);
+int trtp_rtcp_report_sr_add_block(trtp_rtcp_report_sr_t* self, trtp_rtcp_rblock_t* rblock);
+tsk_size_t trtp_rtcp_report_sr_get_size(const trtp_rtcp_report_sr_t* self);
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_REPORT_SR_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_xr.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_xr.h
new file mode 100644
index 0000000..b08e096
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_report_xr.h
@@ -0,0 +1,32 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_REPORT_XR_H
+#define TINYRTP_RTCP_REPORT_XR_H
+
+#include "tinyrtp_config.h"
+
+TRTP_BEGIN_DECLS
+
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_REPORT_XR_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_sdes_chunck.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_sdes_chunck.h
new file mode 100644
index 0000000..ec3a8d8
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_sdes_chunck.h
@@ -0,0 +1,56 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_SDES_CHUNCK_H
+#define TINYRTP_RTCP_SDES_CHUNCK_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtcp/trtp_rtcp_sdes_item.h"
+
+#define TRTP_RTCP_SDES_CHUNCK_MIN_SIZE			4
+#define TRTP_RTCP_SDES_CHUNCK_SSRC_OR_CSRC_SIZE 4
+
+#define TRTP_RTCP_SDES_CHUNCK(self) ((trtp_rtcp_sdes_chunck_t*)(self))
+
+TRTP_BEGIN_DECLS
+
+typedef struct trtp_rtcp_sdes_chunck_s
+{
+	TSK_DECLARE_OBJECT;
+
+	uint32_t ssrc;
+	trtp_rtcp_sdes_items_L_t* items;
+}
+trtp_rtcp_sdes_chunck_t;
+
+typedef tsk_list_t trtp_rtcp_sdes_chuncks_L_t; /**< List of @ref trtp_rtcp_sdes_item_t elements */
+
+trtp_rtcp_sdes_chunck_t* trtp_rtcp_sdes_chunck_create_null();
+trtp_rtcp_sdes_chunck_t* trtp_rtcp_sdes_chunck_create(uint32_t ssrc);
+trtp_rtcp_sdes_chunck_t* trtp_rtcp_sdes_chunck_deserialize(const void* data, tsk_size_t size);
+int trtp_rtcp_sdes_chunck_serialize_to(const trtp_rtcp_sdes_chunck_t* self, void* data, tsk_size_t size);
+int trtp_rtcp_sdes_chunck_add_item(trtp_rtcp_sdes_chunck_t* self, trtp_rtcp_sdes_item_type_t type, const void* data, uint8_t length);
+tsk_size_t trtp_rtcp_sdes_chunck_get_size(const trtp_rtcp_sdes_chunck_t* self);
+
+TRTP_END_DECLS
+
+#endif /*TINYRTP_RTCP_SDES_CHUNCK_H*/
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_sdes_item.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_sdes_item.h
new file mode 100644
index 0000000..8356a74
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_sdes_item.h
@@ -0,0 +1,71 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef TINYRTP_RTCP_SDES_ITEM_H
+#define TINYRTP_RTCP_SDES_ITEM_H
+
+#include "tinyrtp_config.h"
+
+#include "tsk_list.h"
+#include "tsk_buffer.h"
+
+#define TRTP_RTCP_SDES_ITEM_MIN_SIZE 2 /* Type + Length */
+
+#define TRTP_RTCP_SDES_ITEM(self) ((trtp_rtcp_sdes_item_t*)(self))
+
+TRTP_BEGIN_DECLS
+
+// RFC 3550 12.2 SDES Types
+typedef enum trtp_rtcp_sdes_item_type_e
+{
+	trtp_rtcp_sdes_item_type_end = 0, /**< end of SDES list */
+	trtp_rtcp_sdes_item_type_cname = 1, /**< canonical name*/
+	trtp_rtcp_sdes_item_type_name = 2, /**< user name */
+	trtp_rtcp_sdes_item_type_email = 3, /**< user's electronic mail address*/
+	trtp_rtcp_sdes_item_type_phone = 4, /**< user's phone number  */
+	trtp_rtcp_sdes_item_type_loc = 5, /**< geographic user location*/
+	trtp_rtcp_sdes_item_type_tool = 6, /**< name of application or tool*/
+	trtp_rtcp_sdes_item_type_note = 7, /**< notice about the source*/
+	trtp_rtcp_sdes_item_type_priv = 8, /**< private extensions*/
+}
+trtp_rtcp_sdes_item_type_t;
+
+typedef struct trtp_rtcp_sdes_item_s
+{
+	TSK_DECLARE_OBJECT;
+
+	trtp_rtcp_sdes_item_type_t type;
+	tsk_buffer_t *data;
+}
+trtp_rtcp_sdes_item_t;
+
+
+typedef tsk_list_t trtp_rtcp_sdes_items_L_t; /**< List of @ref trtp_rtcp_sdes_item_t elements */
+
+trtp_rtcp_sdes_item_t* trtp_rtcp_sdes_item_create(trtp_rtcp_sdes_item_type_t type, const void* data, uint8_t length);
+trtp_rtcp_sdes_item_t* trtp_rtcp_sdes_item_deserialize(const void* data, tsk_size_t size);
+tsk_buffer_t* trtp_rtcp_sdes_item_serialize(const trtp_rtcp_sdes_item_t* self);
+int trtp_rtcp_sdes_item_serialize_to(const trtp_rtcp_sdes_item_t* self, void* data, tsk_size_t size);
+tsk_size_t trtp_rtcp_sdes_item_get_size(const trtp_rtcp_sdes_item_t* self);
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTCP_SDES_ITEM_H */
diff --git a/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_session.h b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_session.h
new file mode 100644
index 0000000..34ddbbc
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtcp/trtp_rtcp_session.h
@@ -0,0 +1,70 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtcp_session.h
+ * @brief RTCP session.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#ifndef TINYMEDIA_RTCP_SESSION_H
+#define TINYMEDIA_RTCP_SESSION_H
+
+#include "tinyrtp_config.h"
+#include "tinyrtp/trtp_srtp.h"
+
+#include "tnet_types.h"
+
+#include "tsk_common.h"
+
+TRTP_BEGIN_DECLS
+
+struct trtp_rtcp_packet_s;
+struct trtp_rtp_packet_s;
+struct tnet_ice_ctx_s;
+struct tnet_transport_s;
+
+typedef int (*trtp_rtcp_cb_f)(const void* callback_data, const struct trtp_rtcp_packet_s* packet);
+
+struct trtp_rtcp_session_s* trtp_rtcp_session_create(uint32_t ssrc, const char* cname);
+struct trtp_rtcp_session_s* trtp_rtcp_session_create_2(struct tnet_ice_ctx_s* ice_ctx, uint32_t ssrc, const char* cname);
+int trtp_rtcp_session_set_callback(struct trtp_rtcp_session_s* self, trtp_rtcp_cb_f callback, const void* callback_data);
+#if HAVE_SRTP
+int trtp_rtcp_session_set_srtp_sess(struct trtp_rtcp_session_s* self, const srtp_t* session);
+#endif
+int trtp_rtcp_session_set_app_bandwidth_max(struct trtp_rtcp_session_s* self, int32_t bw_upload_kbps, int32_t bw_download_kbps);
+int trtp_rtcp_session_start(struct trtp_rtcp_session_s* self, tnet_fd_t local_fd, const struct sockaddr* remote_addr);
+int trtp_rtcp_session_stop(struct trtp_rtcp_session_s* self);
+int trtp_rtcp_session_process_rtp_out(struct trtp_rtcp_session_s* self, const struct trtp_rtp_packet_s* packet_rtp, tsk_size_t size);
+int trtp_rtcp_session_process_rtp_in(struct trtp_rtcp_session_s* self, const struct trtp_rtp_packet_s* packet_rtp, tsk_size_t size);
+int trtp_rtcp_session_process_rtcp_in(struct trtp_rtcp_session_s* self, const void* buffer, tsk_size_t size);
+int trtp_rtcp_session_signal_pkt_loss(struct trtp_rtcp_session_s* self, uint32_t ssrc_media, const uint16_t* seq_nums, tsk_size_t count);
+int trtp_rtcp_session_signal_frame_corrupted(struct trtp_rtcp_session_s* self, uint32_t ssrc_media);
+int trtp_rtcp_session_signal_jb_error(struct trtp_rtcp_session_s* self, uint32_t ssrc_media);
+
+tnet_fd_t trtp_rtcp_session_get_local_fd(const struct trtp_rtcp_session_s* self);
+int trtp_rtcp_session_set_local_fd(struct trtp_rtcp_session_s* self, tnet_fd_t local_fd);
+int trtp_rtcp_session_set_net_transport(struct trtp_rtcp_session_s* self, struct tnet_transport_s* transport);
+
+TRTP_END_DECLS
+
+#endif /* TINYMEDIA_RTCP_SESSION_H */
diff --git a/tinyRTP/include/tinyrtp/rtp/trtp_rtp_header.h b/tinyRTP/include/tinyrtp/rtp/trtp_rtp_header.h
new file mode 100644
index 0000000..15d177c
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtp/trtp_rtp_header.h
@@ -0,0 +1,85 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtp_header.h
+ * @brief RTP header.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+ */
+#ifndef TINYRTP_RTP_HEADER_H
+#define TINYRTP_RTP_HEADER_H
+
+#include "tinyrtp_config.h"
+#include "tinymedia/tmedia_codec.h"
+#include "tsk_buffer.h"
+
+TRTP_BEGIN_DECLS
+
+#define TRTP_RTP_HEADER_MIN_SIZE 12
+#define TRTP_RTP_HEADER(self)	((trtp_rtp_header_t*)(self))
+
+typedef struct trtp_rtp_header_s
+{
+	TSK_DECLARE_OBJECT;
+	/* RFC 3550 section 5.1 - RTP Fixed Header Fields
+		0                   1                   2                   3
+		0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |V=2|P|X|  CC   |M|     PT      |       sequence number         |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |                           timestamp                           |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |           synchronization source (SSRC) identifier            |
+	   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+	   |            contributing source (CSRC) identifiers             |
+	   |                             ....                              |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	*/
+	unsigned version:2;
+	unsigned padding:1;
+	unsigned extension:1;
+	unsigned csrc_count:4;
+	unsigned marker:1;
+	unsigned payload_type:7;
+	uint16_t seq_num;
+	uint32_t timestamp;
+	uint32_t ssrc;
+	uint32_t csrc[15];
+
+	// for internal use
+	enum tmedia_codec_id_e codec_id;
+}
+trtp_rtp_header_t;
+
+TINYRTP_API trtp_rtp_header_t* trtp_rtp_header_create_null();
+TINYRTP_API trtp_rtp_header_t* trtp_rtp_header_create(uint32_t ssrc, uint16_t seq_num, uint32_t timestamp, uint8_t payload_type, tsk_bool_t marker);
+TINYRTP_API tsk_size_t trtp_rtp_header_guess_serialbuff_size(const trtp_rtp_header_t *self);
+TINYRTP_API tsk_size_t trtp_rtp_header_serialize_to(const trtp_rtp_header_t *self, void *buffer, tsk_size_t size);
+TINYRTP_API tsk_buffer_t* trtp_rtp_header_serialize(const trtp_rtp_header_t *self);
+TINYRTP_API trtp_rtp_header_t* trtp_rtp_header_deserialize(const void *data, tsk_size_t size);
+
+
+TINYRTP_GEXTERN const tsk_object_def_t *trtp_rtp_header_def_t;
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTP_HEADER_H */
diff --git a/tinyRTP/include/tinyrtp/rtp/trtp_rtp_packet.h b/tinyRTP/include/tinyrtp/rtp/trtp_rtp_packet.h
new file mode 100644
index 0000000..c7f8cf3
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtp/trtp_rtp_packet.h
@@ -0,0 +1,74 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtp_packet.h
+ * @brief RTP packet.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+ */
+#ifndef TINYRTP_RTP_PACKET_H
+#define TINYRTP_RTP_PACKET_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtp/trtp_rtp_header.h"
+
+#include "tsk_object.h"
+
+TRTP_BEGIN_DECLS
+
+
+typedef struct trtp_rtp_packet_s
+{
+	TSK_DECLARE_OBJECT;
+
+	trtp_rtp_header_t* header;
+
+	struct{
+		void* data;
+		const void* data_const; // never free()d. an alternative to "data"
+		tsk_size_t size;
+	} payload;
+	
+	/* extension header as per RFC 3550 section 5.3.1 */
+	struct{
+		void* data;
+		tsk_size_t size; /* contains the first two 16-bit fields */
+	} extension;
+}
+trtp_rtp_packet_t;
+typedef tsk_list_t trtp_rtp_packets_L_t;
+
+TINYRTP_API trtp_rtp_packet_t* trtp_rtp_packet_create_null();
+TINYRTP_API trtp_rtp_packet_t* trtp_rtp_packet_create(uint32_t ssrc, uint16_t seq_num, uint32_t timestamp, uint8_t payload_type, tsk_bool_t marker);
+TINYRTP_API trtp_rtp_packet_t* trtp_rtp_packet_create_2(const trtp_rtp_header_t* header);
+TINYRTP_API tsk_size_t trtp_rtp_packet_guess_serialbuff_size(const trtp_rtp_packet_t *self);
+TINYRTP_API tsk_size_t trtp_rtp_packet_serialize_to(const trtp_rtp_packet_t *self, void* buffer, tsk_size_t size);
+TINYRTP_API tsk_buffer_t* trtp_rtp_packet_serialize(const trtp_rtp_packet_t *self, tsk_size_t num_bytes_pad);
+TINYRTP_API trtp_rtp_packet_t* trtp_rtp_packet_deserialize(const void *data, tsk_size_t size);
+
+
+TINYRTP_GEXTERN const tsk_object_def_t *trtp_rtp_packet_def_t;
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_RTP_PACKET_H */
diff --git a/tinyRTP/include/tinyrtp/rtp/trtp_rtp_session.h b/tinyRTP/include/tinyrtp/rtp/trtp_rtp_session.h
new file mode 100644
index 0000000..475502a
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/rtp/trtp_rtp_session.h
@@ -0,0 +1,42 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtp_session.h
+ * @brief RTP session.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#ifndef TINYMEDIA_RTP_SESSION_H
+#define TINYMEDIA_RTP_SESSION_H
+
+#include "tinyrtp_config.h"
+
+TRTP_BEGIN_DECLS
+
+struct trtp_rtp_packet_s;
+
+typedef int (*trtp_rtp_cb_f)(const void* callback_data, const struct trtp_rtp_packet_s* packet);
+
+TRTP_END_DECLS
+
+#endif /* TINYMEDIA_RTP_SESSION_H */
diff --git a/tinyRTP/include/tinyrtp/trtp.h b/tinyRTP/include/tinyrtp/trtp.h
new file mode 100644
index 0000000..3359a70
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/trtp.h
@@ -0,0 +1,38 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp.h
+ * @brief tinyRTP (Real-time Transport Protocol)  as per RFC 3550.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#ifndef TINYMEDIA_TRTP_H
+#define TINYMEDIA_TRTP_H
+
+#include "tinyrtp_config.h"
+
+TRTP_BEGIN_DECLS
+
+TRTP_END_DECLS
+
+#endif /* TINYMEDIA_TRTP_H */
diff --git a/tinyRTP/include/tinyrtp/trtp_manager.h b/tinyRTP/include/tinyrtp/trtp_manager.h
new file mode 100644
index 0000000..1594f9c
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/trtp_manager.h
@@ -0,0 +1,227 @@
+/*
+* Copyright (C) 2012 Mamadou Diop
+* Copyright (C) 2012-2013 Doubango Telecom <http://www.doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_manager.h
+ * @brief RTP/RTCP manager.
+ */
+#ifndef TINYRTP_MANAGER_H
+#define TINYRTP_MANAGER_H
+
+#include "tinyrtp_config.h"
+
+#include "tinyrtp/rtp/trtp_rtp_session.h"
+#include "tinyrtp/rtcp/trtp_rtcp_session.h"
+#include "tinyrtp/trtp_srtp.h"
+
+#include "tinymedia/tmedia_defaults.h"
+
+#include "tinynet.h"
+
+TRTP_BEGIN_DECLS
+
+struct trtp_rtp_packet_s;
+struct tnet_proxyinfo_s;
+
+/** RTP/RTCP manager */
+typedef struct trtp_manager_s
+{
+	TSK_DECLARE_OBJECT;
+
+	char* local_ip;
+	tsk_bool_t use_ipv6;
+	tsk_bool_t is_started;
+	tsk_bool_t use_rtcp;
+	tsk_bool_t use_rtcpmux;
+	tsk_bool_t is_socket_disabled;
+	tsk_bool_t is_ice_neg_ok;
+	tsk_bool_t is_ice_turn_active;
+	tsk_bool_t is_force_symetric_rtp;
+	tsk_bool_t is_symetric_rtp_checked;
+	tsk_bool_t is_symetric_rtcp_checked;
+	int32_t app_bw_max_upload; // application specific (kbps)
+	int32_t app_bw_max_download; // application specific (kbps)
+
+	tnet_transport_t* transport;
+
+	struct tnet_ice_ctx_s* ice_ctx;
+
+	tsk_timer_manager_handle_t* timer_mgr_global;
+
+	struct{
+		tmedia_rtcweb_type_t local;
+		tmedia_rtcweb_type_t remote;
+	} rtcweb_type;
+    
+    struct {
+        tsk_bool_t auto_detect;
+        struct tnet_proxyinfo_s* info;
+    }
+    proxy;
+
+	struct{
+		uint16_t start;
+		uint16_t stop;
+	} port_range;
+
+	struct{
+		uint16_t seq_num;
+		uint32_t timestamp;
+		uint8_t payload_type;
+        int32_t dscp;
+
+		char* remote_ip;
+		tnet_port_t remote_port;
+		struct sockaddr_storage remote_addr;
+	
+		char* public_ip;
+		tnet_port_t public_port;
+
+		struct{
+			uint32_t local;
+			uint32_t remote;
+		} ssrc;
+
+		struct{
+			const void* usrdata;
+			trtp_rtp_cb_f fun;
+		} cb;
+
+		struct{
+			void* ptr;
+			tsk_size_t size;
+            tsk_size_t index;
+		} serial_buffer;
+	} rtp;
+
+	struct{
+		char* cname;
+		char* remote_ip;
+		tnet_port_t remote_port;
+		struct sockaddr_storage remote_addr;
+		tnet_socket_t* local_socket;
+
+		char* public_ip;
+		tnet_port_t public_port;
+
+		struct{
+			const void* usrdata;
+			trtp_rtcp_cb_f fun;
+		} cb;
+
+		struct trtp_rtcp_session_s* session;
+	} rtcp;
+
+	TSK_DECLARE_SAFEOBJ;
+
+#if HAVE_SRTP	
+	enum tmedia_srtp_type_e srtp_type;
+	enum tmedia_srtp_mode_e srtp_mode;
+	trtp_srtp_state_t srtp_state;
+	trtp_srtp_ctx_xt srtp_contexts[2/*LINE_IDX*/][2/*CRYPTO_TYPE*/];
+	const struct trtp_srtp_ctx_xs* srtp_ctx_neg_local;
+	const struct trtp_srtp_ctx_xs* srtp_ctx_neg_remote;
+
+	struct{
+		char* file_ca;
+		char* file_pbk;
+		char* file_pvk;
+		tsk_bool_t cert_verif;
+		
+		trtp_srtp_state_t state;
+		// enable() could be postponed if net transport not ready yet (e.g. when ICE is ON)
+		tsk_bool_t enable_postponed;
+
+		tsk_bool_t srtp_connected;
+		tsk_bool_t srtcp_connected;
+		tsk_bool_t srtp_handshake_succeed;
+		tsk_bool_t srtcp_handshake_succeed;
+
+		trtp_srtp_crypto_type_t crypto_selected;
+
+		struct{
+			uint64_t timeout;
+			tsk_timer_id_t id;
+		} timer_hanshaking;
+
+		struct{
+			const void* usrdata;
+			trtp_srtp_dtls_cb_f fun;
+		} cb;
+
+		struct{
+			tnet_fingerprint_t fp;
+			tnet_dtls_hash_type_t fp_hash;
+		} remote;
+		struct{
+			tnet_dtls_setup_t setup;
+			tsk_bool_t connection_new;
+		}local;
+	} dtls;
+#endif
+}
+trtp_manager_t;
+
+TINYRTP_API trtp_manager_t* trtp_manager_create(tsk_bool_t use_rtcp, const char* local_ip, tsk_bool_t use_ipv6, enum tmedia_srtp_type_e srtp_type, enum tmedia_srtp_mode_e srtp_mode);
+TINYRTP_API trtp_manager_t* trtp_manager_create_2(struct tnet_ice_ctx_s* ice_ctx, enum tmedia_srtp_type_e srtp_type, enum tmedia_srtp_mode_e srtp_mode);
+TINYRTP_API int trtp_manager_set_ice_ctx(trtp_manager_t* self, struct tnet_ice_ctx_s* ice_ctx);
+TINYRTP_API int trtp_manager_prepare(trtp_manager_t* self);
+#if HAVE_SRTP
+TINYRTP_API int trtp_manager_set_dtls_certs(trtp_manager_t* self, const char* ca, const char* pbk, const char* pvk, tsk_bool_t verify);
+TINYRTP_API int trtp_manager_set_dtls_remote_fingerprint(trtp_manager_t* self, const tnet_fingerprint_t* fp, const char* hash);
+TINYRTP_API enum tnet_dtls_hash_type_e trtp_manager_get_dtls_remote_fingerprint_hash(trtp_manager_t* self);
+TINYRTP_API int trtp_manager_set_dtls_local_setup(trtp_manager_t* self, tnet_dtls_setup_t setup, tsk_bool_t connection_new);
+TINYRTP_API int trtp_manager_set_dtls_callback(trtp_manager_t* self, const void* usrdata, trtp_srtp_dtls_cb_f fun);
+TINYRTP_API const char* trtp_manager_get_dtls_local_fingerprint(trtp_manager_t* self, enum tnet_dtls_hash_type_e hash);
+TINYRTP_API tsk_bool_t trtp_manager_is_dtls_enabled(trtp_manager_t* self);
+TINYRTP_API tsk_bool_t trtp_manager_is_dtls_activated(trtp_manager_t* self);
+TINYRTP_API tsk_bool_t trtp_manager_is_dtls_started(trtp_manager_t* self);
+TINYRTP_API tsk_bool_t trtp_manager_is_srtp_activated(trtp_manager_t* self);
+TINYRTP_API tsk_bool_t trtp_manager_is_srtp_started(trtp_manager_t* self);
+TINYRTP_API int trtp_manager_set_srtp_type_remote(trtp_manager_t* self, enum tmedia_srtp_type_e srtp_type);
+TINYRTP_API int trtp_manager_set_srtp_type_local(trtp_manager_t* self, enum tmedia_srtp_type_e srtp_type, enum tmedia_srtp_mode_e srtp_mode);
+#endif /* HAVE_SRTP */
+TINYRTP_API tsk_bool_t trtp_manager_is_ready(trtp_manager_t* self);
+TINYRTP_API int trtp_manager_set_natt_ctx(trtp_manager_t* self, struct tnet_nat_ctx_s* natt_ctx);
+TINYRTP_API int trtp_manager_set_rtp_callback(trtp_manager_t* self, trtp_rtp_cb_f fun, const void* usrdata);
+TINYRTP_API int trtp_manager_set_rtcp_callback(trtp_manager_t* self, trtp_rtcp_cb_f fun, const void* usrdata);
+TINYRTP_API int trtp_manager_set_rtp_dscp(trtp_manager_t* self, int32_t dscp);
+TINYRTP_API int trtp_manager_set_payload_type(trtp_manager_t* self, uint8_t payload_type);
+TINYRTP_API int trtp_manager_set_rtp_remote(trtp_manager_t* self, const char* remote_ip, tnet_port_t remote_port);
+TINYRTP_API int trtp_manager_set_rtcp_remote(trtp_manager_t* self, const char* remote_ip, tnet_port_t remote_port);
+TINYRTP_API int trtp_manager_set_port_range(trtp_manager_t* self, uint16_t start, uint16_t stop);
+TINYRTP_API int trtp_manager_set_rtcweb_type_remote(trtp_manager_t* self, tmedia_rtcweb_type_t rtcweb_type);
+TINYRTP_API int trtp_manager_set_proxy_auto_detect(trtp_manager_t* self, tsk_bool_t auto_detect);
+TINYRTP_API int trtp_manager_set_proxy_info(trtp_manager_t* self, enum tnet_proxy_type_e type, const char* host, tnet_port_t port, const char* login, const char* password);
+TINYRTP_API int trtp_manager_start(trtp_manager_t* self);
+TINYRTP_API tsk_size_t trtp_manager_send_rtp(trtp_manager_t* self, const void* data, tsk_size_t size, uint32_t duration, tsk_bool_t marker, tsk_bool_t last_packet);
+TINYRTP_API tsk_size_t trtp_manager_send_rtp_packet(trtp_manager_t* self, const struct trtp_rtp_packet_s* packet, tsk_bool_t bypass_encrypt);
+TINYRTP_API int trtp_manager_get_bytes_count(trtp_manager_t* self, uint64_t* bytes_in, uint64_t* bytes_out);
+TINYRTP_API tsk_size_t trtp_manager_send_rtp_raw(trtp_manager_t* self, const void* data, tsk_size_t size);
+TINYRTP_API int trtp_manager_set_app_bandwidth_max(trtp_manager_t* self, int32_t bw_upload_kbps, int32_t bw_download_kbps);
+TINYRTP_API int trtp_manager_signal_pkt_loss(trtp_manager_t* self, uint32_t ssrc_media, const uint16_t* seq_nums, tsk_size_t count);
+TINYRTP_API int trtp_manager_signal_frame_corrupted(trtp_manager_t* self, uint32_t ssrc_media);
+TINYRTP_API int trtp_manager_signal_jb_error(trtp_manager_t* self, uint32_t ssrc_media);
+TINYRTP_API int trtp_manager_stop(trtp_manager_t* self);
+
+TINYRTP_GEXTERN const tsk_object_def_t *trtp_manager_def_t;
+
+TRTP_END_DECLS
+
+#endif /* TINYRTP_MANAGER_H */
diff --git a/tinyRTP/include/tinyrtp/trtp_srtp.h b/tinyRTP/include/tinyrtp/trtp_srtp.h
new file mode 100644
index 0000000..9992bbb
--- /dev/null
+++ b/tinyRTP/include/tinyrtp/trtp_srtp.h
@@ -0,0 +1,131 @@
+/*
+* Copyright (C) 2012 Mamadou Diop
+* Copyright (C) 2012-2013 Doubango Telecom <http://www.doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_srtp.h
+ */
+#ifndef TINYRTP_SRTP_H
+#define TINYRTP_SRTP_H
+
+#include "tinyrtp_config.h"
+
+#if HAVE_SRTP
+#	include "tsk_common.h" 
+#	include <srtp/srtp.h>
+
+struct trtp_manager_s;
+
+typedef enum trtp_srtp_dtls_event_type_e
+{
+	trtp_srtp_dtls_event_type_handshake_failed,
+	trtp_srtp_dtls_event_type_handshake_succeed,
+	trtp_srtp_dtls_event_type_fatal_error,
+	trtp_srtp_dtls_event_type_started
+}
+trtp_srtp_dtls_event_type_t;
+
+typedef enum trtp_srtp_crypto_type_e
+{
+	NONE = -1,
+	HMAC_SHA1_80,
+	HMAC_SHA1_32,
+
+	SRTP_CRYPTO_TYPES_MAX
+}
+trtp_srtp_crypto_type_t;
+
+typedef enum trtp_srtp_state_e
+{
+	trtp_srtp_state_none,
+	/* at this state we're able to generated DTLS "fingerprints" and SDES "crypro" attributes
+     but neither encrypt() nor decrypt() is possible.
+     it's possible to move backward and disable SRTP (e.g. because of negotiation error)
+     it's required to move to this state in order to be able to negotiate SRTP when mode is "optional" or "mandatory"
+     */
+	trtp_srtp_state_enabled,
+	/* at this state both required parameters (e.g. "crypto" attributes) have been successfuly proceeded
+     it's not possible to move backward and disable SRTP
+     if type="SDES": start()ing the engine means we'll be imediately able to encrypt()/decrypt() data
+     if type="DTLS": start()ing the engine doesn't mean we will be able to encrypt()/decrypt() data unless handshaking process successfuly completed
+     */
+	trtp_srtp_state_activated,
+	/* at this state we're able to encrypt()/decrypt() SRTP data
+     */
+	trtp_srtp_state_started
+}
+trtp_srtp_state_t;
+
+typedef int (*trtp_srtp_dtls_cb_f)(const void* usrdata,  enum trtp_srtp_dtls_event_type_e type, const char* reason);
+
+#define TRTP_SRTP_AES_CM_128_HMAC_SHA1_80 "AES_CM_128_HMAC_SHA1_80"
+#define TRTP_SRTP_AES_CM_128_HMAC_SHA1_32 "AES_CM_128_HMAC_SHA1_32"
+
+#define TRTP_SRTP_LINE_IDX_LOCAL	0
+#define TRTP_SRTP_LINE_IDX_REMOTE	1
+
+static const char* trtp_srtp_crypto_type_strings[2] =
+{
+	TRTP_SRTP_AES_CM_128_HMAC_SHA1_80, TRTP_SRTP_AES_CM_128_HMAC_SHA1_32
+};
+
+
+typedef struct trtp_srtp_ctx_internal_xs
+{
+	int32_t tag;
+	trtp_srtp_crypto_type_t crypto_type;
+	char key_str[SRTP_MAX_KEY_LEN];
+	char key_bin[SRTP_MASTER_KEY_LEN];
+    tsk_bool_t have_valid_key;
+
+	srtp_t session;
+	srtp_policy_t policy;
+	tsk_bool_t initialized;
+}
+trtp_srtp_ctx_internal_xt;
+
+typedef struct trtp_srtp_ctx_xs
+{
+	// (rtp == rtcp) for SDES but different for DTLS
+	struct trtp_srtp_ctx_internal_xs rtp;
+	struct trtp_srtp_ctx_internal_xs rtcp;
+}
+trtp_srtp_ctx_xt;
+
+int trtp_srtp_ctx_internal_init(struct trtp_srtp_ctx_internal_xs* ctx, int32_t tag, trtp_srtp_crypto_type_t type, uint32_t ssrc);
+int trtp_srtp_ctx_internal_deinit(struct trtp_srtp_ctx_internal_xs* ctx);
+int trtp_srtp_ctx_init(struct trtp_srtp_ctx_xs* ctx, int32_t tag, trtp_srtp_crypto_type_t type, uint32_t ssrc);
+int trtp_srtp_ctx_deinit(struct trtp_srtp_ctx_xs* ctx);
+TINYRTP_API int trtp_srtp_match_line(const char* crypto_line, int32_t* tag, int32_t* crypto_type, char* key, tsk_size_t key_size);
+
+TINYRTP_API int trtp_srtp_set_crypto(struct trtp_manager_s* rtp_mgr, const char* crypto_line, int32_t idx);
+#define trtp_srtp_set_crypto_local(rtp_mgr, crypto_line) trtp_srtp_set_crypto((rtp_mgr), (crypto_line), TRTP_SRTP_LINE_IDX_LOCAL)
+#define trtp_srtp_set_crypto_remote(rtp_mgr, crypto_line) trtp_srtp_set_crypto((rtp_mgr), (crypto_line), TRTP_SRTP_LINE_IDX_REMOTE)
+TINYRTP_API int trtp_srtp_set_key_and_salt(struct trtp_manager_s* rtp_mgr, trtp_srtp_crypto_type_t crypto_type, const void* key, tsk_size_t key_size, const void* salt, tsk_size_t salt_size, int32_t idx, tsk_bool_t rtp);
+#define trtp_srtp_set_key_and_salt_local(rtp_mgr, crypto_type, key, key_size, salt, salt_size, is_rtp) trtp_srtp_set_key_and_salt((rtp_mgr), (crypto_type), (key), (key_size), (salt), (salt_size), TRTP_SRTP_LINE_IDX_LOCAL, (is_rtp))
+#define trtp_srtp_set_key_and_salt_remote(rtp_mgr, crypto_type, key, key_size, salt, salt_size, is_rtp) trtp_srtp_set_key_and_salt((rtp_mgr), (crypto_type), (key), (key_size), (salt), (salt_size), TRTP_SRTP_LINE_IDX_REMOTE, (is_rtp))
+TINYRTP_API tsk_size_t trtp_srtp_get_local_contexts(struct trtp_manager_s* rtp_mgr, const struct trtp_srtp_ctx_xs ** contexts, tsk_size_t contexts_count);
+TINYRTP_API tsk_bool_t trtp_srtp_is_initialized(struct trtp_manager_s* rtp_mgr);
+TINYRTP_API tsk_bool_t trtp_srtp_is_started(struct trtp_manager_s* rtp_mgr);
+
+#endif /* HAVE_SRTP */
+
+
+
+
+#endif /* TINYRTP_SRTP_H */
diff --git a/tinyRTP/include/tinyrtp_config.h b/tinyRTP/include/tinyrtp_config.h
new file mode 100644
index 0000000..422b68f
--- /dev/null
+++ b/tinyRTP/include/tinyrtp_config.h
@@ -0,0 +1,92 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+
+#ifndef TINYRTP_CONFIG_H
+#define TINYRTP_CONFIG_H
+
+#ifdef __SYMBIAN32__
+#undef _WIN32 /* Because of WINSCW */
+#endif
+
+// Windows (XP/Vista/7/CE and Windows Mobile) macro definition.
+#if defined(WIN32)|| defined(_WIN32) || defined(_WIN32_WCE)
+#	define TRTP_UNDER_WINDOWS	1
+#	if defined(_WIN32_WCE) || defined(UNDER_CE)
+#		define TRTP_UNDER_WINDOWS_CE	1
+#	endif
+#	if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP || WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#		define TRTP_UNDER_WINDOWS_RT		1
+#	endif
+#endif
+
+#if (TRTP_UNDER_WINDOWS || defined(__SYMBIAN32__)) && defined(TINYRTP_EXPORTS)
+# 	define TINYRTP_API		__declspec(dllexport)
+# 	define TINYRTP_GEXTERN __declspec(dllexport)
+#elif (TRTP_UNDER_WINDOWS || defined(__SYMBIAN32__)) && !defined(TINYRTP_IMPORTS_IGNORE)
+# 	define TINYRTP_API __declspec(dllimport)
+# 	define TINYRTP_GEXTERN __declspec(dllimport)
+#else
+#	define TINYRTP_API
+#	define TINYRTP_GEXTERN	extern
+#endif
+
+/* Guards against C++ name mangling 
+*/
+#ifdef __cplusplus
+#	define TRTP_BEGIN_DECLS extern "C" {
+#	define TRTP_END_DECLS }
+#else
+#	define TRTP_BEGIN_DECLS 
+#	define TRTP_END_DECLS
+#endif
+
+/* Disable some well-known warnings
+*/
+#ifdef _MSC_VER
+#	define _CRT_SECURE_NO_WARNINGS
+#endif
+
+/* Detecting C99 compilers
+ */
+#if (__STDC_VERSION__ == 199901L) && !defined(__C99__)
+#	define __C99__
+#endif
+
+#if !defined(TRTP_RTP_VERSION)
+#   define TRTP_RTP_VERSION 2
+#endif /* TRTP_RTP_VERSION */
+
+#include <stdint.h>
+#ifdef __SYMBIAN32__
+#   include <stdlib.h>
+#endif
+
+#if defined(__APPLE__)
+#   include <TargetConditionals.h>
+#   include <Availability.h>
+#endif
+
+#if HAVE_CONFIG_H
+	#include <config.h>
+#endif
+
+#endif // TINYRTP_CONFIG_H
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_header.c b/tinyRTP/src/rtcp/trtp_rtcp_header.c
new file mode 100644
index 0000000..e93772a
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_header.c
@@ -0,0 +1,134 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_memory.h"
+#include "tsk_debug.h"
+/*
+        0                   1                   2                   3
+        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+header |V=2|P|    RC   |   PT=SR=200   |             length            |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+*/
+
+trtp_rtcp_header_t* trtp_rtcp_header_create_null()
+{
+	return tsk_object_new(trtp_rtcp_header_def_t);
+}
+
+trtp_rtcp_header_t* trtp_rtcp_header_create(uint8_t version, uint8_t padding, uint8_t rc, trtp_rtcp_packet_type_t type, uint16_t length_in_bytes)
+{
+	trtp_rtcp_header_t* header;
+	if((header = trtp_rtcp_header_create_null())){
+		header->version = version;
+		header->padding = padding;
+		header->rc = rc;
+		header->type = type;
+		header->length_in_words_minus1 = ((length_in_bytes >> 2) - 1);
+		header->length_in_bytes = length_in_bytes;
+	}
+
+	return header;
+}
+
+int trtp_rtcp_header_serialize_to(const trtp_rtcp_header_t *self, void* data, tsk_size_t size)
+{
+	uint8_t* pdata = (uint8_t*)data;
+	if(!self || !data || size < TRTP_RTCP_HEADER_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	// Octet-0: version(2), Padding(1), RC(5)
+	pdata[0] = ((uint8_t)self->version)<<6 |
+		((uint8_t)self->padding)<<5 |
+		((uint8_t)self->rc);
+	// Octet-1: PT(8)
+	pdata[1] = self->type;
+	// Octet-2 and Octet3: length (16)
+	pdata[2] = self->length_in_words_minus1 >> 8;
+	pdata[3] = self->length_in_words_minus1 & 0xFF;
+	return 0;
+}
+
+trtp_rtcp_header_t* trtp_rtcp_header_deserialize(const void *data, tsk_size_t size)
+{
+	trtp_rtcp_header_t* header = tsk_null;
+	if(trtp_rtcp_header_deserialize_to(&header, data, size) != 0){
+		TSK_DEBUG_ERROR("Failed to deserialize the rtcp header");
+		TSK_OBJECT_SAFE_FREE(header);
+	}
+	return header;
+}
+
+int trtp_rtcp_header_deserialize_to(trtp_rtcp_header_t** self, const void *data, tsk_size_t size)
+{
+	const uint8_t* pdata = (uint8_t*)data;
+	if(!self || !data || size < TRTP_RTCP_HEADER_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	
+	if(!*self && !(*self = trtp_rtcp_header_create_null())){
+		TSK_DEBUG_ERROR("Failed to create new rtcp header");
+		return -3;
+	}
+	(*self)->version = pdata[0] >> 6;
+	(*self)->padding = (pdata[0] >> 5) & 0x01;
+	(*self)->rc = (pdata[0] & 0x1f);
+	(*self)->type = (enum trtp_rtcp_packet_type_e)pdata[1];
+	(*self)->length_in_words_minus1 = tnet_ntohs_2(&pdata[2]);
+	(*self)->length_in_bytes = ((*self)->length_in_words_minus1 + 1) << 2;
+
+	return 0;
+}
+
+//=================================================================================================
+//	RTCP header object definition
+//
+static tsk_object_t* trtp_rtcp_header_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_header_t *header = self;
+	if(header){
+	}
+	return self;
+}
+
+static tsk_object_t* trtp_rtcp_header_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_header_t *header = self;
+	if(header){
+	}
+
+	return self;
+}
+
+static const tsk_object_def_t trtp_rtcp_header_def_s = 
+{
+	sizeof(trtp_rtcp_header_t),
+	trtp_rtcp_header_ctor, 
+	trtp_rtcp_header_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_header_def_t = &trtp_rtcp_header_def_s;
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_packet.c b/tinyRTP/src/rtcp/trtp_rtcp_packet.c
new file mode 100644
index 0000000..d2ec856
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_packet.c
@@ -0,0 +1,255 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_sdes.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_sr.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_rr.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_bye.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_fb.h"
+
+#include "tsk_debug.h"
+
+static tsk_object_t* trtp_rtcp_packet_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_packet_t *packet = self;
+	if(packet){
+	}
+	return self;
+}
+
+static tsk_object_t* trtp_rtcp_packet_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_packet_t *packet = self;
+	if(packet){
+
+	}
+
+	return self;
+}
+
+static const tsk_object_def_t trtp_rtcp_packet_def_s = 
+{
+	sizeof(trtp_rtcp_packet_t),
+	trtp_rtcp_packet_ctor, 
+	trtp_rtcp_packet_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_packet_def_t = &trtp_rtcp_packet_def_s;
+
+trtp_rtcp_packet_t* trtp_rtcp_packet_create(struct trtp_rtcp_header_s* header)
+{
+	trtp_rtcp_packet_t* packet;
+	if((packet = tsk_object_new(trtp_rtcp_packet_def_t)) && header){
+		packet->header = tsk_object_ref(header);
+	}
+	return packet;
+}
+
+
+int trtp_rtcp_packet_init(trtp_rtcp_packet_t* self, uint8_t version, uint8_t padding, uint8_t rc, trtp_rtcp_packet_type_t type, uint16_t length_in_bytes)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(!self->header){
+		self->header = trtp_rtcp_header_create(version, padding, rc, type, length_in_bytes);
+	}
+	else{
+		self->header->version = version;
+		self->header->padding = padding;
+		self->header->rc = rc;
+		self->header->type = type;
+		self->header->length_in_bytes = length_in_bytes;
+		self->header->length_in_words_minus1 = ((length_in_bytes >> 2) - 1);
+	}
+	return 0;
+}
+
+trtp_rtcp_packet_t* trtp_rtcp_packet_deserialize(const void* data, tsk_size_t size)
+{
+	trtp_rtcp_packet_type_t type;
+
+	if(!data || size < TRTP_RTCP_HEADER_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+
+	type = (trtp_rtcp_packet_type_t)((const uint8_t*)data)[1];
+
+	switch(type){
+		case trtp_rtcp_packet_type_rr: return (trtp_rtcp_packet_t*)trtp_rtcp_report_rr_deserialize(data, size);
+		case trtp_rtcp_packet_type_sr: return (trtp_rtcp_packet_t*)trtp_rtcp_report_sr_deserialize(data, size);
+		case trtp_rtcp_packet_type_sdes: return (trtp_rtcp_packet_t*)trtp_rtcp_report_sdes_deserialize(data, size);
+		case trtp_rtcp_packet_type_bye: return (trtp_rtcp_packet_t*)trtp_rtcp_report_bye_deserialize(data, size);
+		case trtp_rtcp_packet_type_rtpfb: return (trtp_rtcp_packet_t*)trtp_rtcp_report_rtpfb_deserialize(data, size);
+		case trtp_rtcp_packet_type_psfb: return (trtp_rtcp_packet_t*)trtp_rtcp_report_psfb_deserialize(data, size);
+		default:
+			{
+				// returns abstract RTCP packet
+				trtp_rtcp_header_t* header;
+				TSK_DEBUG_ERROR("%d not recognized as valid RTCP packet type", (int)type);
+				if((header = trtp_rtcp_header_deserialize(data, size))){
+					trtp_rtcp_packet_t* packet = trtp_rtcp_packet_create(header);
+					TSK_OBJECT_SAFE_FREE(header);
+					return packet;
+				}
+				break;
+			}
+	}
+
+	return tsk_null;
+}
+
+int trtp_rtcp_packet_serialize_to(const trtp_rtcp_packet_t* self, void* data, tsk_size_t size)
+{
+	if(!self || !self->header || !data || !size){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	switch(self->header->type){
+		case trtp_rtcp_packet_type_rr: return trtp_rtcp_report_rr_serialize_to((const trtp_rtcp_report_rr_t*)self, data, size);
+		case trtp_rtcp_packet_type_sr: return trtp_rtcp_report_sr_serialize_to((const trtp_rtcp_report_sr_t*)self, data, size);
+		case trtp_rtcp_packet_type_sdes: return trtp_rtcp_report_sdes_serialize_to((const trtp_rtcp_report_sdes_t*)self, data, size);
+		case trtp_rtcp_packet_type_bye: return trtp_rtcp_report_bye_serialize_to((const trtp_rtcp_report_bye_t*)self, data, size);
+		case trtp_rtcp_packet_type_psfb: return trtp_rtcp_report_psfb_serialize_to((const trtp_rtcp_report_psfb_t*)self, data, size);
+		case trtp_rtcp_packet_type_rtpfb: return trtp_rtcp_report_rtpfb_serialize_to((const trtp_rtcp_report_rtpfb_t*)self, data, size);
+		default:
+			{
+				TSK_DEBUG_ERROR("%d not recognized as valid RTCP packet type", (int)self->header->type);
+				return -2;
+			}
+	}
+}
+
+tsk_buffer_t* trtp_rtcp_packet_serialize(const trtp_rtcp_packet_t* self, tsk_size_t num_bytes_pad)
+{
+	tsk_size_t size = trtp_rtcp_packet_get_size(self);
+	if(self && size){
+		tsk_buffer_t* buffer;
+		const tsk_size_t _size = (size + num_bytes_pad);
+		if((buffer = tsk_buffer_create(tsk_null, _size))){
+			if(trtp_rtcp_packet_serialize_to(self, buffer->data, size) != 0){
+				TSK_OBJECT_SAFE_FREE(buffer);
+			}
+			else buffer->size = size;
+			return buffer;
+		}
+	}
+	return tsk_null;
+}
+
+int trtp_rtcp_packet_add_packet(trtp_rtcp_packet_t* self, trtp_rtcp_packet_t* packet, tsk_bool_t front)
+{
+	trtp_rtcp_packets_L_t* packets = tsk_null;
+	if(!self || !self->header || !packet){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	switch(self->header->type){
+		case trtp_rtcp_packet_type_rr: packets = ((trtp_rtcp_report_rr_t*)self)->packets; break;
+		case trtp_rtcp_packet_type_sr: packets = ((trtp_rtcp_report_sr_t*)self)->packets; break;
+		case trtp_rtcp_packet_type_bye: packets = ((trtp_rtcp_report_bye_t*)self)->packets; break;
+		default: TSK_DEBUG_ERROR("not valid operation for packet type %d", (int)self->header->type); return -2;
+	}
+
+	if(packets){
+		//tsk_size_t packet_size = trtp_rtcp_packet_get_size(packet);
+		packet = tsk_object_ref(packet);
+		// self->header->length_in_bytes += packet_size;
+		// self->header->length_in_words_minus1 = ((self->header->length_in_bytes >> 2) - 1) + 
+		//	((self->header->length_in_bytes & 0x03) ? 1 : 0);
+		tsk_list_push_data(packets, (void**)&packet, !front);
+	}
+
+	return 0;
+}
+
+const trtp_rtcp_packet_t* trtp_rtcp_packet_get_at(const trtp_rtcp_packet_t* self, trtp_rtcp_packet_type_t type, tsk_size_t index)
+{
+	const tsk_list_item_t *item;
+	const trtp_rtcp_packets_L_t* packets = tsk_null;
+	tsk_size_t i;
+
+	if(!self || !self->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	if(self->header->type == type && index == 0){
+		return self;
+	}
+	switch(self->header->type){
+		case trtp_rtcp_packet_type_rr: packets = ((const trtp_rtcp_report_rr_t*)self)->packets; break;
+		case trtp_rtcp_packet_type_sr: packets = ((const trtp_rtcp_report_sr_t*)self)->packets; break;
+		case trtp_rtcp_packet_type_bye: packets = ((const trtp_rtcp_report_bye_t*)self)->packets; break;
+        default: break;
+	}
+
+	i = 0;
+	tsk_list_foreach(item, packets){
+		if(TRTP_RTCP_PACKET(item->data)->header->type == type && i++ >= index){
+			return TRTP_RTCP_PACKET(item->data);
+		}
+	}
+	return tsk_null;
+}
+
+const trtp_rtcp_packet_t* trtp_rtcp_packet_get(const trtp_rtcp_packet_t* self, trtp_rtcp_packet_type_t type)
+{
+	return trtp_rtcp_packet_get_at(self, type, 0);
+}
+
+tsk_size_t trtp_rtcp_packet_get_size(const trtp_rtcp_packet_t* self)
+{
+	if(!self || !self->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+
+	switch(self->header->type){
+		case trtp_rtcp_packet_type_rr: return trtp_rtcp_report_rr_get_size((const trtp_rtcp_report_rr_t*)self);
+		case trtp_rtcp_packet_type_sr: return trtp_rtcp_report_sr_get_size((const trtp_rtcp_report_sr_t*)self);
+		case trtp_rtcp_packet_type_sdes: return trtp_rtcp_report_sdes_get_size((const trtp_rtcp_report_sdes_t*)self);
+		case trtp_rtcp_packet_type_bye: return trtp_rtcp_report_bye_get_size((const trtp_rtcp_report_bye_t*)self);
+		case trtp_rtcp_packet_type_rtpfb: return trtp_rtcp_report_rtpfb_get_size((const trtp_rtcp_report_rtpfb_t*)self);
+		case trtp_rtcp_packet_type_psfb: return trtp_rtcp_report_psfb_get_size((const trtp_rtcp_report_psfb_t*)self);
+		default:
+			{
+				TSK_DEBUG_ERROR("%d not recognized as valid RTCP packet type", (int)self->header->type);
+				return self->header->length_in_bytes;
+			}
+	}
+}
+
+int trtp_rtcp_packet_deinit(trtp_rtcp_packet_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	TSK_OBJECT_SAFE_FREE(self->header);
+	return 0;
+}
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_rblock.c b/tinyRTP/src/rtcp/trtp_rtcp_rblock.c
new file mode 100644
index 0000000..9a85b4b
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_rblock.c
@@ -0,0 +1,153 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_rblock.h"
+
+#include "tnet_endianness.h"
+#include "tsk_debug.h"
+
+/* 6.4.1 SR: Sender Report RTCP Packet
+
+	   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+report |                 SSRC_1 (SSRC of first source)                 |
+block  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  1    | fraction lost |       cumulative number of packets lost       |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       |           extended highest sequence number received           |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       |                      interarrival jitter                      |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       |                         last SR (LSR)                         |
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       |                   delay since last SR (DLSR)                  |
+       +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*/
+static tsk_object_t* trtp_rtcp_rblock_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_rblock_t *block = self;
+	if(block){
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_rblock_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_rblock_t *block = self;
+	if(block){
+	}
+
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_rblock_def_s = 
+{
+	sizeof(trtp_rtcp_rblock_t),
+	trtp_rtcp_rblock_ctor, 
+	trtp_rtcp_rblock_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_rblock_def_t = &trtp_rtcp_rblock_def_s;
+
+trtp_rtcp_rblock_t* trtp_rtcp_rblock_create_null()
+{
+	return tsk_object_new(trtp_rtcp_rblock_def_t);
+}
+
+trtp_rtcp_rblock_t* trtp_rtcp_rblock_deserialize(const void* data, tsk_size_t size)
+{
+	trtp_rtcp_rblock_t* rblock = tsk_null;
+	const uint8_t* pdata = (const uint8_t*)data;
+	if(!data || size < TRTP_RTCP_RBLOCK_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	if((rblock = trtp_rtcp_rblock_create_null())){
+		rblock->ssrc = (uint32_t)tnet_ntohl_2(pdata);
+		rblock->fraction = pdata[4];
+		rblock->cumulative_no_lost = (tnet_ntohl_2(&pdata[5]) >> 8) & 0xFFFFFF;
+		rblock->last_seq = (uint32_t)tnet_ntohl_2(&pdata[8]);
+		rblock->jitter = (uint32_t)tnet_ntohl_2(&pdata[12]);
+		rblock->lsr = (uint32_t)tnet_ntohl_2(&pdata[16]);
+		rblock->dlsr = (uint32_t)tnet_ntohl_2(&pdata[20]);
+	}
+	else{
+		TSK_DEBUG_ERROR("Failed to create report block object");
+	}
+
+	return rblock;
+}
+
+// Up to the
+int trtp_rtcp_rblock_deserialize_list(const void* data, tsk_size_t _size, trtp_rtcp_rblocks_L_t* dest_list)
+{
+	int32_t size = (int32_t)_size;
+	const uint8_t* pdata = (const uint8_t*)data;
+	trtp_rtcp_rblock_t* rblock;
+
+	if(!data || !size || !dest_list){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	while(size >= TRTP_RTCP_RBLOCK_SIZE){
+		if((rblock = trtp_rtcp_rblock_deserialize(pdata, size))){
+			tsk_list_push_back_data(dest_list, (void**)&rblock);
+		}
+		if((size -= TRTP_RTCP_RBLOCK_SIZE) > 0){
+			pdata += TRTP_RTCP_RBLOCK_SIZE;
+		}
+	}
+	return 0;
+}
+
+int trtp_rtcp_rblock_serialize_to(const trtp_rtcp_rblock_t* self, void* data, tsk_size_t size)
+{
+	uint8_t* pdata = (uint8_t*)data;
+	if(!self || !data || size < TRTP_RTCP_RBLOCK_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	pdata[0] = self->ssrc >> 24;
+	pdata[1] = (self->ssrc >> 16) & 0xFF;
+	pdata[2] = (self->ssrc >> 8) & 0xFF;
+	pdata[3] = (self->ssrc & 0xFF);
+	pdata[4] = self->fraction;
+	pdata[5] = (self->cumulative_no_lost >> 16) & 0xFF;
+	pdata[6] = (self->cumulative_no_lost >> 8) & 0xFF;
+	pdata[7] = (self->cumulative_no_lost & 0xFF);
+	pdata[8] = self->last_seq >> 24;
+	pdata[9] = (self->last_seq >> 16) & 0xFF;
+	pdata[10] = (self->last_seq >> 8) & 0xFF;
+	pdata[11] = (self->last_seq & 0xFF);
+	pdata[12] = self->jitter >> 24;
+	pdata[13] = (self->jitter >> 16) & 0xFF;
+	pdata[14] = (self->jitter >> 8) & 0xFF;
+	pdata[15] = (self->jitter & 0xFF);
+	pdata[16] = self->lsr >> 24;
+	pdata[17] = (self->lsr >> 16) & 0xFF;
+	pdata[18] = (self->lsr >> 8) & 0xFF;
+	pdata[19] = (self->lsr & 0xFF);
+	pdata[20] = self->dlsr >> 24;
+	pdata[21] = (self->dlsr >> 16) & 0xFF;
+	pdata[22] = (self->dlsr >> 8) & 0xFF;
+	pdata[23] = (self->dlsr & 0xFF);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_report.c b/tinyRTP/src/rtcp/trtp_rtcp_report.c
new file mode 100644
index 0000000..5fb2697
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_report.c
@@ -0,0 +1,21 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
\ No newline at end of file
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_report_bye.c b/tinyRTP/src/rtcp/trtp_rtcp_report_bye.c
new file mode 100644
index 0000000..0f44608
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_report_bye.c
@@ -0,0 +1,225 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_report_bye.h"
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_memory.h"
+#include "tsk_debug.h"
+
+#define TRTP_RTCP_PACKET_BYE_MIN_SIZE (TRTP_RTCP_HEADER_SIZE + 0/* could have zero ssrc */)
+
+static tsk_object_t* trtp_rtcp_report_bye_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_report_bye_t *bye = self;
+	if(bye){
+		bye->packets = tsk_list_create();
+	}
+	return self;
+}
+
+static tsk_object_t* trtp_rtcp_report_bye_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_report_bye_t *bye = self;
+	if(bye){
+		// deinit self
+		TSK_OBJECT_SAFE_FREE(bye->packets);
+		TSK_FREE(bye->ssrc_list);
+		// deinit base
+		trtp_rtcp_packet_deinit(TRTP_RTCP_PACKET(bye));
+	}
+
+	return self;
+}
+
+static const tsk_object_def_t trtp_rtcp_report_bye_def_s = 
+{
+	sizeof(trtp_rtcp_report_bye_t),
+	trtp_rtcp_report_bye_ctor, 
+	trtp_rtcp_report_bye_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_report_bye_def_t = &trtp_rtcp_report_bye_def_s;
+
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_create_null()
+{
+	trtp_rtcp_report_bye_t* bye;
+	if((bye = (trtp_rtcp_report_bye_t*)tsk_object_new(trtp_rtcp_report_bye_def_t))){
+		trtp_rtcp_packet_init(TRTP_RTCP_PACKET(bye), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_bye, TRTP_RTCP_HEADER_SIZE);
+	}
+	return bye;
+}
+
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_create(struct trtp_rtcp_header_s* header)
+{
+	trtp_rtcp_report_bye_t* bye;
+	if((bye = (trtp_rtcp_report_bye_t*)tsk_object_new(trtp_rtcp_report_bye_def_t))){
+		TRTP_RTCP_PACKET(bye)->header = tsk_object_ref(header);
+	}
+	return bye;
+}
+
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_create_2(uint32_t ssrc)
+{
+	uint32_t* ssrc_list = tsk_malloc(sizeof(uint32_t));
+	if(ssrc_list){
+		trtp_rtcp_report_bye_t* bye;
+		if((bye = (trtp_rtcp_report_bye_t*)tsk_object_new(trtp_rtcp_report_bye_def_t))){
+			trtp_rtcp_packet_init(TRTP_RTCP_PACKET(bye), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_bye, (TRTP_RTCP_HEADER_SIZE + 4));
+			TRTP_RTCP_PACKET(bye)->header->rc = 1;
+			*ssrc_list = ssrc, bye->ssrc_list = ssrc_list, ssrc_list = tsk_null;
+		}
+		TSK_FREE(ssrc_list);
+		return bye;
+	}
+	return tsk_null;
+}
+
+trtp_rtcp_report_bye_t* trtp_rtcp_report_bye_deserialize(const void* data, tsk_size_t _size)
+{
+	trtp_rtcp_report_bye_t* bye = tsk_null;
+	trtp_rtcp_header_t* header = tsk_null;
+	const uint8_t* pdata = (const uint8_t*)data;
+	int32_t size = (int32_t)_size;
+
+	if(!data || size < TRTP_RTCP_PACKET_BYE_MIN_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	
+	if(!(header = trtp_rtcp_header_deserialize(pdata, size))){
+		TSK_DEBUG_ERROR("Failed to deserialize the header");
+		goto bail;
+	}
+	if(header->length_in_bytes < TRTP_RTCP_PACKET_BYE_MIN_SIZE){
+		TSK_DEBUG_ERROR("Too short");
+		goto bail;
+	}
+	
+	if(!(bye = trtp_rtcp_report_bye_create(header))){
+		TSK_DEBUG_ERROR("Failed to create object");
+		goto bail;
+	}
+
+	pdata += (TRTP_RTCP_HEADER_SIZE);
+	size -= (TRTP_RTCP_HEADER_SIZE);
+
+	// SSRCs
+	if(header->rc > 0){
+		tsk_size_t i;
+		if((int32_t)(header->rc * sizeof(uint32_t)) > size){
+			TSK_DEBUG_ERROR("Too short");
+			goto bail;
+		}
+		if(!(bye->ssrc_list = tsk_calloc(header->rc, sizeof(uint32_t)))){
+			goto bail;
+		}
+		for(i = 0; i < header->rc; ++i){
+			bye->ssrc_list[i] = (uint32_t)tnet_ntohl_2(&pdata[0]);
+			pdata += sizeof(uint32_t);
+			size -= sizeof(uint32_t);
+		}
+	}
+	
+	// Other Packets
+	while(size > TRTP_RTCP_HEADER_SIZE){
+		trtp_rtcp_packet_t* packet;
+		
+		if((packet = trtp_rtcp_packet_deserialize(pdata, size))){
+			if((size -= packet->header->length_in_bytes) > 0){
+				pdata += packet->header->length_in_bytes;
+			}
+			tsk_list_push_back_data(bye->packets, (void**)&packet);
+			continue;
+		}
+		break;
+	}
+
+bail:
+	TSK_OBJECT_SAFE_FREE(header);
+	return bye;
+}
+
+int trtp_rtcp_report_bye_serialize_to(const trtp_rtcp_report_bye_t* self, void* data, tsk_size_t size)
+{
+	int ret;
+	tsk_size_t i;
+	uint8_t* pdata = (uint8_t*)data;
+	const tsk_list_item_t* item;
+
+	if(!self || !data || size < trtp_rtcp_report_bye_get_size(self)){
+		return -1;
+	}
+
+	if((ret = trtp_rtcp_header_serialize_to(TRTP_RTCP_PACKET(self)->header, pdata, size))){
+		TSK_DEBUG_ERROR("Failed to serialize the header");
+		return ret;
+	}
+
+	pdata += (TRTP_RTCP_HEADER_SIZE);
+	size -= (TRTP_RTCP_HEADER_SIZE);
+
+	for(i = 0; i < TRTP_RTCP_PACKET(self)->header->rc; ++i){
+		pdata[0] = self->ssrc_list[i] >> 24;
+		pdata[1] = (self->ssrc_list[i] >> 16) & 0xFF;
+		pdata[2] = (self->ssrc_list[i] >> 8) & 0xFF;
+		pdata[3] = (self->ssrc_list[i] & 0xFF);
+		pdata += 4;
+		size -= 4;
+	}
+
+	tsk_list_foreach(item, self->packets){
+		if(!item->data){
+			continue;
+		}
+		if((ret = trtp_rtcp_packet_serialize_to(TRTP_RTCP_PACKET(item->data), pdata, size))){
+			TSK_DEBUG_ERROR("Failed to serialize packet");
+			goto bail;
+		}
+		pdata += TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+		size -= TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+	}
+
+bail:
+	return ret;
+}
+
+tsk_size_t trtp_rtcp_report_bye_get_size(const trtp_rtcp_report_bye_t* self)
+{
+	tsk_size_t size;
+	const tsk_list_item_t* item;
+
+	if(!self || !TRTP_RTCP_PACKET(self)->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+
+	size = TRTP_RTCP_PACKET(self)->header->length_in_bytes;
+	tsk_list_foreach(item, self->packets){
+		if(item->data && TRTP_RTCP_PACKET(item->data)->header){
+			size += TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+		}
+	}
+
+	return size;
+}
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_report_fb.c b/tinyRTP/src/rtcp/trtp_rtcp_report_fb.c
new file mode 100644
index 0000000..bbc80b1
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_report_fb.c
@@ -0,0 +1,651 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WArtpfbANTY; without even the implied wartpfbanty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_report_fb.h"
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_string.h"
+#include "tsk_memory.h"
+#include "tsk_debug.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#define TRTP_RTCP_PACKET_FB_MIN_SIZE	(TRTP_RTCP_HEADER_SIZE + 4 + 4)
+
+static int _trtp_rtcp_report_fb_deserialize(const void* data, tsk_size_t _size, trtp_rtcp_header_t** header, uint32_t* ssrc_sender, uint32_t* ssrc_media_src)
+{
+	const uint8_t* pdata = data;
+	if(!data || !header || _size < TRTP_RTCP_PACKET_FB_MIN_SIZE || (_size & 0x03)){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	
+	if(!(*header = trtp_rtcp_header_deserialize(pdata, _size))){
+		TSK_DEBUG_ERROR("Failed to deserialize the header");
+		return -3;
+	}
+	if((*header)->length_in_bytes < TRTP_RTCP_PACKET_FB_MIN_SIZE){
+		TSK_DEBUG_ERROR("Too short");
+		return -4;
+	}
+	else if((*header)->length_in_bytes > _size){
+		TSK_DEBUG_ERROR("Too long");
+		return -5;
+	}
+
+	*ssrc_sender = (uint32_t)tnet_ntohl_2(&pdata[4]);
+	*ssrc_media_src = (uint32_t)tnet_ntohl_2(&pdata[8]);
+	return 0;
+}
+
+
+static int _trtp_rtcp_report_fb_serialize_to(const trtp_rtcp_report_fb_t* self, void* data, tsk_size_t size)
+{
+	int ret;
+	uint8_t* pdata = (uint8_t*)data;
+
+	if(!self || !data || size < TRTP_RTCP_PACKET_FB_MIN_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if((ret = trtp_rtcp_header_serialize_to(TRTP_RTCP_PACKET(self)->header, pdata, size))){
+		TSK_DEBUG_ERROR("Failed to serialize the header");
+		return ret;
+	}
+	
+	pdata[TRTP_RTCP_HEADER_SIZE] = self->ssrc_sender >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 1] = (self->ssrc_sender >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 2] = (self->ssrc_sender >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 3] = (self->ssrc_sender & 0xFF);
+	pdata[TRTP_RTCP_HEADER_SIZE + 4] = self->ssrc_media >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 5] = (self->ssrc_media >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 6] = (self->ssrc_media >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 7] = (self->ssrc_media & 0xFF);
+	
+	return 0;
+}
+
+
+
+static tsk_object_t* trtp_rtcp_report_rtpfb_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_report_rtpfb_t *rtpfb = self;
+	if(rtpfb){
+		
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_report_rtpfb_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_report_rtpfb_t *rtpfb = self;
+	if(rtpfb){
+		// deinit self
+		switch(rtpfb->fci_type){
+			case trtp_rtcp_rtpfb_fci_type_nack:
+				{
+					TSK_FREE(rtpfb->nack.pid);
+					TSK_FREE(rtpfb->nack.blp);
+					break;
+				}
+			case trtp_rtcp_rtpfb_fci_type_tmmbn:
+				{
+					TSK_FREE(rtpfb->tmmbn.ssrc);
+					TSK_FREE(rtpfb->tmmbn.MxTBR_Exp);
+					TSK_FREE(rtpfb->tmmbn.MxTBR_Mantissa);
+					TSK_FREE(rtpfb->tmmbn.MeasuredOverhead);
+					break;
+				}
+		}
+		// deinit base
+		trtp_rtcp_packet_deinit(TRTP_RTCP_PACKET(rtpfb));
+	}
+
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_report_rtpfb_def_s = 
+{
+	sizeof(trtp_rtcp_report_rtpfb_t),
+	trtp_rtcp_report_rtpfb_ctor, 
+	trtp_rtcp_report_rtpfb_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_report_rtpfb_def_t = &trtp_rtcp_report_rtpfb_def_s;
+
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create_null()
+{
+	trtp_rtcp_report_rtpfb_t* rtpfb;
+	if((rtpfb = (trtp_rtcp_report_rtpfb_t*)tsk_object_new(trtp_rtcp_report_rtpfb_def_t))){
+		trtp_rtcp_packet_init(TRTP_RTCP_PACKET(rtpfb), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_rtpfb, TRTP_RTCP_PACKET_FB_MIN_SIZE);
+	}
+	return rtpfb;
+}
+
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create(trtp_rtcp_header_t* header)
+{
+	trtp_rtcp_report_rtpfb_t* rtpfb;
+	if((rtpfb = (trtp_rtcp_report_rtpfb_t*)tsk_object_new(trtp_rtcp_report_rtpfb_def_t))){
+		TRTP_RTCP_PACKET(rtpfb)->header = tsk_object_ref(header);
+	}
+	return rtpfb;
+}
+
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create_2(trtp_rtcp_rtpfb_fci_type_t fci_type, uint32_t ssrc_sender, uint32_t ssrc_media_src)
+{
+	trtp_rtcp_report_rtpfb_t* rtpfb;
+	if((rtpfb = trtp_rtcp_report_rtpfb_create_null())){
+		rtpfb->fci_type = TRTP_RTCP_PACKET(rtpfb)->header->rc = fci_type;
+		TRTP_RTCP_REPORT_FB(rtpfb)->ssrc_sender = ssrc_sender;
+		TRTP_RTCP_REPORT_FB(rtpfb)->ssrc_media = ssrc_media_src;
+	}
+	return rtpfb;
+}
+
+// seq_nums[n] must be in [seq_nums[0], seq_nums[0] + 16] and > seq_nums[n - 1]
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_create_nack(uint32_t ssrc_sender, uint32_t ssrc_media_src, const uint16_t* seq_nums, tsk_size_t count)
+{
+	trtp_rtcp_report_rtpfb_t* rtpfb;
+	if(!seq_nums || !count){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	if((rtpfb = trtp_rtcp_report_rtpfb_create_2(trtp_rtcp_rtpfb_fci_type_nack, ssrc_sender, ssrc_media_src))){
+		tsk_size_t i, j;
+		rtpfb->nack.count = 1; // max = 16
+		rtpfb->nack.blp = tsk_malloc(sizeof(uint16_t));
+		rtpfb->nack.pid = tsk_malloc(sizeof(uint16_t));
+		if(!rtpfb->nack.blp || !rtpfb->nack.pid){
+			TSK_OBJECT_SAFE_FREE(rtpfb);
+			return tsk_null;
+		}
+		rtpfb->nack.pid[0] = seq_nums[0];
+		rtpfb->nack.blp[0] = 0;
+		for(i = 1; i <= 16 && i < count; ++i){
+			j = seq_nums[i] - rtpfb->nack.pid[0];
+			rtpfb->nack.blp[0] |= (1 << (j - 1));
+		}
+
+		TRTP_RTCP_PACKET(rtpfb)->header->length_in_bytes += (uint32_t)(rtpfb->nack.count << 2);
+		TRTP_RTCP_PACKET(rtpfb)->header->length_in_words_minus1 = ((TRTP_RTCP_PACKET(rtpfb)->header->length_in_bytes >> 2) - 1);
+	}
+	return rtpfb;
+}
+
+
+trtp_rtcp_report_rtpfb_t* trtp_rtcp_report_rtpfb_deserialize(const void* data, tsk_size_t _size)
+{
+	trtp_rtcp_report_rtpfb_t* rtpfb = tsk_null;
+	trtp_rtcp_header_t* header = tsk_null;
+	uint32_t ssrc_sender, ssrc_media_src;
+
+	if(_trtp_rtcp_report_fb_deserialize(data, _size, &header, &ssrc_sender, &ssrc_media_src) == 0){
+		if((rtpfb = trtp_rtcp_report_rtpfb_create(header))){
+			const uint8_t* pdata = ((const uint8_t*)data) + TRTP_RTCP_PACKET_FB_MIN_SIZE;
+			tsk_size_t size = (header->length_in_bytes - TRTP_RTCP_PACKET_FB_MIN_SIZE), i;
+			
+			TRTP_RTCP_REPORT_FB(rtpfb)->ssrc_sender = ssrc_sender;
+			TRTP_RTCP_REPORT_FB(rtpfb)->ssrc_media = ssrc_media_src;
+
+			switch(rtpfb->fci_type = (trtp_rtcp_rtpfb_fci_type_t)header->rc){
+				case trtp_rtcp_rtpfb_fci_type_nack:
+					{
+						if((rtpfb->nack.count = (size >> 2)) > 0){
+							rtpfb->nack.pid = tsk_realloc(rtpfb->nack.pid, (rtpfb->nack.count * sizeof(uint16_t)));
+							rtpfb->nack.blp = tsk_realloc(rtpfb->nack.blp, (rtpfb->nack.count * sizeof(uint16_t)));
+							for(i = 0; i < rtpfb->nack.count; ++i){
+								if(rtpfb->nack.pid) rtpfb->nack.pid[i] = tnet_ntohs_2(&pdata[0]);
+								if(rtpfb->nack.blp) rtpfb->nack.blp[i] = tnet_ntohs_2(&pdata[2]);
+								pdata += 4;
+							}
+						}
+						break;
+					}
+				case trtp_rtcp_rtpfb_fci_type_tmmbn:
+					{
+						TSK_DEBUG_INFO("TMMBN");
+						if((rtpfb->tmmbn.count = (size >> 3)) > 0){
+							uint32_t u32;
+							rtpfb->tmmbn.ssrc = tsk_realloc(rtpfb->tmmbn.ssrc, (rtpfb->tmmbn.count * sizeof(uint32_t)));
+							rtpfb->tmmbn.MxTBR_Exp = tsk_realloc(rtpfb->tmmbn.MxTBR_Exp, (rtpfb->tmmbn.count * sizeof(uint16_t)));
+							rtpfb->tmmbn.MxTBR_Mantissa = tsk_realloc(rtpfb->tmmbn.MxTBR_Mantissa, (rtpfb->tmmbn.count * sizeof(uint32_t)));
+							rtpfb->tmmbn.MeasuredOverhead = tsk_realloc(rtpfb->tmmbn.MeasuredOverhead, (rtpfb->tmmbn.count * sizeof(uint16_t)));
+							for(i = 0; i < rtpfb->tmmbn.count; ++i){
+								if(rtpfb->tmmbn.ssrc) rtpfb->tmmbn.ssrc[i] = (uint32_t)tnet_ntohl_2(&pdata[0]);
+								u32 = (uint32_t)tnet_ntohl_2(&pdata[4]);
+								if(rtpfb->tmmbn.MxTBR_Exp) rtpfb->tmmbn.MxTBR_Exp[i] = (u32 >> 26);
+								if(rtpfb->tmmbn.MxTBR_Mantissa) rtpfb->tmmbn.MxTBR_Mantissa[i] = ((u32 >> 9) & 0x1FFFF);
+								if(rtpfb->tmmbn.MeasuredOverhead) rtpfb->tmmbn.MeasuredOverhead[i] = (u32 & 0x1FF);
+								pdata += 8;
+							}
+						}
+						break;
+					}
+
+				default:
+					{
+						TSK_DEBUG_ERROR("Unsupported Feedback message type %d", (int)rtpfb->fci_type);
+						break;
+					}
+			}
+		}
+	}	
+
+	TSK_OBJECT_SAFE_FREE(header);
+	return rtpfb;
+}
+
+int trtp_rtcp_report_rtpfb_serialize_to(const trtp_rtcp_report_rtpfb_t* self, void* data, tsk_size_t size)
+{
+	int ret;
+	uint8_t* pdata = (uint8_t*)data;
+
+	if(!self || !data || size < trtp_rtcp_report_rtpfb_get_size(self)){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if((ret = _trtp_rtcp_report_fb_serialize_to(TRTP_RTCP_REPORT_FB(self), pdata, size))){
+		TSK_DEBUG_ERROR("Failed to serialize FB message");
+		return ret;
+	}
+	pdata += TRTP_RTCP_PACKET_FB_MIN_SIZE;
+	size -= TRTP_RTCP_PACKET_FB_MIN_SIZE;
+	
+	switch(self->fci_type){
+		case trtp_rtcp_rtpfb_fci_type_nack:
+			{
+				tsk_size_t i;
+				for(i = 0; i < self->nack.count; ++i){
+					pdata[0] = self->nack.pid[i] >> 8;
+					pdata[1] = (self->nack.pid[i] & 0xFF);
+					pdata[2] = self->nack.blp[i] >> 8;
+					pdata[3] = (self->nack.blp[i] & 0xFF);
+					pdata += 4;
+				}
+				break;
+			}
+		default:
+			{
+				TSK_DEBUG_ERROR("Not implemented");
+				return -2;
+			}
+	}
+	return 0;
+}
+
+tsk_size_t trtp_rtcp_report_rtpfb_get_size(const trtp_rtcp_report_rtpfb_t* self)
+{
+	if(!self || !TRTP_RTCP_PACKET(self)->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	return TRTP_RTCP_PACKET(self)->header->length_in_bytes;
+}
+
+
+
+
+
+
+
+
+
+static tsk_object_t* trtp_rtcp_report_psfb_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_report_psfb_t *psfb = self;
+	if(psfb){
+		
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_report_psfb_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_report_psfb_t *psfb = self;
+	if(psfb){
+		// deinit self
+		switch(psfb->fci_type){
+			case trtp_rtcp_psfb_fci_type_pli: 
+				break;
+			case trtp_rtcp_psfb_fci_type_sli:
+				TSK_FREE(psfb->sli.first);
+				TSK_FREE(psfb->sli.number);
+				TSK_FREE(psfb->sli.pic_id);
+				break;
+			case trtp_rtcp_psfb_fci_type_rpsi:
+				TSK_FREE(psfb->rpsi.bytes);
+				break;
+			case trtp_rtcp_psfb_fci_type_fir:
+				TSK_FREE(psfb->fir.ssrc);
+				TSK_FREE(psfb->fir.seq_num);
+				break;
+			case trtp_rtcp_psfb_fci_type_afb:
+				switch(psfb->afb.type){
+					case trtp_rtcp_psfb_afb_type_none:
+						TSK_FREE(psfb->afb.none.bytes);
+						break;
+					case trtp_rtcp_psfb_afb_type_remb:
+						TSK_FREE(psfb->afb.remb.ssrc_feedbacks);
+						break;
+				}
+				break;
+		}
+		// deinit base
+		trtp_rtcp_packet_deinit(TRTP_RTCP_PACKET(psfb));
+	}
+
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_report_psfb_def_s = 
+{
+	sizeof(trtp_rtcp_report_psfb_t),
+	trtp_rtcp_report_psfb_ctor, 
+	trtp_rtcp_report_psfb_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_report_psfb_def_t = &trtp_rtcp_report_psfb_def_s;
+
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_null()
+{
+	trtp_rtcp_report_psfb_t* psfb;
+	if((psfb = (trtp_rtcp_report_psfb_t*)tsk_object_new(trtp_rtcp_report_psfb_def_t))){
+		trtp_rtcp_packet_init(TRTP_RTCP_PACKET(psfb), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_psfb, TRTP_RTCP_PACKET_FB_MIN_SIZE);
+	}
+	return psfb;
+}
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create(trtp_rtcp_header_t* header)
+{
+	trtp_rtcp_report_psfb_t* psfb;
+	if((psfb = (trtp_rtcp_report_psfb_t*)tsk_object_new(trtp_rtcp_report_psfb_def_t))){
+		TRTP_RTCP_PACKET(psfb)->header = tsk_object_ref(header);
+	}
+	return psfb;
+}
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_2(trtp_rtcp_psfb_fci_type_t fci_type, uint32_t ssrc_sender, uint32_t ssrc_media_src)
+{
+	trtp_rtcp_report_psfb_t* psfb;
+	if((psfb = trtp_rtcp_report_psfb_create_null())){
+		TRTP_RTCP_PACKET(psfb)->header->rc = psfb->fci_type = fci_type;
+		TRTP_RTCP_REPORT_FB(psfb)->ssrc_sender = ssrc_sender;
+		TRTP_RTCP_REPORT_FB(psfb)->ssrc_media = ssrc_media_src;
+	}
+	return psfb;
+}
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_pli(uint32_t ssrc_sender, uint32_t ssrc_media_src)
+{
+	return trtp_rtcp_report_psfb_create_2(trtp_rtcp_psfb_fci_type_pli, ssrc_sender, ssrc_media_src);
+}
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_fir(uint8_t seq_num, uint32_t ssrc_sender, uint32_t ssrc_media_src)
+{
+	trtp_rtcp_report_psfb_t* psfb;
+	if((psfb = trtp_rtcp_report_psfb_create_2(trtp_rtcp_psfb_fci_type_fir, ssrc_sender, ssrc_media_src))){
+		psfb->fir.ssrc = tsk_malloc(sizeof(uint32_t));
+		psfb->fir.seq_num = tsk_malloc(sizeof(uint8_t));
+		if(!psfb->fir.ssrc || !psfb->fir.seq_num){
+			TSK_OBJECT_SAFE_FREE(psfb);
+			return tsk_null;
+		}
+		psfb->fir.count = 1;
+		psfb->fir.seq_num[0] = seq_num;
+		psfb->fir.ssrc[0] = ssrc_media_src;
+		TRTP_RTCP_PACKET(psfb)->header->length_in_bytes += (uint32_t)(psfb->fir.count << 3);
+		TRTP_RTCP_PACKET(psfb)->header->length_in_words_minus1 = ((TRTP_RTCP_PACKET(psfb)->header->length_in_bytes >> 2) - 1);
+	}
+	return psfb;
+}
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_create_afb_remb(uint32_t ssrc_sender, const uint32_t* ssrc_media_src_list, uint32_t ssrc_media_src_list_count, uint32_t bitrate/*in bps*/)
+{
+	trtp_rtcp_report_psfb_t* psfb;
+	// draft-alvestrand-rmcat-remb-02 2.2: SSRC media source always equal to zero
+	if((psfb = trtp_rtcp_report_psfb_create_2(trtp_rtcp_psfb_fci_type_afb, ssrc_sender, 0))){
+		static const uint32_t __max_mantissa = 131072;
+		psfb->afb.type = trtp_rtcp_psfb_afb_type_remb;
+		psfb->afb.remb.exp = 0;
+		if(bitrate <= __max_mantissa){
+			psfb->afb.remb.mantissa = bitrate;
+		}
+		else{
+			while(bitrate >= (__max_mantissa << psfb->afb.remb.exp) && psfb->afb.remb.exp < 63) ++psfb->afb.remb.exp;
+			psfb->afb.remb.mantissa = (bitrate >> psfb->afb.remb.exp);
+		}
+		if(ssrc_media_src_list && ssrc_media_src_list_count > 0 && (psfb->afb.remb.ssrc_feedbacks = (uint32_t*)tsk_malloc(ssrc_media_src_list_count << 2))){
+			uint32_t i;
+			psfb->afb.remb.num_ssrc = ssrc_media_src_list_count;
+			for(i = 0; i < ssrc_media_src_list_count; ++i){
+				psfb->afb.remb.ssrc_feedbacks[i] = ssrc_media_src_list[i];
+			}
+		}
+		TRTP_RTCP_PACKET(psfb)->header->length_in_bytes += 8; /*'R' 'E' 'M' 'B', Num SSRC, BR Exp, BR Mantissa */
+		TRTP_RTCP_PACKET(psfb)->header->length_in_bytes += (psfb->afb.remb.num_ssrc << 2);
+		TRTP_RTCP_PACKET(psfb)->header->length_in_words_minus1 = ((TRTP_RTCP_PACKET(psfb)->header->length_in_bytes >> 2) - 1);
+	}
+	return psfb;
+}
+
+trtp_rtcp_report_psfb_t* trtp_rtcp_report_psfb_deserialize(const void* data, tsk_size_t _size)
+{
+	trtp_rtcp_report_psfb_t* psfb = tsk_null;
+	trtp_rtcp_header_t* header = tsk_null;
+	uint32_t ssrc_sender, ssrc_media_src;
+
+	if(_trtp_rtcp_report_fb_deserialize(data, _size, &header, &ssrc_sender, &ssrc_media_src) == 0){
+		if((psfb = trtp_rtcp_report_psfb_create(header))){
+			const uint8_t* pdata = ((const uint8_t*)data) + TRTP_RTCP_PACKET_FB_MIN_SIZE;
+			tsk_size_t size = (header->length_in_bytes - TRTP_RTCP_PACKET_FB_MIN_SIZE);
+
+			TRTP_RTCP_REPORT_FB(psfb)->ssrc_sender = ssrc_sender;
+			TRTP_RTCP_REPORT_FB(psfb)->ssrc_media = ssrc_media_src;
+
+			switch((psfb->fci_type = header->rc)/* FMT for RTCP-FB messages */){
+				case trtp_rtcp_psfb_fci_type_pli:
+					{
+						// No FCI in PLI
+						// TSK_DEBUG_INFO("PLI");
+						break;
+					}
+				case trtp_rtcp_psfb_fci_type_sli:
+					{
+						tsk_size_t sli_count = (size >> 2), i;
+						uint32_t u32;
+						if(sli_count == 0){
+							TSK_DEBUG_ERROR("Too short");
+							goto bail;
+						}
+						psfb->sli.first = tsk_realloc(psfb->sli.first, (sli_count * sizeof(uint16_t)));
+						psfb->sli.number = tsk_realloc(psfb->sli.number, (sli_count * sizeof(uint16_t)));
+						psfb->sli.pic_id = tsk_realloc(psfb->sli.pic_id, (sli_count * sizeof(uint16_t)));
+						for(i = 0; i < sli_count; ++i){
+							u32 = (uint32_t)tnet_ntohl_2(&pdata[i >> 2]);
+							if(psfb->sli.first) psfb->sli.first[i] = (u32 >> 19);
+							if(psfb->sli.number) psfb->sli.number[i] = (u32 >> 6) & 0x1FFF;
+							if(psfb->sli.pic_id) psfb->sli.pic_id[i] = u32 & 0x3F;
+						}
+						
+						break;
+					}
+				case trtp_rtcp_psfb_fci_type_rpsi:
+					{
+						uint16_t u16;
+						if(size < 2){
+							TSK_DEBUG_ERROR("Too short");
+							goto bail;
+						}
+						u16 = tnet_ntohs_2(&pdata[0]);
+						psfb->rpsi.pb = (u16 >> 8);
+						psfb->rpsi.pt = (u16 & 0x7F);
+						if((psfb->rpsi.bytes = tsk_calloc((size - 2), sizeof(uint8_t)))){
+							memcpy(psfb->rpsi.bytes, &pdata[2], (size - 2));
+						}
+						break;
+					}
+				case trtp_rtcp_psfb_fci_type_fir:
+					{
+						tsk_size_t fir_count = (size >> 3), i;
+						if(fir_count == 0){
+							TSK_DEBUG_ERROR("Too short");
+							goto bail;
+						}
+						psfb->fir.count = fir_count;
+						psfb->fir.ssrc = tsk_realloc(psfb->fir.seq_num, (fir_count * sizeof(uint32_t)));
+						psfb->fir.seq_num = tsk_realloc(psfb->fir.seq_num, (fir_count * sizeof(uint8_t)));
+						for(i = 0; i < fir_count; ++i){
+							if(psfb->fir.ssrc) psfb->fir.ssrc[i] = (uint32_t)tnet_ntohl_2(&pdata[0]);
+							if(psfb->fir.seq_num) psfb->fir.seq_num[i] = pdata[4];
+							pdata+=8;
+						}
+						break;
+					}
+				case trtp_rtcp_psfb_fci_type_afb:
+					{
+						if(size > 0){
+							psfb->afb.type = trtp_rtcp_psfb_afb_type_none;
+							// REMB (http://tools.ietf.org/html/draft-alvestrand-rmcat-remb-02) ?
+							if(size > 4 && tsk_strniequals(pdata, "REMB", 4)){
+								uint32_t _u32;
+								if(size < 8){ // REMB, Num SSRC, BR Exp, BR Mantissa
+									TSK_DEBUG_ERROR("Too short");
+									goto bail;
+								}
+								psfb->afb.type = trtp_rtcp_psfb_afb_type_remb;
+								_u32 = (uint32_t)tnet_ntohl_2(&pdata[4]);
+								psfb->afb.remb.num_ssrc = ((_u32 >> 24) & 0xFF);
+								if((psfb->afb.remb.num_ssrc << 2) != (size - 8)){
+									TSK_DEBUG_ERROR("Invalid size");
+									psfb->afb.remb.num_ssrc = 0;
+									goto bail;
+								}
+								psfb->afb.remb.exp = ((_u32 >> 18) & 0x3F);
+								psfb->afb.remb.mantissa = (_u32 & 0x3FFFF);
+								if((psfb->afb.remb.ssrc_feedbacks = tsk_malloc(psfb->afb.remb.num_ssrc << 2))){
+									for(_u32 = 0; _u32 < psfb->afb.remb.num_ssrc; ++_u32){
+										psfb->afb.remb.ssrc_feedbacks[_u32] = (uint32_t)tnet_ntohl_2(&pdata[8 + (_u32 << 2)]);
+									}
+								}
+							}
+							else{
+								if((psfb->afb.none.bytes = tsk_calloc(size, sizeof(uint8_t)))){
+									memcpy(psfb->afb.none.bytes, &pdata[0], size);
+								}
+							}
+						}
+						break;
+					}
+				default:
+					{
+						TSK_DEBUG_ERROR("%d not a valid FCI", psfb->fci_type);
+						goto bail;
+					}
+			}
+		}
+	}	
+
+bail:
+	TSK_OBJECT_SAFE_FREE(header);
+	return psfb;
+}
+
+int trtp_rtcp_report_psfb_serialize_to(const trtp_rtcp_report_psfb_t* self, void* data, tsk_size_t size)
+{
+	int ret;
+	uint8_t* pdata = (uint8_t*)data;
+
+	if(!self || !data || size < trtp_rtcp_report_psfb_get_size(self)){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if((ret = _trtp_rtcp_report_fb_serialize_to(TRTP_RTCP_REPORT_FB(self), pdata, size))){
+		TSK_DEBUG_ERROR("Failed to serialize FB message");
+		return ret;
+	}
+	pdata += TRTP_RTCP_PACKET_FB_MIN_SIZE;
+	size -= TRTP_RTCP_PACKET_FB_MIN_SIZE;
+	
+	switch(self->fci_type){
+		case trtp_rtcp_psfb_fci_type_pli:
+			{
+				// No FCI in PLI
+				break;
+			}
+		case trtp_rtcp_psfb_fci_type_fir:
+			{
+				tsk_size_t i;
+				for(i = 0; i < self->fir.count; ++i){
+					pdata[0] = self->fir.ssrc[i] >> 24;
+					pdata[1] = (self->fir.ssrc[i] >> 16) & 0xFF;
+					pdata[2] = (self->fir.ssrc[i] >> 8) & 0xFF;
+					pdata[3] = (self->fir.ssrc[i] & 0xFF);
+					pdata[4] = self->fir.seq_num[i];
+					pdata += 8; // SSRC (4), Seq nr(1), Reserved(3)
+				}
+				break;
+			}
+		case trtp_rtcp_psfb_fci_type_afb:
+			{
+				if(self->afb.type == trtp_rtcp_psfb_afb_type_remb){
+					tsk_size_t i;
+					// 'R' 'E' 'M' 'B'
+					pdata[0] = 'R', pdata[1] = 'E', pdata[2] = 'M', pdata[3] = 'B';
+					// |  Num SSRC     | BR Exp    |  BR Mantissa
+					pdata[4] = self->afb.remb.num_ssrc; // 8bits
+					pdata[5] = (self->afb.remb.exp << 2) & 0xFC;// 6bits
+					// 18bits
+					pdata[5] |= (self->afb.remb.mantissa >> 16) & 0x3;
+					pdata[6] = (self->afb.remb.mantissa >> 8) & 0xFF;
+					pdata[7] = (self->afb.remb.mantissa & 0xFF);
+					if(self->afb.remb.ssrc_feedbacks){
+						for(i = 0; i < self->afb.remb.num_ssrc; ++i){
+							pdata[8 + (i<<2)] = self->afb.remb.ssrc_feedbacks[i] >> 24;
+							pdata[8 + (i<<2) + 1] = (self->afb.remb.ssrc_feedbacks[i] >> 16) & 0xFF;
+							pdata[8 + (i<<2) + 2] = (self->afb.remb.ssrc_feedbacks[i] >> 8) & 0xFF;
+							pdata[8 + (i<<2) + 3] = (self->afb.remb.ssrc_feedbacks[i] & 0xFF);
+						}
+					}
+				}
+				else{
+					TSK_DEBUG_ERROR("Not implemented yet");
+					return -1;
+				}
+				break;
+			}
+		default:
+			{
+				TSK_DEBUG_ERROR("Not implemented yet");
+				return -1;
+			}
+	}
+	
+	return ret;
+}
+
+tsk_size_t trtp_rtcp_report_psfb_get_size(const trtp_rtcp_report_psfb_t* self)
+{
+	if(!self || !TRTP_RTCP_PACKET(self)->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	return TRTP_RTCP_PACKET(self)->header->length_in_bytes;
+}
\ No newline at end of file
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_report_rr.c b/tinyRTP/src/rtcp/trtp_rtcp_report_rr.c
new file mode 100644
index 0000000..2a38a4c
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_report_rr.c
@@ -0,0 +1,232 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_report_rr.h"
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_debug.h"
+
+#define TRTP_RTCP_PACKET_RR_MIN_SIZE	(TRTP_RTCP_HEADER_SIZE + 4)
+
+static tsk_object_t* trtp_rtcp_report_rr_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_report_rr_t *rr = self;
+	if(rr){
+		rr->packets = tsk_list_create();
+		rr->blocks = tsk_list_create();
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_report_rr_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_report_rr_t *rr = self;
+	if(rr){
+		// deinit self
+		TSK_OBJECT_SAFE_FREE(rr->packets);
+		TSK_OBJECT_SAFE_FREE(rr->blocks);
+		// deinit base
+		trtp_rtcp_packet_deinit(TRTP_RTCP_PACKET(rr));
+	}
+
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_report_rr_def_s = 
+{
+	sizeof(trtp_rtcp_report_rr_t),
+	trtp_rtcp_report_rr_ctor, 
+	trtp_rtcp_report_rr_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_report_rr_def_t = &trtp_rtcp_report_rr_def_s;
+
+
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_create_null()
+{
+	trtp_rtcp_report_rr_t* rr;
+	if((rr = (trtp_rtcp_report_rr_t*)tsk_object_new(trtp_rtcp_report_rr_def_t))){
+		trtp_rtcp_packet_init(TRTP_RTCP_PACKET(rr), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_rr, (TRTP_RTCP_HEADER_SIZE + 4));
+	}
+	return rr;
+}
+
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_create(trtp_rtcp_header_t* header)
+{
+	trtp_rtcp_report_rr_t* rr;
+	if((rr = (trtp_rtcp_report_rr_t*)tsk_object_new(trtp_rtcp_report_rr_def_t))){
+		TRTP_RTCP_PACKET(rr)->header = tsk_object_ref(header);
+	}
+	return rr;
+}
+
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_create_2(uint32_t ssrc)
+{
+	trtp_rtcp_report_rr_t* rr;
+	if((rr = trtp_rtcp_report_rr_create_null())){
+		rr->ssrc = ssrc;
+	}
+	return rr;
+}
+
+trtp_rtcp_report_rr_t* trtp_rtcp_report_rr_deserialize(const void* data, tsk_size_t _size)
+{
+	trtp_rtcp_report_rr_t* rr = tsk_null;
+	trtp_rtcp_header_t* header = tsk_null;
+	const uint8_t* pdata = (const uint8_t*)data;
+	int32_t size = (int32_t)_size;
+
+	if(!data || size < TRTP_RTCP_PACKET_RR_MIN_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	
+	if(!(header = trtp_rtcp_header_deserialize(pdata, size))){
+		TSK_DEBUG_ERROR("Failed to deserialize the header");
+		goto bail;
+	}
+	if(header->length_in_bytes < TRTP_RTCP_PACKET_RR_MIN_SIZE){
+		TSK_DEBUG_ERROR("Too short");
+		goto bail;
+	}
+	
+	if(!(rr = trtp_rtcp_report_rr_create(header))){
+		TSK_DEBUG_ERROR("Failed to create object");
+		goto bail;
+	}
+
+	rr->ssrc = (uint32_t)tnet_ntohl_2(&pdata[4]);
+
+	pdata += (TRTP_RTCP_HEADER_SIZE + 4);
+	size -= (TRTP_RTCP_HEADER_SIZE + 4);
+
+	// Blocks
+	if(header->rc > 0){
+		tsk_size_t i = 0;
+		trtp_rtcp_rblock_t* rblock;
+
+		while(i++ < header->rc && size >= TRTP_RTCP_RBLOCK_SIZE){
+			if((rblock = trtp_rtcp_rblock_deserialize(pdata, size))){
+				tsk_list_push_back_data(rr->blocks, (void**)&rblock);
+			}
+			pdata += TRTP_RTCP_RBLOCK_SIZE;
+			size -= TRTP_RTCP_RBLOCK_SIZE;
+		}
+	}
+
+	// Other Packets
+	while(size > TRTP_RTCP_HEADER_SIZE){
+		trtp_rtcp_packet_t* packet;
+		
+		if((packet = trtp_rtcp_packet_deserialize(pdata, size))){
+			if((size -= packet->header->length_in_bytes) > 0){
+				pdata += packet->header->length_in_bytes;
+			}
+			tsk_list_push_back_data(rr->packets, (void**)&packet);
+			continue;
+		}
+		break;
+	}
+
+bail:
+	TSK_OBJECT_SAFE_FREE(header);
+	return rr;
+}
+
+int trtp_rtcp_report_rr_serialize_to(const trtp_rtcp_report_rr_t* self, void* data, tsk_size_t size)
+{
+	int ret;
+	const tsk_list_item_t* item;
+	uint8_t* pdata = (uint8_t*)data;
+
+	if(!self || !data || size < trtp_rtcp_report_rr_get_size(self)){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if((ret = trtp_rtcp_header_serialize_to(TRTP_RTCP_PACKET(self)->header, pdata, size))){
+		TSK_DEBUG_ERROR("Failed to serialize the header");
+		return ret;
+	}
+	
+	pdata[TRTP_RTCP_HEADER_SIZE] = self->ssrc >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 1] = (self->ssrc >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 2] = (self->ssrc >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 3] = (self->ssrc & 0xFF);
+	
+	pdata += (TRTP_RTCP_HEADER_SIZE + 4);
+	size -= (TRTP_RTCP_HEADER_SIZE + 4);
+
+	if(TRTP_RTCP_PACKET(self)->header->rc > 0){
+		tsk_list_foreach(item, self->blocks){
+			if(!item->data){
+				continue;
+			}
+			if((ret = trtp_rtcp_rblock_serialize_to(TRTP_RTCP_RBLOCK(item->data), pdata, size))){
+				TSK_DEBUG_ERROR("Failed to serialize the rblock");
+				goto bail;
+			}
+			pdata += TRTP_RTCP_RBLOCK_SIZE;
+			size -= TRTP_RTCP_RBLOCK_SIZE;
+		}
+	}
+
+	tsk_list_foreach(item, self->packets){
+		if(!item->data){
+			continue;
+		}
+		if((ret = trtp_rtcp_packet_serialize_to(TRTP_RTCP_PACKET(item->data), pdata, size))){
+			TSK_DEBUG_ERROR("Failed to serialize packet");
+			goto bail;
+		}
+		pdata += TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+		size -= TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+	}
+
+bail:
+	return ret;
+}
+
+tsk_size_t trtp_rtcp_report_rr_get_size(const trtp_rtcp_report_rr_t* self)
+{
+	tsk_size_t size;
+	const tsk_list_item_t* item;
+
+	if(!self || !TRTP_RTCP_PACKET(self)->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+
+	size = TRTP_RTCP_PACKET(self)->header->length_in_bytes;
+	if(TRTP_RTCP_PACKET(self)->header->rc > 0){
+		tsk_list_foreach(item, self->blocks){
+			if(item->data){
+				size += TRTP_RTCP_RBLOCK_SIZE;
+			}
+		}
+	}
+	tsk_list_foreach(item, self->packets){
+		if(item->data && TRTP_RTCP_PACKET(item->data)->header){
+			size += TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+		}
+	}
+
+	return size;
+}
\ No newline at end of file
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_report_sdes.c b/tinyRTP/src/rtcp/trtp_rtcp_report_sdes.c
new file mode 100644
index 0000000..4f5e944
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_report_sdes.c
@@ -0,0 +1,214 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_report_sdes.h"
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+
+#include "tsk_debug.h"
+
+/*
+6.5 SDES: Source Description RTCP Packet
+        0                   1                   2                   
+        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+header |V=2|P|    SC   |  PT=SDES=202  |             length            |
+       +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+chunk  |                          SSRC/CSRC_1                          |
+  1    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       |                           SDES items                          |
+       |                              ...                              |
+       +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+chunk  |                          SSRC/CSRC_2                          |
+  2    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+       |                           SDES items                          |
+       |                              ...                              |
+       +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*/
+
+static tsk_object_t* trtp_rtcp_report_sdes_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_report_sdes_t *sdes = self;
+	if(sdes){
+		sdes->chuncks = tsk_list_create();
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_report_sdes_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_report_sdes_t *sdes = self;
+	if(sdes){
+		// deinit base
+		trtp_rtcp_packet_deinit(TRTP_RTCP_PACKET(sdes));
+		// deinit self
+		TSK_OBJECT_SAFE_FREE(sdes->chuncks);
+	}
+
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_report_sdes_def_s = 
+{
+	sizeof(trtp_rtcp_report_sdes_t),
+	trtp_rtcp_report_sdes_ctor, 
+	trtp_rtcp_report_sdes_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_report_sdes_def_t = &trtp_rtcp_report_sdes_def_s;
+
+
+trtp_rtcp_report_sdes_t* trtp_rtcp_report_sdes_create_null()
+{
+	trtp_rtcp_report_sdes_t* sdes;
+	if((sdes = (trtp_rtcp_report_sdes_t*)tsk_object_new(trtp_rtcp_report_sdes_def_t))){
+		trtp_rtcp_packet_init(TRTP_RTCP_PACKET(sdes), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_sdes, TRTP_RTCP_HEADER_SIZE);
+	}
+	return sdes;
+}
+
+trtp_rtcp_report_sdes_t* trtp_rtcp_report_sdes_create(trtp_rtcp_header_t* header)
+{
+	trtp_rtcp_report_sdes_t* sdes;
+	if((sdes = (trtp_rtcp_report_sdes_t*)tsk_object_new(trtp_rtcp_report_sdes_def_t))){
+		TRTP_RTCP_PACKET(sdes)->header = tsk_object_ref(header);
+	}
+	return sdes;
+}
+
+trtp_rtcp_report_sdes_t* trtp_rtcp_report_sdes_deserialize(const void* data, tsk_size_t _size)
+{
+	trtp_rtcp_report_sdes_t* sdes = tsk_null;
+	trtp_rtcp_header_t* header = tsk_null;
+	const uint8_t* pdata = (const uint8_t*)data;
+	int32_t size = (int32_t)_size;
+
+	if(!data || size < TRTP_RTCP_HEADER_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	
+	if(!(header = trtp_rtcp_header_deserialize(pdata, size))){
+		TSK_DEBUG_ERROR("Failed to deserialize the header");
+		goto bail;
+	}
+	if(header->length_in_bytes < (TRTP_RTCP_HEADER_SIZE + 4)){
+		TSK_DEBUG_ERROR("Too short");
+		goto bail;
+	}
+	
+	if(!(sdes = trtp_rtcp_report_sdes_create(header))){
+		TSK_DEBUG_ERROR("Failed to create object");
+		goto bail;
+	}
+
+	pdata += TRTP_RTCP_HEADER_SIZE;
+	size -= TRTP_RTCP_HEADER_SIZE;
+
+	// Chuncks
+	if(header->rc > 0){
+		tsk_size_t i = 0, chunck_size;
+		trtp_rtcp_sdes_chunck_t* chunck;
+		while(i++ < header->rc && size > TRTP_RTCP_SDES_CHUNCK_MIN_SIZE){
+			if((chunck = trtp_rtcp_sdes_chunck_deserialize(pdata, size))){
+				chunck_size = trtp_rtcp_sdes_chunck_get_size(chunck);
+				if((size -= (int32_t)chunck_size)){
+					pdata += chunck_size;
+				}
+				tsk_list_push_ascending_data(sdes->chuncks, (void**)&chunck);
+				continue;
+			}
+			break;
+		}
+	}
+
+bail:
+	TSK_OBJECT_SAFE_FREE(header);
+	return sdes;
+}
+
+int trtp_rtcp_report_sdes_serialize_to(const trtp_rtcp_report_sdes_t* self, void* data, tsk_size_t size)
+{
+	int ret;
+	uint8_t* pdata = (uint8_t*)data;
+	if(!self || !data || size < trtp_rtcp_report_sdes_get_size(self)){
+		return -1;
+	}
+
+	if((ret = trtp_rtcp_header_serialize_to(TRTP_RTCP_PACKET(self)->header, pdata, size))){
+		TSK_DEBUG_ERROR("Failed to serialize the header");
+		return ret;
+	}
+
+	pdata += (TRTP_RTCP_HEADER_SIZE);
+	size -= (TRTP_RTCP_HEADER_SIZE);
+
+	if(TRTP_RTCP_PACKET(self)->header->rc > 0){
+		const tsk_list_item_t* item;
+		tsk_size_t chunck_size;
+		const trtp_rtcp_sdes_chunck_t* chunck;
+		tsk_list_foreach(item, self->chuncks){
+			if(!(chunck = item->data)){
+				continue;
+			}
+			if((ret = trtp_rtcp_sdes_chunck_serialize_to(chunck, pdata, size))){
+				TSK_DEBUG_ERROR("Failed to serialize SDES chunck");
+				goto bail;
+			}
+			chunck_size = trtp_rtcp_sdes_chunck_get_size(chunck);
+			pdata += chunck_size;
+			size -= chunck_size;
+		}
+	}
+
+bail:
+	return ret;
+}
+
+int trtp_rtcp_report_sdes_add_chunck(trtp_rtcp_report_sdes_t* self, trtp_rtcp_sdes_chunck_t* chunck)
+{
+	if(!self || !self->chuncks || !chunck){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	chunck = tsk_object_ref(chunck);
+	TRTP_RTCP_PACKET(self)->header->length_in_bytes += (uint32_t)trtp_rtcp_sdes_chunck_get_size(chunck);
+	TRTP_RTCP_PACKET(self)->header->length_in_words_minus1 = ((TRTP_RTCP_PACKET(self)->header->length_in_bytes >> 2) - 1) 
+		+  ((TRTP_RTCP_PACKET(self)->header->length_in_bytes & 0x03) ? 1 : 0);
+	++TRTP_RTCP_PACKET(self)->header->rc;
+	tsk_list_push_back_data(self->chuncks, (void**)&chunck);
+	return 0;
+}
+
+tsk_size_t trtp_rtcp_report_sdes_get_size(const trtp_rtcp_report_sdes_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	else{
+		tsk_size_t size = TRTP_RTCP_HEADER_SIZE;
+		const tsk_list_item_t* item;
+		tsk_list_foreach(item, self->chuncks){
+			size += trtp_rtcp_sdes_chunck_get_size(TRTP_RTCP_SDES_CHUNCK(item->data));
+		}
+		return size;
+	}
+}
+
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_report_sr.c b/tinyRTP/src/rtcp/trtp_rtcp_report_sr.c
new file mode 100644
index 0000000..5d8ceda
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_report_sr.c
@@ -0,0 +1,270 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_report_sr.h"
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_debug.h"
+
+#define TRTP_RTCP_PACKET_SR_MIN_SIZE (TRTP_RTCP_HEADER_SIZE + 4 + 20)
+
+static tsk_object_t* trtp_rtcp_report_sr_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_report_sr_t *sr = self;
+	if(sr){
+		sr->blocks = tsk_list_create();
+		sr->packets = tsk_list_create();
+	}
+	return self;
+}
+
+static tsk_object_t* trtp_rtcp_report_sr_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_report_sr_t *sr = self;
+	if(sr){
+		// deinit self
+		TSK_OBJECT_SAFE_FREE(sr->blocks);
+		TSK_OBJECT_SAFE_FREE(sr->packets);
+		// deinit base
+		trtp_rtcp_packet_deinit(TRTP_RTCP_PACKET(sr));
+	}
+
+	return self;
+}
+
+static const tsk_object_def_t trtp_rtcp_report_sr_def_s = 
+{
+	sizeof(trtp_rtcp_report_sr_t),
+	trtp_rtcp_report_sr_ctor, 
+	trtp_rtcp_report_sr_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_report_sr_def_t = &trtp_rtcp_report_sr_def_s;
+
+trtp_rtcp_report_sr_t* trtp_rtcp_report_sr_create_null()
+{
+	trtp_rtcp_report_sr_t* sr;
+	if((sr = (trtp_rtcp_report_sr_t*)tsk_object_new(trtp_rtcp_report_sr_def_t))){
+		trtp_rtcp_packet_init(TRTP_RTCP_PACKET(sr), TRTP_RTCP_HEADER_VERSION_DEFAULT, 0, 0, trtp_rtcp_packet_type_sr, (TRTP_RTCP_HEADER_SIZE  + 4 + 20));
+	}
+	return sr;
+}
+
+trtp_rtcp_report_sr_t* trtp_rtcp_report_sr_create(struct trtp_rtcp_header_s* header)
+{
+	trtp_rtcp_report_sr_t* sr;
+	if((sr = (trtp_rtcp_report_sr_t*)tsk_object_new(trtp_rtcp_report_sr_def_t))){
+		TRTP_RTCP_PACKET(sr)->header = tsk_object_ref(header);
+	}
+	return sr;
+}
+
+
+trtp_rtcp_report_sr_t* trtp_rtcp_report_sr_deserialize(const void* data, tsk_size_t _size)
+{
+	trtp_rtcp_report_sr_t* sr = tsk_null;
+	trtp_rtcp_header_t* header = tsk_null;
+	const uint8_t* pdata = (const uint8_t*)data;
+	int32_t size = (int32_t)_size;
+
+	if(!data || size < TRTP_RTCP_PACKET_SR_MIN_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	
+	if(!(header = trtp_rtcp_header_deserialize(pdata, size))){
+		TSK_DEBUG_ERROR("Failed to deserialize the header");
+		goto bail;
+	}
+	if(header->length_in_bytes < TRTP_RTCP_PACKET_SR_MIN_SIZE){
+		TSK_DEBUG_ERROR("Too short");
+		goto bail;
+	}
+	
+	if(!(sr = trtp_rtcp_report_sr_create(header))){
+		TSK_DEBUG_ERROR("Failed to create object");
+		goto bail;
+	}
+
+	sr->ssrc = (uint32_t)tnet_ntohl_2(&pdata[4]);
+	pdata += (TRTP_RTCP_HEADER_SIZE + 4);
+	size -= (TRTP_RTCP_HEADER_SIZE + 4);
+
+	// sender info
+	sr->sender_info.ntp_msw = (uint32_t)tnet_ntohl_2(&pdata[0]);
+	sr->sender_info.ntp_lsw = (uint32_t)tnet_ntohl_2(&pdata[4]);
+	sr->sender_info.rtp_timestamp = (uint32_t)tnet_ntohl_2(&pdata[8]);
+	sr->sender_info.sender_pcount = (uint32_t)tnet_ntohl_2(&pdata[12]);
+	sr->sender_info.sender_ocount = (uint32_t)tnet_ntohl_2(&pdata[16]);
+	pdata += 20;
+	size -= 20;
+
+	// Blocks
+	if(header->rc > 0){
+		tsk_size_t i = 0;
+		trtp_rtcp_rblock_t* rblock;
+
+		while(i++ < header->rc && size >= TRTP_RTCP_RBLOCK_SIZE){
+			if((rblock = trtp_rtcp_rblock_deserialize(pdata, size))){
+				tsk_list_push_back_data(sr->blocks, (void**)&rblock);
+			}
+			pdata += TRTP_RTCP_RBLOCK_SIZE;
+			size -= TRTP_RTCP_RBLOCK_SIZE;
+		}
+	}
+
+	// Other Packets
+	while(size > TRTP_RTCP_HEADER_SIZE){
+		trtp_rtcp_packet_t* packet;
+		
+		if((packet = trtp_rtcp_packet_deserialize(pdata, size))){
+			if((size -= packet->header->length_in_bytes) > 0){
+				pdata += packet->header->length_in_bytes;
+			}
+			tsk_list_push_back_data(sr->packets, (void**)&packet);
+			continue;
+		}
+		break;
+	}
+
+bail:
+	TSK_OBJECT_SAFE_FREE(header);
+	return sr;
+}
+
+int trtp_rtcp_report_sr_serialize_to(const trtp_rtcp_report_sr_t* self, void* data, tsk_size_t size)
+{
+	int ret;
+	const tsk_list_item_t* item;
+	uint8_t* pdata = (uint8_t*)data;
+
+	if(!self || !data || size < trtp_rtcp_report_sr_get_size(self)){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if((ret = trtp_rtcp_header_serialize_to(TRTP_RTCP_PACKET(self)->header, pdata, size))){
+		TSK_DEBUG_ERROR("Failed to serialize the header");
+		return ret;
+	}
+	
+	pdata[TRTP_RTCP_HEADER_SIZE] = self->ssrc >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 1] = (self->ssrc >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 2] = (self->ssrc >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 3] = (self->ssrc & 0xFF);
+	pdata[TRTP_RTCP_HEADER_SIZE + 4] = self->sender_info.ntp_msw >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 5] = (self->sender_info.ntp_msw >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 6] = (self->sender_info.ntp_msw >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 7] = self->sender_info.ntp_msw & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 8] = self->sender_info.ntp_lsw >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 9] = (self->sender_info.ntp_lsw >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 10] = (self->sender_info.ntp_lsw >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 11] = self->sender_info.ntp_lsw & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 12] = self->sender_info.rtp_timestamp >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 13] = (self->sender_info.rtp_timestamp >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 14] = (self->sender_info.rtp_timestamp >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 15] = self->sender_info.rtp_timestamp & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 16] = self->sender_info.sender_pcount >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 17] = (self->sender_info.sender_pcount >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 18] = (self->sender_info.sender_pcount >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 19] = self->sender_info.sender_pcount & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 20] = self->sender_info.sender_ocount >> 24;
+	pdata[TRTP_RTCP_HEADER_SIZE + 21] = (self->sender_info.sender_ocount >> 16) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 22] = (self->sender_info.sender_ocount >> 8) & 0xFF;
+	pdata[TRTP_RTCP_HEADER_SIZE + 23] = self->sender_info.sender_ocount & 0xFF;
+
+	pdata += (TRTP_RTCP_HEADER_SIZE + 4 + 20);
+	size -= (TRTP_RTCP_HEADER_SIZE + 4 + 20);
+
+	if(TRTP_RTCP_PACKET(self)->header->rc > 0){
+		tsk_list_foreach(item, self->blocks){
+			if(!item->data){
+				continue;
+			}
+			if((ret = trtp_rtcp_rblock_serialize_to(TRTP_RTCP_RBLOCK(item->data), pdata, size))){
+				TSK_DEBUG_ERROR("Failed to serialize the rblock");
+				goto bail;
+			}
+			pdata += TRTP_RTCP_RBLOCK_SIZE;
+			size -= TRTP_RTCP_RBLOCK_SIZE;
+		}
+	}
+
+	tsk_list_foreach(item, self->packets){
+		if(!item->data){
+			continue;
+		}
+		if((ret = trtp_rtcp_packet_serialize_to(TRTP_RTCP_PACKET(item->data), pdata, size))){
+			TSK_DEBUG_ERROR("Failed to serialize packet");
+			goto bail;
+		}
+		pdata += TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+		size -= TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+	}
+
+bail:
+	return ret;
+}
+
+int trtp_rtcp_report_sr_add_block(trtp_rtcp_report_sr_t* self, trtp_rtcp_rblock_t* rblock)
+{
+	if(!self || !TRTP_RTCP_PACKET(self)->header || !rblock){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	rblock = tsk_object_ref(rblock);
+	tsk_list_push_back_data(self->blocks, (void**)&rblock);
+	++TRTP_RTCP_PACKET(self)->header->rc;
+	TRTP_RTCP_PACKET(self)->header->length_in_bytes += TRTP_RTCP_RBLOCK_SIZE;
+	TRTP_RTCP_PACKET(self)->header->length_in_words_minus1 = ((TRTP_RTCP_PACKET(self)->header->length_in_bytes >> 2) - 1) + 
+		((TRTP_RTCP_PACKET(self)->header->length_in_bytes & 0x03) ? 1 : 0);
+	return 0;
+}
+
+tsk_size_t trtp_rtcp_report_sr_get_size(const trtp_rtcp_report_sr_t* self)
+{
+	tsk_size_t size;
+	const tsk_list_item_t* item;
+
+	if(!self || !TRTP_RTCP_PACKET(self)->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+
+	size = TRTP_RTCP_PACKET(self)->header->length_in_bytes;
+	//if(TRTP_RTCP_PACKET(self)->header->rc > 0){
+	//	tsk_list_foreach(item, self->blocks){
+	//		if(item->data){
+	//			size += TRTP_RTCP_RBLOCK_SIZE;
+	//		}
+	//	}
+	//}
+	tsk_list_foreach(item, self->packets){
+		if(item->data && TRTP_RTCP_PACKET(item->data)->header){
+			size += TRTP_RTCP_PACKET(item->data)->header->length_in_bytes;
+		}
+	}
+
+	return size;
+}
+
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_report_xr.c b/tinyRTP/src/rtcp/trtp_rtcp_report_xr.c
new file mode 100644
index 0000000..5fb2697
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_report_xr.c
@@ -0,0 +1,21 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
\ No newline at end of file
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_sdes_chunck.c b/tinyRTP/src/rtcp/trtp_rtcp_sdes_chunck.c
new file mode 100644
index 0000000..9104580
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_sdes_chunck.c
@@ -0,0 +1,190 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_sdes_chunck.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_debug.h"
+
+/*
+Each chunk consists of an SSRC/CSRC identifier followed by a list of
+   zero or more items, which carry information about the SSRC/CSRC.
+   Each chunk starts on a 32-bit boundary.  Each item consists of an 8-
+   bit type field, an 8-bit octet count describing the length of the
+   text (thus, not including this two-octet header), and the text
+   itself.  Note that the text can be no longer than 255 octets, but
+   this is consistent with the need to limit RTCP bandwidth consumption.
+
++=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+|                          SSRC/CSRC_1                          |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                           SDES items                          |
+|                              ...                              |
++=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*/
+
+static tsk_object_t* trtp_rtcp_sdes_chunck_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_sdes_chunck_t *chunck = self;
+	if(chunck){
+		chunck->items = tsk_list_create();
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_sdes_chunck_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_sdes_chunck_t *chunck = self;
+	if(chunck){
+		TSK_OBJECT_SAFE_FREE(chunck->items);
+	}
+
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_sdes_chunck_def_s = 
+{
+	sizeof(trtp_rtcp_sdes_chunck_t),
+	trtp_rtcp_sdes_chunck_ctor, 
+	trtp_rtcp_sdes_chunck_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_sdes_chunck_def_t = &trtp_rtcp_sdes_chunck_def_s;
+
+
+
+trtp_rtcp_sdes_chunck_t* trtp_rtcp_sdes_chunck_create_null()
+{
+	return tsk_object_new(trtp_rtcp_sdes_chunck_def_t);
+}
+
+trtp_rtcp_sdes_chunck_t* trtp_rtcp_sdes_chunck_create(uint32_t ssrc)
+{
+	trtp_rtcp_sdes_chunck_t* chunck;
+	if((chunck = trtp_rtcp_sdes_chunck_create_null())){
+		chunck->ssrc = ssrc;
+	}
+	return chunck;
+}
+
+trtp_rtcp_sdes_chunck_t* trtp_rtcp_sdes_chunck_deserialize(const void* data, tsk_size_t size)
+{
+	trtp_rtcp_sdes_chunck_t* chunck = tsk_null;
+	const uint8_t* pdata = (uint8_t*)data;
+	const uint8_t* pend;
+	if(!data || size < TRTP_RTCP_SDES_CHUNCK_MIN_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	
+	pend = (pdata + size);
+	if((chunck = trtp_rtcp_sdes_chunck_create_null())){
+		trtp_rtcp_sdes_item_t* item;
+		tsk_bool_t is_last_item = tsk_false;
+		// SSRC/CSRC
+		chunck->ssrc = (uint32_t)tnet_ntohl_2(pdata);
+		pdata += TRTP_RTCP_SDES_CHUNCK_SSRC_OR_CSRC_SIZE;
+		while((pdata < pend) && !is_last_item){
+			if((item = trtp_rtcp_sdes_item_deserialize(pdata, (pend-pdata)))){
+				is_last_item = (item->type == trtp_rtcp_sdes_item_type_end);
+				pdata += trtp_rtcp_sdes_item_get_size(item);
+				tsk_list_push_back_data(chunck->items, (void**)&item);
+			}
+			else{
+				TSK_DEBUG_ERROR("Failed to deserialize sdes item");
+				break;
+			}
+		}
+	}
+	else{
+		TSK_DEBUG_ERROR("Failed to create new sdes_chunck object");
+		return tsk_null;
+	}
+
+	return chunck;
+}
+
+int trtp_rtcp_sdes_chunck_serialize_to(const trtp_rtcp_sdes_chunck_t* self, void* data, tsk_size_t size)
+{
+	uint8_t* pdata = (uint8_t*)data;
+	const tsk_list_item_t* item;
+	const trtp_rtcp_sdes_item_t* sdes_item;
+	tsk_size_t sdes_item_size;
+	int ret = 0;
+
+	if(!self || !data || size < trtp_rtcp_sdes_chunck_get_size(self)){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	pdata[0] = self->ssrc >> 24;
+	pdata[1] = (self->ssrc >> 16) & 0xFF;
+	pdata[2] = (self->ssrc >> 8) & 0xFF;
+	pdata[3] = (self->ssrc & 0xFF);
+	pdata += 4;
+
+	tsk_list_foreach(item, self->items){
+		if(!(sdes_item = TRTP_RTCP_SDES_ITEM(item->data))){
+			continue;
+		}
+		if((ret = trtp_rtcp_sdes_item_serialize_to(sdes_item, pdata, size))){
+			TSK_DEBUG_ERROR("SDES item serialization failed");
+			goto bail;
+		}
+		sdes_item_size = trtp_rtcp_sdes_item_get_size(sdes_item);
+		pdata += sdes_item_size; size -= sdes_item_size;
+	}
+
+bail:
+	return ret;
+}
+
+int trtp_rtcp_sdes_chunck_add_item(trtp_rtcp_sdes_chunck_t* self, trtp_rtcp_sdes_item_type_t type, const void* data, uint8_t length)
+{
+	trtp_rtcp_sdes_item_t *item;
+	if(!self || !self->items){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if((item = trtp_rtcp_sdes_item_create(type, data, length))){
+		tsk_list_push_back_data(self->items, (void**)&item);
+	}
+	return 0;
+}
+
+tsk_size_t trtp_rtcp_sdes_chunck_get_size(const trtp_rtcp_sdes_chunck_t* self)
+{
+	const tsk_list_item_t* item;
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	else{
+		tsk_size_t size = TRTP_RTCP_SDES_CHUNCK_SSRC_OR_CSRC_SIZE;
+		tsk_list_foreach(item, self->items){
+			size += trtp_rtcp_sdes_item_get_size(TRTP_RTCP_SDES_ITEM(item->data));
+		}
+		if(size & 0x03){//Each chunk starts on a 32-bit boundary 
+			size += (4 - (size & 0x03));
+		}
+		return size;
+	}
+}
+
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_sdes_item.c b/tinyRTP/src/rtcp/trtp_rtcp_sdes_item.c
new file mode 100644
index 0000000..7f22537
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_sdes_item.c
@@ -0,0 +1,148 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinyrtp/rtcp/trtp_rtcp_sdes_item.h"
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_string.h"
+#include "tsk_memory.h"
+#include "tsk_debug.h"
+
+#include <string.h> /* strlen() */
+
+static tsk_object_t* trtp_rtcp_sdes_item_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_sdes_item_t *item = self;
+	if(item){
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_sdes_item_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_sdes_item_t *item = self;
+	if(item){
+		TSK_OBJECT_SAFE_FREE(item->data);
+	}
+
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_sdes_item_def_s = 
+{
+	sizeof(trtp_rtcp_sdes_item_t),
+	trtp_rtcp_sdes_item_ctor, 
+	trtp_rtcp_sdes_item_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_sdes_item_def_t = &trtp_rtcp_sdes_item_def_s;
+
+
+trtp_rtcp_sdes_item_t* _trtp_rtcp_sdes_item_create_null(trtp_rtcp_sdes_item_type_t type)
+{
+	return tsk_object_new(trtp_rtcp_sdes_item_def_t);
+}
+
+trtp_rtcp_sdes_item_t* trtp_rtcp_sdes_item_create(trtp_rtcp_sdes_item_type_t type, const void* data, uint8_t length)
+{
+	trtp_rtcp_sdes_item_t* item;
+	if(!(item = _trtp_rtcp_sdes_item_create_null(type))){
+		TSK_DEBUG_ERROR("Failed to create new SDES item");
+		return tsk_null;
+	}
+	item->type = type;
+	if(data && length){
+		item->data = tsk_buffer_create(data, length);
+	}
+	
+	return item;
+}
+
+trtp_rtcp_sdes_item_t* trtp_rtcp_sdes_item_deserialize(const void* data, tsk_size_t size)
+{
+	const uint8_t* pdata = (const uint8_t*)data;
+	
+	if(!data || !size){
+		TSK_DEBUG_ERROR("Invlaid parameter");
+		return tsk_null;
+	}
+
+	if(pdata[0] == trtp_rtcp_sdes_item_type_end){
+		return trtp_rtcp_sdes_item_create(trtp_rtcp_sdes_item_type_end, tsk_null, 0);
+	}
+	
+	if(size < TRTP_RTCP_SDES_ITEM_MIN_SIZE || size < (tsk_size_t)(pdata[1] + 2)){
+		TSK_DEBUG_ERROR("Too short");
+		return tsk_null;
+	}
+
+	return trtp_rtcp_sdes_item_create((trtp_rtcp_sdes_item_type_t)pdata[0], &pdata[2], pdata[1]);
+}
+
+tsk_buffer_t* trtp_rtcp_sdes_item_serialize(const trtp_rtcp_sdes_item_t* self)
+{
+	tsk_buffer_t*buffer = tsk_null;
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	if((buffer = tsk_buffer_create(tsk_null, trtp_rtcp_sdes_item_get_size(self)))){
+		if(trtp_rtcp_sdes_item_serialize_to(self, buffer->data, buffer->size) != 0){
+			TSK_OBJECT_SAFE_FREE(buffer);
+		}
+	}
+	return buffer;
+}
+
+int trtp_rtcp_sdes_item_serialize_to(const trtp_rtcp_sdes_item_t* self, void* data, tsk_size_t size)
+{
+	if(!self || !data || (size < trtp_rtcp_sdes_item_get_size(self))){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(self->type == trtp_rtcp_sdes_item_type_end){
+		((uint8_t*)data)[0] = trtp_rtcp_sdes_item_type_end;
+	}
+	else{
+		((uint8_t*)data)[0] = self->type;
+		if(self->data){
+			((uint8_t*)data)[1] = (uint8_t)self->data->size;
+			memcpy(&((uint8_t*)data)[2], self->data->data, self->data->size);
+		}
+		else{
+			((uint8_t*)data)[1] = 0;
+		}
+	}
+	return 0;
+}
+
+tsk_size_t trtp_rtcp_sdes_item_get_size(const trtp_rtcp_sdes_item_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	switch(self->type){
+		case trtp_rtcp_sdes_item_type_end: return 1;
+		default: return 2 + (self->data ? self->data->size : 0);
+	}
+}
+
diff --git a/tinyRTP/src/rtcp/trtp_rtcp_session.c b/tinyRTP/src/rtcp/trtp_rtcp_session.c
new file mode 100644
index 0000000..3172278
--- /dev/null
+++ b/tinyRTP/src/rtcp/trtp_rtcp_session.c
@@ -0,0 +1,1584 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtcp_session.c
+ * @brief RTCP session.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#include "tinyrtp/rtcp/trtp_rtcp_session.h"
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+#include "tinyrtp/rtcp/trtp_rtcp_header.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_rr.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_sr.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_sdes.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_bye.h"
+#include "tinyrtp/rtcp/trtp_rtcp_report_fb.h"
+#include "tinyrtp/rtp/trtp_rtp_packet.h"
+
+#include "ice/tnet_ice_ctx.h"
+#include "turn/tnet_turn_session.h"
+#include "tnet_transport.h"
+
+#include "tnet_utils.h"
+
+#include "tsk_string.h"
+#include "tsk_md5.h"
+#include "tsk_list.h"
+#include "tsk_time.h"
+#include "tsk_timer.h"
+#include "tsk_safeobj.h"
+#include "tsk_memory.h"
+#include "tsk_debug.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h> /* INT_MAX */
+
+#ifdef _MSC_VER
+static double drand48() { return (((double)rand()) / RAND_MAX); }
+static void srand48(long sv) { srand((unsigned int) sv); }
+#endif
+
+#define RTCP_BW			(160 * 50) // FIXME: default bandwidth (octet/second)
+#define CODEC_RATE		8000		// FIXME
+#define RTP_SEQ_MOD		(1 << 16)
+#define MAX_DROPOUT		3000
+#define MAX_MISORDER	100
+#define MIN_SEQUENTIAL	2
+
+typedef double time_tp;
+typedef void* packet_;
+
+typedef enum event_
+{
+	EVENT_BYE,
+	EVENT_REPORT,
+	EVENT_RTP
+}
+event_;
+
+typedef enum PacketType_
+{
+	PACKET_RTCP_REPORT,
+	PACKET_BYE,
+	PACKET_RTP,
+}
+PacketType_;
+
+#define TypeOfEvent(e)	(e)
+
+#define TRTP_RTCP_SOURCE(self)	((trtp_rtcp_source_t*)self)
+
+typedef struct trtp_rtcp_source_s
+{
+	TSK_DECLARE_OBJECT;
+
+	uint32_t ssrc;			 /* source's ssrc */
+	uint16_t max_seq;        /* highest seq. number seen */
+	uint32_t cycles;         /* shifted count of seq. number cycles */
+	uint32_t base_seq;       /* base seq number */
+	uint32_t bad_seq;        /* last 'bad' seq number + 1 */
+	uint32_t probation;      /* sequ. packets till source is valid */
+	uint32_t received;       /* packets received */
+	uint32_t expected_prior; /* packet expected at last interval */
+	uint32_t received_prior; /* packet received at last interval */
+	uint32_t transit;        /* relative trans time for prev pkt */
+	double jitter;         /* estimated jitter */
+	
+	uint32_t base_ts;	/* base timestamp */
+	uint32_t max_ts;	/* highest timestamp number seen */
+	uint32_t rate;		/* codec sampling rate */
+
+	uint32_t ntp_msw;  /* last received NTP timestamp from RTCP sender */
+	uint32_t ntp_lsw;  /* last received NTP timestamp from RTCP sender */
+	uint64_t dlsr;    /* delay since last SR */
+}
+trtp_rtcp_source_t;
+typedef tsk_list_t trtp_rtcp_sources_L_t; /**< List of @ref trtp_rtcp_header_t elements */
+
+static tsk_object_t* trtp_rtcp_source_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_source_t *source = self;
+	if(source){
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_source_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_source_t *source = self;
+	if(source){
+	}
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_source_def_s = 
+{
+	sizeof(trtp_rtcp_source_t),
+	trtp_rtcp_source_ctor, 
+	trtp_rtcp_source_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_source_def_t = &trtp_rtcp_source_def_s;
+
+static int _trtp_rtcp_source_init_seq(trtp_rtcp_source_t* self, uint16_t seq, uint32_t ts);
+static tsk_bool_t _trtp_rtcp_source_update_seq(trtp_rtcp_source_t* self, uint16_t seq, uint32_t ts);
+
+static int __pred_find_source_by_ssrc(const tsk_list_item_t *item, const void *pssrc)
+{
+	if(item && item->data){
+		trtp_rtcp_source_t *source = item->data;
+		return source->ssrc - *((uint32_t*)pssrc);
+	}
+	return -1;
+}
+
+static trtp_rtcp_source_t* _trtp_rtcp_source_create(uint32_t ssrc, uint16_t seq, uint32_t ts)
+{
+	trtp_rtcp_source_t* source;
+	if(!(source = tsk_object_new(trtp_rtcp_source_def_t))){
+		TSK_DEBUG_ERROR("Failed to create source object");
+		return tsk_null;
+	}
+	
+	_trtp_rtcp_source_init_seq(source, seq, ts);
+	source->ssrc = ssrc;
+	source->max_seq = seq - 1;
+	source->probation = MIN_SEQUENTIAL;
+	source->rate = CODEC_RATE;//FIXME
+
+	return source;
+}
+
+static int _trtp_rtcp_source_init_seq(trtp_rtcp_source_t* self, uint16_t seq, uint32_t ts)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	self->base_seq = seq;
+	self->max_seq = seq;
+	self->bad_seq = RTP_SEQ_MOD + 1;   /* so seq == bad_seq is false */
+	self->cycles = 0;
+	self->received = 0;
+	self->received_prior = 0;
+	self->expected_prior = 0;
+	self->base_ts = ts;
+	self->max_ts = ts;
+	return 0;
+}
+
+static tsk_bool_t _trtp_rtcp_source_update_seq(trtp_rtcp_source_t* self, uint16_t seq, uint32_t ts)
+{
+	uint16_t udelta;
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_false;
+	}
+
+	 udelta = seq - self->max_seq;
+
+	/*
+	* Source is not valid until MIN_SEQUENTIAL packets with
+	* sequential sequence numbers have been received.
+	*/
+	if (self->probation) {
+		/* packet is in sequence */
+		if (seq == self->max_seq + 1) {
+			self->probation--;
+			self->max_seq = seq;
+			self->max_ts = ts;
+			if (self->probation == 0) {
+				_trtp_rtcp_source_init_seq(self, seq, ts);
+				self->received++;
+				return tsk_true;
+			}
+		} else {
+			self->probation = MIN_SEQUENTIAL - 1;
+			self->max_seq = seq;
+			self->max_ts = ts;
+		}
+		return tsk_false;
+	} else if (udelta < MAX_DROPOUT) {
+		/* in order, with permissible gap */
+		if (seq < self->max_seq) {
+			/*
+			* Sequence number wrapped - count another 64K cycle.
+			*/
+			self->cycles += RTP_SEQ_MOD;
+		}
+		self->max_seq = seq;
+		self->max_ts = ts;
+	} else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
+		/* the sequence number made a very large jump */
+		if (seq == self->bad_seq) {
+			/*
+			* Two sequential packets -- assume that the other side
+			* restarted without telling us so just re-sync
+			* (i.e., pretend this was the first packet).
+			*/
+			_trtp_rtcp_source_init_seq(self, seq, ts);
+		}
+		else {
+			self->bad_seq = (seq + 1) & (RTP_SEQ_MOD-1);
+			return tsk_false;
+		}
+	} else {
+		/* duplicate or reordered packet */
+	}
+	self->received++;
+	return tsk_true;
+}
+
+static tsk_bool_t _trtp_rtcp_source_is_probed(const trtp_rtcp_source_t* self)
+{
+	return (self && self->probation == 0);
+}
+
+
+
+
+
+
+
+typedef time_tp (*tc_f)();
+static time_tp _trtp_rtcp_session_tc() { return (time_tp)tsk_time_now(); }
+
+typedef struct trtp_rtcp_session_s
+{
+	TSK_DECLARE_OBJECT;
+	
+	tsk_bool_t is_started;
+	tnet_fd_t local_fd;
+    struct tnet_transport_s* transport; // not starter -> do not stop
+	const struct sockaddr * remote_addr;
+	struct tnet_ice_ctx_s* ice_ctx; // not starter -> do not stop
+	tsk_bool_t is_ice_turn_active;
+
+	const void* callback_data;
+	trtp_rtcp_cb_f callback;
+
+	int32_t app_bw_max_upload; // application specific (kbps)
+	int32_t app_bw_max_download; // application specific (kbps)
+
+	struct{
+		tsk_timer_manager_handle_t* handle_global;
+		tsk_timer_id_t id_report;
+		tsk_timer_id_t id_bye;
+	} timer;
+
+	trtp_rtcp_source_t* source_local; /**< local source */
+	trtp_rtcp_report_sdes_t* sdes;
+	uint64_t time_start; /**< Start time in millis (NOT in NTP unit yet) */
+	
+	// <RTCP-FB>
+	uint8_t fir_seqnr;
+	// </RTCP-FB>
+
+	// <sender>
+	char* cname;
+	uint32_t packets_count;
+	uint32_t octets_count;
+	// </sender>
+
+	// <others>
+	time_tp tp; /**< the last time an RTCP packet was transmitted; */
+	tc_f tc; /**< the current time */
+	time_tp tn; /**< the next scheduled transmission time of an RTCP packet */
+	int32_t pmembers; /**< the estimated number of session members at the time tn was last recomputed */
+	int32_t members; /**< the most current estimate for the number of session members */
+	int32_t senders; /**< the most current estimate for the number of senders in the session */
+	double rtcp_bw; /**< The target RTCP bandwidth, i.e., the total bandwidth
+      that will be used for RTCP packets by all members of this session,
+      in octets per second.  This will be a specified fraction of the
+      "session bandwidth" parameter supplied to the application at
+      startup*/
+	tsk_bool_t we_sent; /**< Flag that is true if the application has sent data since the 2nd previous RTCP report was transmitted */
+	double avg_rtcp_size; /**< The average compound RTCP packet size, in octets,
+      over all RTCP packets sent and received by this participant.  The
+      size includes lower-layer transport and network protocol headers
+      (e.g., UDP and IP) as explained in Section 6.2*/
+	tsk_bool_t initial; /**< Flag that is true if the application has not yet sent an RTCP packet */
+	// </others>
+
+	trtp_rtcp_sources_L_t *sources;
+
+	TSK_DECLARE_SAFEOBJ;
+
+#if HAVE_SRTP
+	struct{
+		const srtp_t* session;
+	} srtp;
+#endif
+}
+trtp_rtcp_session_t;
+
+static tsk_object_t* trtp_rtcp_session_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtcp_session_t *session = self;
+	if(session){
+		session->app_bw_max_upload = INT_MAX; // INT_MAX or <=0 means undefined
+		session->app_bw_max_download = INT_MAX; // INT_MAX or <=0 means undefined
+		session->sources = tsk_list_create();
+		session->timer.id_report = TSK_INVALID_TIMER_ID;
+		session->timer.id_bye = TSK_INVALID_TIMER_ID;
+		session->tc = _trtp_rtcp_session_tc;
+		// get a handle for the global timer manager
+		session->timer.handle_global = tsk_timer_mgr_global_ref();
+		tsk_safeobj_init(session);
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtcp_session_dtor(tsk_object_t * self)
+{ 
+	trtp_rtcp_session_t *session = self;
+	if(session){
+		trtp_rtcp_session_stop(session);
+
+		TSK_OBJECT_SAFE_FREE(session->sources);
+		TSK_OBJECT_SAFE_FREE(session->source_local);
+		TSK_OBJECT_SAFE_FREE(session->sdes);
+		TSK_OBJECT_SAFE_FREE(session->ice_ctx); // not starter -> do not stop
+		TSK_FREE(session->cname);
+        TSK_OBJECT_SAFE_FREE(session->transport); // not starter -> do not stop
+		// release the handle for the global timer manager
+		tsk_timer_mgr_global_unref(&session->timer.handle_global);
+
+		tsk_safeobj_deinit(session);
+	}
+	return self;
+}
+static const tsk_object_def_t trtp_rtcp_session_def_s = 
+{
+	sizeof(trtp_rtcp_session_t),
+	trtp_rtcp_session_ctor, 
+	trtp_rtcp_session_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtcp_session_def_t = &trtp_rtcp_session_def_s;
+
+
+static tsk_bool_t _trtp_rtcp_session_have_source(trtp_rtcp_session_t* self, uint32_t ssrc);
+static trtp_rtcp_source_t* _trtp_rtcp_session_find_source(trtp_rtcp_session_t* self, uint32_t ssrc);
+static trtp_rtcp_source_t* _trtp_rtcp_session_find_or_add_source(trtp_rtcp_session_t* self, uint32_t ssrc, uint16_t seq_if_add, uint32_t ts_id_add);
+static int _trtp_rtcp_session_add_source(trtp_rtcp_session_t* self, trtp_rtcp_source_t* source);
+static int _trtp_rtcp_session_add_source_2(trtp_rtcp_session_t* self, uint32_t ssrc, uint16_t seq, uint32_t ts, tsk_bool_t *added);
+static int _trtp_rtcp_session_remove_source(trtp_rtcp_session_t* self, uint32_t ssrc, tsk_bool_t *removed);
+static tsk_size_t _trtp_rtcp_session_send_pkt(trtp_rtcp_session_t* self, trtp_rtcp_packet_t* pkt);
+static tsk_size_t _trtp_rtcp_session_send_raw(trtp_rtcp_session_t* self, const void* data, tsk_size_t size);
+static int _trtp_rtcp_session_timer_callback(const void* arg, tsk_timer_id_t timer_id);
+
+static void Schedule(trtp_rtcp_session_t* session, double tn, event_ e);
+static void OnReceive(trtp_rtcp_session_t* session, const packet_ p, event_ e, tsk_size_t ReceivedPacketSize);
+static void OnExpire(trtp_rtcp_session_t* session, event_ e);
+static void SendBYEPacket(trtp_rtcp_session_t* session, event_ e);
+
+trtp_rtcp_session_t* trtp_rtcp_session_create(uint32_t ssrc, const char* cname)
+{
+	trtp_rtcp_session_t* session;
+
+	if(!(session = tsk_object_new(trtp_rtcp_session_def_t))){
+		TSK_DEBUG_ERROR("Failed to create new session object");
+		return tsk_null;
+	}
+
+	// RFC 3550 - 6.3.2 Initialization
+	if(!(session->source_local = _trtp_rtcp_source_create(ssrc, 0, 0))){
+		TSK_DEBUG_ERROR("Failed to create new local source");
+		TSK_OBJECT_SAFE_FREE(session);
+		goto bail;
+	}
+	_trtp_rtcp_session_add_source(session, session->source_local);
+	session->initial = tsk_true;
+	session->we_sent = tsk_false;
+	session->senders = 1;
+	session->members = 1;
+	session->rtcp_bw = RTCP_BW;//FIXME: as parameter from the code, Also added possiblities to update this value
+	session->cname = tsk_strdup(cname);
+	
+bail:
+	return session;
+}
+
+struct trtp_rtcp_session_s* trtp_rtcp_session_create_2(struct tnet_ice_ctx_s* ice_ctx, uint32_t ssrc, const char* cname)
+{
+	struct trtp_rtcp_session_s* session = trtp_rtcp_session_create(ssrc, cname);
+	if (session) {
+		if ((session->ice_ctx = tsk_object_ref(ice_ctx))) {
+			session->is_ice_turn_active = tnet_ice_ctx_is_turn_rtcp_active(session->ice_ctx);
+		}
+	}
+	return session;
+}
+
+int trtp_rtcp_session_set_callback(trtp_rtcp_session_t* self, trtp_rtcp_cb_f callback, const void* callback_data)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	tsk_safeobj_lock(self);
+	self->callback = callback;
+	self->callback_data = callback_data;
+	tsk_safeobj_unlock(self);
+	return 0;
+}
+
+#if HAVE_SRTP
+int trtp_rtcp_session_set_srtp_sess(trtp_rtcp_session_t* self, const srtp_t* session)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	tsk_safeobj_lock(self);
+	self->srtp.session = session;
+	tsk_safeobj_unlock(self);
+
+	return 0;
+}
+#endif
+
+int trtp_rtcp_session_set_app_bandwidth_max(trtp_rtcp_session_t* self, int32_t bw_upload_kbps, int32_t bw_download_kbps)
+{
+	trtp_rtcp_report_rr_t* rr;
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	tsk_safeobj_lock(self);
+
+	self->app_bw_max_upload = bw_upload_kbps;
+	self->app_bw_max_download = bw_download_kbps;
+
+	if(self->is_started && self->source_local && self->app_bw_max_download > 0 && self->app_bw_max_download != INT_MAX){ // INT_MAX or <=0 means undefined
+		tsk_list_item_t* item;
+		uint32_t media_ssrc_list[256] = {0};
+		uint32_t media_ssrc_list_count = 0;
+		// retrieve sources as array
+		tsk_list_foreach(item, self->sources){
+			if(!item->data){ 
+				continue;
+			}
+			if((media_ssrc_list_count + 1) < sizeof(media_ssrc_list)/sizeof(media_ssrc_list[0])){
+				media_ssrc_list[media_ssrc_list_count++] = TRTP_RTCP_SOURCE(item->data)->ssrc;
+			}
+		}
+		// create RTCP-RR packet and send it over the network
+		if(media_ssrc_list_count > 0 && (rr = trtp_rtcp_report_rr_create_2(self->source_local->ssrc))){
+			// app_bw_max_download unit is kbps while create_afb_remb() expect bps
+			trtp_rtcp_report_psfb_t* psfb_afb_remb = trtp_rtcp_report_psfb_create_afb_remb(self->source_local->ssrc/*sender SSRC*/, media_ssrc_list, media_ssrc_list_count, (self->app_bw_max_download * 1024));
+			if(psfb_afb_remb){
+				TSK_DEBUG_INFO("Packing RTCP-AFB-REMB (bw_dwn=%d kbps) for outgoing RTCP-RR", self->app_bw_max_download);
+				if(trtp_rtcp_packet_add_packet((trtp_rtcp_packet_t*)rr, (trtp_rtcp_packet_t*)psfb_afb_remb, tsk_false) == 0){
+					_trtp_rtcp_session_send_pkt(self, (trtp_rtcp_packet_t*)rr);
+				}
+				TSK_OBJECT_SAFE_FREE(psfb_afb_remb);
+			}
+			TSK_OBJECT_SAFE_FREE(rr);
+		}
+	}
+
+	tsk_safeobj_unlock(self);
+	
+	return 0;
+}
+
+int trtp_rtcp_session_start(trtp_rtcp_session_t* self, tnet_fd_t local_fd, const struct sockaddr * remote_addr)
+{
+	int ret;
+
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(self->is_started){
+		TSK_DEBUG_WARN("Already started");
+		return 0;
+	}
+	
+	// start global timer manager
+	if((ret = tsk_timer_manager_start(self->timer.handle_global))){
+		TSK_DEBUG_ERROR("Failed to start timer");
+		return ret;
+	}
+
+	self->local_fd = local_fd;
+	self->remote_addr = remote_addr;
+
+	// Send Initial RR (mandatory)
+	Schedule(self, 0., EVENT_REPORT);
+
+	// set start time
+	self->time_start = tsk_time_now();
+
+	self->is_started = tsk_true;
+
+	return ret;
+}
+
+int trtp_rtcp_session_stop(trtp_rtcp_session_t* self)
+{
+	int ret = 0;
+
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	if(self->is_started){
+		// send BYE synchronous way
+		SendBYEPacket(self, EVENT_REPORT);
+		
+		// this is a global timer shared by many components -> stopping it won't remove
+		// all scheduled items as it could continue running if still used
+		tsk_safeobj_lock(self); // must
+		if(TSK_TIMER_ID_IS_VALID(self->timer.id_bye)){
+			tsk_timer_manager_cancel(self->timer.handle_global, self->timer.id_bye);
+			self->timer.id_bye = TSK_INVALID_TIMER_ID;
+		}
+		if(TSK_TIMER_ID_IS_VALID(self->timer.id_report)){
+			tsk_timer_manager_cancel(self->timer.handle_global, self->timer.id_report);
+			self->timer.id_report = TSK_INVALID_TIMER_ID;
+		}
+		tsk_safeobj_unlock(self);
+		self->is_started = tsk_false;
+	}
+
+	return ret;
+}
+
+int trtp_rtcp_session_process_rtp_out(trtp_rtcp_session_t* self, const trtp_rtp_packet_t* packet_rtp, tsk_size_t size)
+{
+	int ret = 0;
+
+	if(!self || !packet_rtp || !packet_rtp->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	if(!self->is_started){
+		TSK_DEBUG_ERROR("Not started");
+		return -2;
+	}
+
+	tsk_safeobj_lock(self);
+
+	// create local source if not already done
+	// first destroy it if the ssrc don't match
+	if(self->source_local && self->source_local->ssrc != packet_rtp->header->ssrc){
+		tsk_bool_t removed = tsk_false;
+		// local ssrc has changed: sould never happen ...but who know?
+		// remove the source
+		TSK_DEBUG_WARN("Not expected to be called");
+		_trtp_rtcp_session_remove_source(self, self->source_local->ssrc, &removed);
+		TSK_OBJECT_SAFE_FREE(self->source_local);
+		TSK_OBJECT_SAFE_FREE(self->sdes);
+		self->packets_count = 0;
+		self->octets_count = 0;
+		if(removed){
+			--self->senders;
+			--self->members;
+		}
+	}
+	if(!self->source_local){
+		if(!(self->source_local = _trtp_rtcp_source_create(packet_rtp->header->ssrc, packet_rtp->header->seq_num, packet_rtp->header->timestamp))){
+			TSK_DEBUG_ERROR("Failed to create new local source");
+		}
+		// add the source (refresh the number of senders, ...)
+		_trtp_rtcp_session_add_source(self, self->source_local);
+		// 'members' and 'senders' were already initialized in the constructor
+	}
+	
+	if(!self->we_sent){
+		self->we_sent = tsk_true;
+	}
+
+	++self->packets_count;
+	self->octets_count += (uint32_t)size;
+
+	tsk_safeobj_unlock(self);
+
+	return ret;
+}
+
+int trtp_rtcp_session_process_rtp_in(trtp_rtcp_session_t* self, const trtp_rtp_packet_t* packet_rtp, tsk_size_t size)
+{
+	int ret = 0;
+	trtp_rtcp_source_t* source;
+
+	if(!self || !packet_rtp || !packet_rtp->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	if(!self->is_started){
+		TSK_DEBUG_INFO("RTCP session not started");
+		return -2;
+	}
+
+	tsk_safeobj_lock(self);
+	OnReceive(self, (const packet_)packet_rtp, EVENT_RTP, size);
+	if((source = _trtp_rtcp_session_find_source(self, packet_rtp->header->ssrc))){
+		if(_trtp_rtcp_source_update_seq(source, packet_rtp->header->seq_num, packet_rtp->header->timestamp)){
+			// RFC 3550 A.8 Estimating the Interarrival Jitter
+			/* uint32_t expected = (source->cycles + source->max_seq) - source->base_seq + 1; */
+			double arrival = (((double)(source->max_ts - source->base_ts) / (double)source->rate) * 1000);
+			int32_t transit = (int32_t)arrival - packet_rtp->header->timestamp;
+			int32_t d = (transit - source->transit);
+			if(d < 0) d = -d;
+			source->transit = transit;
+			source->jitter += (1./16.) * ((double)d - source->jitter);
+		}
+		TSK_OBJECT_SAFE_FREE(source);
+	}
+
+	tsk_safeobj_unlock(self);
+
+	return ret;
+}
+
+int trtp_rtcp_session_process_rtcp_in(trtp_rtcp_session_t* self, const void* buffer, tsk_size_t size)
+{
+	int ret = 0;
+	trtp_rtcp_packet_t* packet_rtcp = tsk_null;
+
+	if(!self || !buffer || size < TRTP_RTCP_HEADER_SIZE){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	if(!self->is_started){
+		TSK_DEBUG_ERROR("Not started");
+		return -2;
+	}
+	
+	// derialize the RTCP packet for processing
+	packet_rtcp = trtp_rtcp_packet_deserialize(buffer, size);
+	if(packet_rtcp){
+		tsk_safeobj_lock(self);
+		OnReceive(self, 
+			(const packet_)packet_rtcp, 
+			(packet_rtcp->header->type == trtp_rtcp_packet_type_bye) ? EVENT_BYE : EVENT_REPORT, 
+			size);
+		if(packet_rtcp->header->type == trtp_rtcp_packet_type_sr){
+			trtp_rtcp_source_t* source;
+			const trtp_rtcp_report_sr_t* sr = (const trtp_rtcp_report_sr_t*)packet_rtcp;
+			if((source = _trtp_rtcp_session_find_source(self, sr->ssrc))){
+				source->ntp_lsw = sr->sender_info.ntp_lsw;
+				source->ntp_msw = sr->sender_info.ntp_msw;
+				source->dlsr = tsk_time_now();
+				TSK_OBJECT_SAFE_FREE(source);
+			}
+		}
+		tsk_safeobj_unlock(self); // must be before callback()
+
+		if(self->callback){
+			ret = self->callback(self->callback_data, packet_rtcp);
+		}
+		TSK_OBJECT_SAFE_FREE(packet_rtcp);
+	}
+		
+
+	return ret;
+}
+
+int trtp_rtcp_session_signal_pkt_loss(trtp_rtcp_session_t* self, uint32_t ssrc_media, const uint16_t* seq_nums, tsk_size_t count)
+{
+	trtp_rtcp_report_rr_t* rr;
+	if(!self || !self->source_local || !seq_nums || !count){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(!self->is_started){
+		TSK_DEBUG_ERROR("Not started");
+		return -1;
+	}
+
+	tsk_safeobj_lock(self);
+
+	if((rr = trtp_rtcp_report_rr_create_2(self->source_local->ssrc))){
+		trtp_rtcp_report_rtpfb_t* rtpfb;
+		if((rtpfb = trtp_rtcp_report_rtpfb_create_nack(self->source_local->ssrc, ssrc_media, seq_nums, count))){
+			trtp_rtcp_packet_add_packet((trtp_rtcp_packet_t*)rr,  (trtp_rtcp_packet_t*)rtpfb, tsk_false);
+			_trtp_rtcp_session_send_pkt(self, (trtp_rtcp_packet_t*)rr);
+			TSK_OBJECT_SAFE_FREE(rtpfb);
+		}
+		TSK_OBJECT_SAFE_FREE(rr);
+	}
+
+	tsk_safeobj_unlock(self);
+
+	return 0;
+}
+
+// Frame corrupted means the prediction chain is broken -> Send FIR
+int trtp_rtcp_session_signal_frame_corrupted(trtp_rtcp_session_t* self, uint32_t ssrc_media)
+{
+	trtp_rtcp_report_rr_t* rr;
+	if(!self || !self->source_local){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(!self->is_started){
+		TSK_DEBUG_ERROR("Not started");
+		return -1;
+	}
+
+	tsk_safeobj_lock(self);
+	
+	if((rr = trtp_rtcp_report_rr_create_2(self->source_local->ssrc))){
+		trtp_rtcp_report_psfb_t* psfb_fir = trtp_rtcp_report_psfb_create_fir(self->fir_seqnr++, self->source_local->ssrc, ssrc_media);
+		if(psfb_fir){
+			trtp_rtcp_packet_add_packet((trtp_rtcp_packet_t*)rr, (trtp_rtcp_packet_t*)psfb_fir, tsk_false);
+			_trtp_rtcp_session_send_pkt(self, (trtp_rtcp_packet_t*)rr);
+			TSK_OBJECT_SAFE_FREE(psfb_fir);
+		}
+		TSK_OBJECT_SAFE_FREE(rr);
+	}
+
+	tsk_safeobj_unlock(self);
+	return 0;
+}
+
+// for now send just a FIR
+int trtp_rtcp_session_signal_jb_error(struct trtp_rtcp_session_s* self, uint32_t ssrc_media)
+{
+	return trtp_rtcp_session_signal_frame_corrupted(self, ssrc_media);
+}
+
+tnet_fd_t trtp_rtcp_session_get_local_fd(const struct trtp_rtcp_session_s* self)
+{
+    if (!self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return TNET_INVALID_FD;
+    }
+    return self->local_fd;
+}
+
+int trtp_rtcp_session_set_local_fd(struct trtp_rtcp_session_s* self, tnet_fd_t local_fd)
+{
+    if (!self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    self->local_fd = local_fd;
+    return 0;
+}
+
+int trtp_rtcp_session_set_net_transport(struct trtp_rtcp_session_s* self, struct tnet_transport_s* transport)
+{
+    if (!self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    TSK_OBJECT_SAFE_FREE(self->transport);
+    self->transport = tsk_object_ref(transport);
+    return 0;
+}
+
+static tsk_bool_t _trtp_rtcp_session_have_source(trtp_rtcp_session_t* self, uint32_t ssrc)
+{
+	tsk_list_item_t* item;
+	tsk_list_foreach(item, self->sources){
+		if(TRTP_RTCP_SOURCE(item->data)->ssrc == ssrc){
+			return tsk_true;
+		}
+	}
+	return tsk_false;
+}
+
+// find source by ssrc
+// the caller must release the returned object
+static trtp_rtcp_source_t* _trtp_rtcp_session_find_source(trtp_rtcp_session_t* self, uint32_t ssrc)
+{
+	tsk_list_item_t* item;
+	tsk_list_foreach(item, self->sources){
+		if(TRTP_RTCP_SOURCE(item->data)->ssrc == ssrc){
+			return tsk_object_ref(item->data);
+		}
+	}
+	return tsk_null;
+}
+
+// find or add source by ssrc
+// the caller must release the returned object
+static trtp_rtcp_source_t* _trtp_rtcp_session_find_or_add_source(trtp_rtcp_session_t* self, uint32_t ssrc, uint16_t seq_if_add, uint32_t ts_id_add)
+{
+	trtp_rtcp_source_t* source;
+	if((source = _trtp_rtcp_session_find_source(self, ssrc))){
+		return source;
+	}
+
+	if((source = _trtp_rtcp_source_create(ssrc, seq_if_add, ts_id_add))){
+		if((_trtp_rtcp_session_add_source(self, source)) != 0){
+			TSK_DEBUG_ERROR("Failed to add source");
+			TSK_OBJECT_SAFE_FREE(source);
+			return tsk_null;
+		}
+		return tsk_object_ref(source);
+	}
+	return tsk_null;
+}
+
+int _trtp_rtcp_session_add_source(trtp_rtcp_session_t* self, trtp_rtcp_source_t* source)
+{
+	if(!self || !source){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	tsk_list_lock(self->sources);
+	source = tsk_object_ref(source);
+	tsk_list_push_back_data(self->sources, (void**)&source);
+	tsk_list_unlock(self->sources);
+
+	return 0;
+}
+
+// adds a source if doesn't exist
+static int _trtp_rtcp_session_add_source_2(trtp_rtcp_session_t* self, uint32_t ssrc, uint16_t seq, uint32_t ts, tsk_bool_t *added)
+{
+	int ret = 0;
+	tsk_list_item_t* item;
+	trtp_rtcp_source_t* source;
+
+	tsk_list_lock(self->sources);
+	tsk_list_foreach(item, self->sources){
+		if(TRTP_RTCP_SOURCE(item->data)->ssrc == ssrc){
+			tsk_list_unlock(self->sources);
+			*added = tsk_false;
+			return 0;
+		}
+	}
+
+	tsk_list_unlock(self->sources);
+
+	if((source = _trtp_rtcp_source_create(ssrc, seq, ts))){
+		ret = _trtp_rtcp_session_add_source(self, source);
+	}
+
+	TSK_OBJECT_SAFE_FREE(source);
+
+	*added = tsk_true;
+	return ret;
+}
+
+int _trtp_rtcp_session_remove_source(trtp_rtcp_session_t* self, uint32_t ssrc, tsk_bool_t *removed)
+{
+	*removed = tsk_false;
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	tsk_list_lock(self->sources);
+	if((*removed = tsk_list_remove_item_by_pred(self->sources, __pred_find_source_by_ssrc, &ssrc)) == tsk_true){
+		// ...
+	}
+	tsk_list_unlock(self->sources);
+	return 0;
+}
+
+static tsk_size_t _trtp_rtcp_session_send_pkt(trtp_rtcp_session_t* self, trtp_rtcp_packet_t* pkt)
+{
+	tsk_size_t ret = 0;
+	tsk_size_t __num_bytes_pad = 0;
+	tsk_buffer_t* buffer;
+
+	if(!self->remote_addr || self->local_fd <= 0){
+		TSK_DEBUG_ERROR("Invalid network settings");
+		return 0;
+	}
+
+#if HAVE_SRTP
+	if(self->srtp.session) __num_bytes_pad = (SRTP_MAX_TRAILER_LEN + 0x4);
+#endif
+
+	// SDES
+	if(!self->sdes && (self->sdes = trtp_rtcp_report_sdes_create_null())){
+		trtp_rtcp_sdes_chunck_t* chunck = trtp_rtcp_sdes_chunck_create(self->source_local->ssrc);
+		if(chunck){
+			static const char* _name = "test@doubango.org";
+			trtp_rtcp_sdes_chunck_add_item(chunck, trtp_rtcp_sdes_item_type_cname, self->cname, (uint8_t)tsk_strlen(self->cname));
+			trtp_rtcp_sdes_chunck_add_item(chunck, trtp_rtcp_sdes_item_type_name, _name, (uint8_t)tsk_strlen(_name));
+			trtp_rtcp_report_sdes_add_chunck(self->sdes, chunck);
+			TSK_OBJECT_SAFE_FREE(chunck);
+		}
+	}
+	if(self->sdes){
+		trtp_rtcp_packet_add_packet(pkt, (trtp_rtcp_packet_t*)self->sdes, tsk_true);
+	}
+
+	if((buffer = trtp_rtcp_packet_serialize(pkt, __num_bytes_pad))){
+		void* data = buffer->data;
+		int size = (int)buffer->size;
+#if HAVE_SRTP
+		if(self->srtp.session){
+			if(srtp_protect_rtcp(((srtp_t)*self->srtp.session), data, &size) != err_status_ok){
+				TSK_DEBUG_ERROR("srtp_protect_rtcp() failed");
+			}
+		}
+#endif
+		ret = _trtp_rtcp_session_send_raw(self, data, size);
+		TSK_OBJECT_SAFE_FREE(buffer);
+	}
+
+	return ret;
+}
+
+static tsk_size_t _trtp_rtcp_session_send_raw(trtp_rtcp_session_t* self, const void* data, tsk_size_t size)
+{
+	tsk_size_t ret = 0;
+	if (!self || !data || !size) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	if (self->is_ice_turn_active) {
+		ret = (tnet_ice_ctx_send_turn_rtcp(self->ice_ctx, data, size) == 0) ? size : 0; // returns #0 if ok
+	}
+	else {
+        ret = self->transport
+        ? tnet_transport_sendto(self->transport, self->local_fd, self->remote_addr, data, size)
+        : tnet_sockfd_sendto(self->local_fd, self->remote_addr, data, size);
+	}
+	return ret;
+}
+
+static int _trtp_rtcp_session_timer_callback(const void* arg, tsk_timer_id_t timer_id)
+{
+	trtp_rtcp_session_t* session = (trtp_rtcp_session_t*)arg;
+	tsk_safeobj_lock(session); // must
+	if(session->timer.id_bye == timer_id){
+		session->timer.id_bye = TSK_INVALID_TIMER_ID;
+		OnExpire(session, EVENT_BYE);
+	}
+	else if(session->timer.id_report == timer_id){
+		session->timer.id_report = TSK_INVALID_TIMER_ID;
+		OnExpire(session, EVENT_REPORT);
+	}
+	tsk_safeobj_unlock(session);
+	return 0;
+}
+
+static tsk_bool_t IsRtpPacket(const packet_ p)
+{
+	return (TSK_OBJECT_HEADER(p)->__def__ == trtp_rtp_packet_def_t);
+}
+
+static PacketType_ PacketType(const packet_ p)
+{
+	if(IsRtpPacket(p)){
+		return PACKET_RTP;
+	}
+	else{
+		switch(((const trtp_rtcp_packet_t*)p)->header->type){
+			case trtp_rtcp_packet_type_bye: return PACKET_BYE;
+			default: return PACKET_RTCP_REPORT;
+		}
+	}
+}
+
+// Returns true if the packet is from a member or not
+// also checks all csrc
+static tsk_bool_t NewMember(trtp_rtcp_session_t* session, const packet_ p)
+{
+	uint32_t ssrc = 0;
+	if(IsRtpPacket(p)){
+		const trtp_rtp_packet_t* packet_rtp = (const trtp_rtp_packet_t*)p;
+		tsk_size_t i;
+		for(i = 0; i < packet_rtp->header->csrc_count && i < sizeof(packet_rtp->header->csrc)/sizeof(packet_rtp->header->csrc[0]); ++i){
+			if(!(_trtp_rtcp_session_have_source(session, packet_rtp->header->csrc[i]))){
+				return tsk_false;
+			}
+		}
+		ssrc = packet_rtp->header->ssrc;
+	}
+	else{
+		switch(((const trtp_rtcp_packet_t*)p)->header->type){
+			case trtp_rtcp_packet_type_rr: ssrc = ((const trtp_rtcp_report_rr_t*)p)->ssrc; break;
+			case trtp_rtcp_packet_type_sr: ssrc = ((const trtp_rtcp_report_sr_t*)p)->ssrc; break;
+			case trtp_rtcp_packet_type_bye:
+				{
+					tsk_size_t i;
+					const trtp_rtcp_report_bye_t* bye = (const trtp_rtcp_report_bye_t*)p;
+					for(i = 0; i < TRTP_RTCP_PACKET(bye)->header->rc; ++i){
+						if(!_trtp_rtcp_session_have_source(session, bye->ssrc_list[i])){
+							return tsk_false;
+						}
+					}
+					return tsk_true;
+				}
+			default: return tsk_false;
+		}
+	}
+
+	return !_trtp_rtcp_session_have_source(session, ssrc);
+}
+
+#define NewSender(session, p) NewMember((session), (p))
+
+static tsk_size_t AddMemberUsingRTCPPacket(trtp_rtcp_session_t* session, const trtp_rtcp_packet_t* p, tsk_bool_t sender)
+{
+	trtp_rtcp_packets_L_t* packets = tsk_null;
+	trtp_rtcp_rblocks_L_t* blocks = tsk_null;
+	tsk_bool_t added = tsk_false;
+	tsk_size_t count = 0;
+
+	switch(p->header->type){
+		case trtp_rtcp_packet_type_rr:
+			{
+				const trtp_rtcp_report_rr_t* rr = (const trtp_rtcp_report_rr_t*)p;
+				_trtp_rtcp_session_add_source_2(session, ((const trtp_rtcp_report_rr_t*)p)->ssrc, 0, 0, &added);
+				if(added) ++count;
+				
+				packets = rr->packets;
+				blocks = rr->blocks;
+				break;
+			}
+		case trtp_rtcp_packet_type_sr:
+			{
+				const trtp_rtcp_report_sr_t* sr = (const trtp_rtcp_report_sr_t*)p;
+				_trtp_rtcp_session_add_source_2(session, ((const trtp_rtcp_report_sr_t*)p)->ssrc, 0, 0, &added);
+				if(added) ++count;
+				packets = sr->packets;
+				blocks = sr->blocks;
+				break;
+			}
+        default:
+            {
+                break;
+            }
+	}
+
+	if(!sender){
+		if(packets){
+			const tsk_list_item_t *item;
+			tsk_list_foreach(item, packets){
+				AddMemberUsingRTCPPacket(session, (const trtp_rtcp_packet_t*)item->data, sender);
+			}
+		}
+		if(blocks){
+			const tsk_list_item_t *item;
+			tsk_list_foreach(item, blocks){
+				_trtp_rtcp_session_add_source_2(session, TRTP_RTCP_RBLOCK(item->data)->ssrc, 0, 0, &added);
+				if(added) ++count;
+			}
+		}
+	}
+
+	return count;
+}
+
+static tsk_size_t AddMember_(trtp_rtcp_session_t* session, const packet_ p, tsk_bool_t sender)
+{
+	tsk_size_t count = 0;
+	if(IsRtpPacket(p)){
+		const trtp_rtp_packet_t* packet_rtp = (const trtp_rtp_packet_t*)p;
+		tsk_size_t i;
+		tsk_bool_t added = tsk_false;
+		_trtp_rtcp_session_add_source_2(session, packet_rtp->header->ssrc, packet_rtp->header->seq_num, packet_rtp->header->timestamp, &added);
+		if(added) ++count;
+		for(i = 0; i < packet_rtp->header->csrc_count && i < sizeof(packet_rtp->header->csrc)/sizeof(packet_rtp->header->csrc[0]); ++i){
+			_trtp_rtcp_session_add_source_2(session, packet_rtp->header->csrc[i], 0, 0, &added);
+			if(added) ++count;
+		}
+	}
+	else{
+		count += AddMemberUsingRTCPPacket(session, (const trtp_rtcp_packet_t*) p, sender);
+	}
+	return count;
+}
+
+#define AddMember(session, p)	AddMember_((session), (p), tsk_false)
+#define AddSender(session, p)	AddMember_((session), (p), tsk_true)
+
+
+static tsk_size_t RemoveMemberUsingRTCPPacket(trtp_rtcp_session_t* session, const trtp_rtcp_packet_t* p)
+{
+	trtp_rtcp_packets_L_t* packets = tsk_null;
+	trtp_rtcp_rblocks_L_t* blocks = tsk_null;
+	tsk_bool_t removed = tsk_false;
+	tsk_size_t count = 0;
+
+	switch(p->header->type){
+		case trtp_rtcp_packet_type_rr:
+			{
+				const trtp_rtcp_report_rr_t* rr = (const trtp_rtcp_report_rr_t*)p;
+				_trtp_rtcp_session_remove_source(session, ((const trtp_rtcp_report_rr_t*)p)->ssrc, &removed);
+				if(removed) ++count;
+				
+				packets = rr->packets;
+				blocks = rr->blocks;
+				break;
+			}
+		case trtp_rtcp_packet_type_sr:
+			{
+				const trtp_rtcp_report_sr_t* sr = (const trtp_rtcp_report_sr_t*)p;
+				_trtp_rtcp_session_remove_source(session, ((const trtp_rtcp_report_sr_t*)p)->ssrc, &removed);
+				if(removed) ++count;
+				packets = sr->packets;
+				blocks = sr->blocks;
+				break;
+			}
+        default:
+            {
+                break;
+            }
+	}
+	
+	if(packets){
+		const tsk_list_item_t *item;
+		tsk_list_foreach(item, packets){
+			RemoveMemberUsingRTCPPacket(session, (const trtp_rtcp_packet_t*)item->data);
+		}
+	}
+	if(blocks){
+		const tsk_list_item_t *item;
+		tsk_list_foreach(item, blocks){
+			_trtp_rtcp_session_remove_source(session, TRTP_RTCP_RBLOCK(item->data)->ssrc, &removed);
+			if(removed) ++count;
+		}
+	}
+	
+
+	return count;
+}
+
+static tsk_size_t RemoveMember(trtp_rtcp_session_t* session, const packet_ p)
+{
+	tsk_size_t count = 0;
+	if(IsRtpPacket(p)){
+		const trtp_rtp_packet_t* packet_rtp = (const trtp_rtp_packet_t*)p;
+		tsk_size_t i;
+		tsk_bool_t removed = tsk_false;
+		_trtp_rtcp_session_remove_source(session, packet_rtp->header->ssrc, &removed);
+		if(removed) ++count;
+		for(i = 0; i < packet_rtp->header->csrc_count && i < sizeof(packet_rtp->header->csrc)/sizeof(packet_rtp->header->csrc[0]); ++i){
+			_trtp_rtcp_session_remove_source(session, packet_rtp->header->csrc[i], &removed);
+			if(removed) ++count;
+		}
+	}
+	else{
+		count += RemoveMemberUsingRTCPPacket(session, (const trtp_rtcp_packet_t*) p);
+	}
+	return count;
+}
+
+#define RemoveSender(session, p) RemoveMember((session), (p))
+
+// Sends BYE in synchronous mode
+static void SendBYEPacket(trtp_rtcp_session_t* session, event_ e)
+{
+	trtp_rtcp_report_bye_t* bye;
+	tsk_size_t __num_bytes_pad = 0;
+
+	if(!session->remote_addr || session->local_fd <= 0){
+		TSK_DEBUG_ERROR("Invalid network settings");
+		return;
+	}
+
+	tsk_safeobj_lock(session);
+
+#if HAVE_SRTP
+	if(session->srtp.session) __num_bytes_pad = (SRTP_MAX_TRAILER_LEN + 0x4);
+#endif
+
+	if(session->source_local && (bye = trtp_rtcp_report_bye_create_2(session->source_local->ssrc))){
+		tsk_buffer_t* buffer;
+		// serialize and send the packet
+		if((buffer = trtp_rtcp_packet_serialize((const trtp_rtcp_packet_t*)bye, __num_bytes_pad))){
+			void* data = buffer->data;
+			int size = (int)buffer->size;
+#if HAVE_SRTP
+			if(session->srtp.session){
+				if(srtp_protect_rtcp(((srtp_t)*session->srtp.session), data, &size) != err_status_ok){
+					TSK_DEBUG_ERROR("srtp_protect_rtcp() failed");
+				}
+			}
+#endif
+			_trtp_rtcp_session_send_raw(session, data, size);
+			TSK_OBJECT_SAFE_FREE(buffer);
+		}
+		TSK_OBJECT_SAFE_FREE(bye);
+	}
+
+	tsk_safeobj_unlock(session);
+}
+
+// returns sent packet size
+static tsk_size_t SendRTCPReport(trtp_rtcp_session_t* session, event_ e)
+{
+	tsk_size_t ret = 0;
+
+	tsk_safeobj_lock(session);
+
+	if(session->initial){
+		// Send Receiver report (manadatory to be the first on)
+		trtp_rtcp_report_rr_t* rr = trtp_rtcp_report_rr_create_2(session->source_local->ssrc);
+		if(rr){
+			// serialize and send the packet
+			ret = _trtp_rtcp_session_send_pkt(session, (trtp_rtcp_packet_t*)rr);
+			TSK_OBJECT_SAFE_FREE(rr);
+		}
+	}
+	else{
+		trtp_rtcp_report_sr_t* sr = trtp_rtcp_report_sr_create_null();
+		uint32_t media_ssrc_list[16] = {0};
+		uint32_t media_ssrc_list_count = 0;
+		if(sr){
+			uint64_t ntp_now = tsk_time_ntp();
+			uint64_t time_now = tsk_time_now();
+			trtp_rtcp_rblock_t* rblock;
+			trtp_rtcp_source_t* source;
+			tsk_list_item_t *item;
+			tsk_bool_t packet_lost = tsk_false;
+			
+			// sender info
+			sr->ssrc = session->source_local->ssrc;
+			sr->sender_info.ntp_msw = (ntp_now >> 32);
+			sr->sender_info.ntp_lsw = (ntp_now & 0xFFFFFFFF);
+			sr->sender_info.sender_pcount = session->packets_count;
+			sr->sender_info.sender_ocount = session->octets_count;
+			{	/* rtp_timestamp */
+				struct timeval tv;
+				uint64_t rtp_timestamp = (time_now - session->time_start) * (session->source_local->rate / 1000);
+				tv.tv_sec = (long)(rtp_timestamp / 1000);
+				tv.tv_usec = (long)(rtp_timestamp - ((rtp_timestamp / 1000) * 1000)) * 1000;
+#if 1
+				sr->sender_info.rtp_timestamp = (uint32_t)tsk_time_get_ms(&tv);
+#else
+				sr->sender_info.rtp_timestamp = (uint32_t)tsk_time_get_ntp_ms(&tv);
+#endif
+			}
+
+			// report blocks
+			tsk_list_foreach(item, session->sources){
+				if(!(source = (trtp_rtcp_source_t*)item->data) || !_trtp_rtcp_source_is_probed(source)){
+					continue;
+				}
+				if((rblock = trtp_rtcp_rblock_create_null())){
+					uint32_t expected, expected_interval, received_interval, lost_interval;
+					
+					rblock->ssrc = source->ssrc;
+					// RFC 3550 - A.3 Determining Number of Packets Expected and Lost
+					expected = (source->cycles + source->max_seq) - source->base_seq + 1;
+					expected_interval = expected - source->expected_prior;
+					source->expected_prior = expected;
+					received_interval = source->received - source->received_prior;
+					source->received_prior = source->received;
+					lost_interval = expected_interval - received_interval;
+					if (expected_interval == 0 || lost_interval <= 0) rblock->fraction = 0;
+					else rblock->fraction = (lost_interval << 8) / expected_interval;
+					rblock->cumulative_no_lost = ((expected - source->received));
+					if(!packet_lost && rblock->fraction) packet_lost = tsk_true;
+					
+					rblock->last_seq = ((source->cycles & 0xFFFF) << 16) | source->max_seq;
+					rblock->jitter = (uint32_t)source->jitter;
+					rblock->lsr = ((source->ntp_msw & 0xFFFF) << 16) | ((source->ntp_lsw & 0xFFFF0000) >> 16);
+					if(source->dlsr){
+						rblock->dlsr = (uint32_t)(((time_now - source->dlsr) * 65536) / 1000); // in units of 1/65536 seconds
+					}
+					
+					trtp_rtcp_report_sr_add_block(sr, rblock);					
+					TSK_OBJECT_SAFE_FREE(rblock);
+				}
+
+				if((media_ssrc_list_count + 1) < sizeof(media_ssrc_list)/sizeof(media_ssrc_list[0])){
+					media_ssrc_list[media_ssrc_list_count++] = source->ssrc;
+				}		
+			}
+
+			if(media_ssrc_list_count > 0){
+				// draft-alvestrand-rmcat-remb-02
+				if(session->app_bw_max_download > 0 && session->app_bw_max_download != INT_MAX){ // INT_MAX or <=0 means undefined
+					// app_bw_max_download unit is kbps while create_afb_remb() expect bps
+					trtp_rtcp_report_psfb_t* psfb_afb_remb = trtp_rtcp_report_psfb_create_afb_remb(session->source_local->ssrc/*sender SSRC*/, media_ssrc_list, media_ssrc_list_count, (session->app_bw_max_download * 1024));
+					if(psfb_afb_remb){
+						TSK_DEBUG_INFO("Packing RTCP-AFB-REMB (bw_dwn=%d kbps) for outgoing RTCP-SR", session->app_bw_max_download);
+						trtp_rtcp_packet_add_packet((trtp_rtcp_packet_t*)sr, (trtp_rtcp_packet_t*)psfb_afb_remb, tsk_false);
+						TSK_OBJECT_SAFE_FREE(psfb_afb_remb);
+					}
+				}
+			}
+
+			// serialize and send the packet
+			ret = _trtp_rtcp_session_send_pkt(session, (trtp_rtcp_packet_t*)sr);
+			TSK_OBJECT_SAFE_FREE(sr);
+		}
+	}
+
+	tsk_safeobj_unlock(session);
+	return ret;
+}
+
+static void Schedule(trtp_rtcp_session_t* session, double tn, event_ e)
+{
+	tsk_safeobj_lock(session); // must
+	switch(e){
+		case EVENT_BYE: 
+			if(!TSK_TIMER_ID_IS_VALID(session->timer.id_bye)){
+				session->timer.id_bye = tsk_timer_manager_schedule(session->timer.handle_global, (uint64_t)tn, _trtp_rtcp_session_timer_callback, session);
+			}
+			break;
+		case EVENT_REPORT:
+			if(!TSK_TIMER_ID_IS_VALID(session->timer.id_report)){
+				session->timer.id_report = tsk_timer_manager_schedule(session->timer.handle_global, (uint64_t)tn, _trtp_rtcp_session_timer_callback, session);
+			}
+			break;
+		default: TSK_DEBUG_ERROR("Unexpected code called"); break;
+	}
+	tsk_safeobj_unlock(session);
+}
+
+#define Reschedule(session, tn, e) Schedule((session), (tn), (e))
+
+static double rtcp_interval(int32_t members,
+					 int32_t senders,
+					 double rtcp_bw,
+					 int32_t we_sent,
+					 double avg_rtcp_size,
+					 tsk_bool_t initial)
+{
+	/*
+	* Minimum average time between RTCP packets from this site (in
+	* seconds).  This time prevents the reports from `clumping' when
+	* sessions are small and the law of large numbers isn't helping
+	* to smooth out the traffic.  It also keeps the report interval
+	* from becoming ridiculously small during transient outages like
+	* a network partition.
+	*/
+	#define RTCP_MIN_TIME 5.
+	/*
+	* Fraction of the RTCP bandwidth to be shared among active
+	* senders.  (This fraction was chosen so that in a typical
+	* session with one or two active senders, the computed report
+	* time would be roughly equal to the minimum report time so that
+	* we don't unnecessarily slow down receiver reports.)  The
+	* receiver fraction must be 1 - the sender fraction.
+	*/
+	#define RTCP_SENDER_BW_FRACTION 0.25
+	#define RTCP_RCVR_BW_FRACTION (1 - RTCP_SENDER_BW_FRACTION)
+	/*
+	* To compensate for "timer reconsideration" converging to a
+	* value below the intended average.
+	*/
+	#define COMPENSATION  (2.71828 - 1.5)
+
+	double t;                   /* interval */
+	double rtcp_min_time = RTCP_MIN_TIME;
+	int n;                      /* no. of members for computation */
+
+	/*
+	* Very first call at application start-up uses half the min
+	* delay for quicker notification while still allowing some time
+	* before reporting for randomization and to learn about other
+	* sources so the report interval will converge to the correct
+	* interval more quickly.
+	*/
+	if (initial) {
+		rtcp_min_time /= 2;
+	}
+	/*
+	* Dedicate a fraction of the RTCP bandwidth to senders unless
+	* the number of senders is large enough that their share is
+	* more than that fraction.
+	*/
+	n = members;
+	if (senders <= members * RTCP_SENDER_BW_FRACTION) {
+		if (we_sent) {
+			rtcp_bw *= RTCP_SENDER_BW_FRACTION;
+			n = senders;
+		} else {
+			rtcp_bw *= RTCP_RCVR_BW_FRACTION;
+			n -= senders;
+		}
+	}
+
+	/*
+	* The effective number of sites times the average packet size is
+	* the total number of octets sent when each site sends a report.
+	* Dividing this by the effective bandwidth gives the time
+	* interval over which those packets must be sent in order to
+	* meet the bandwidth target, with a minimum enforced.  In that
+	* time interval we send one report so this time is also our
+	* average time between reports.
+	*/
+	t = avg_rtcp_size * n / rtcp_bw;
+	if (t < rtcp_min_time) t = rtcp_min_time;
+
+	/*
+	* To avoid traffic bursts from unintended synchronization with
+	* other sites, we then pick our actual next report interval as a
+	* random number uniformly distributed between 0.5*t and 1.5*t.
+	*/
+	t = t * (drand48() + 0.5);
+	t = t / COMPENSATION;
+
+	return (t * 1000);
+}
+
+
+static void OnExpire(trtp_rtcp_session_t* session, event_ e)
+{
+	/* This function is responsible for deciding whether to send an
+	* RTCP report or BYE packet now, or to reschedule transmission.
+	* It is also responsible for updating the pmembers, initial, tp,
+	* and avg_rtcp_size state variables.  This function should be
+	* called upon expiration of the event timer used by Schedule().
+	*/
+
+	double t;     /* Interval */
+	double tn;    /* Next transmit time */
+	double tc;
+
+	/* In the case of a BYE, we use "timer reconsideration" to
+	* reschedule the transmission of the BYE if necessary */
+	
+	if (TypeOfEvent(e) == EVENT_BYE) {
+		t = rtcp_interval(session->members,
+			session->senders,
+			session->rtcp_bw,
+			session->we_sent,
+			session->avg_rtcp_size,
+			session->initial);
+		tn = session->tp + t;
+		if (tn <= session->tc()) {
+			SendBYEPacket(session, e);
+#if 0
+			exit(1);
+#endif
+		} else {
+#if 0
+			Schedule(session, tn, e);
+#else
+			Schedule(session, 0, e);
+#endif
+		}
+
+	} else if (TypeOfEvent(e) == EVENT_REPORT) {
+		t = rtcp_interval(session->members,
+			session->senders,
+			session->rtcp_bw,
+			session->we_sent,
+			session->avg_rtcp_size,
+			session->initial);
+		tn = session->tp + t;
+		if (tn <= (tc = session->tc())) {
+			tsk_size_t SentPacketSize = SendRTCPReport(session, e);
+			session->avg_rtcp_size = (1./16.)*SentPacketSize + (15./16.)*(session->avg_rtcp_size);
+			session->tp = tc;
+
+			/* We must redraw the interval.  Don't reuse the
+			one computed above, since its not actually
+			distributed the same, as we are conditioned
+			on it being small enough to cause a packet to
+			be sent */
+
+			t = rtcp_interval(session->members,
+				session->senders,
+				session->rtcp_bw,
+				session->we_sent,
+				session->avg_rtcp_size,
+				session->initial);
+#if 0
+			Schedule(session, t+tc, e);
+#else
+			Schedule(session, t, e);
+#endif
+			session->initial = tsk_false;
+		} else {
+#if 0
+			Schedule(session, tn, e);
+#else
+			Schedule(session, 0, e);
+#endif
+		}
+		session->pmembers = session->members;
+	}
+}
+
+static void OnReceive(trtp_rtcp_session_t* session, const packet_ p, event_ e, tsk_size_t ReceivedPacketSize)
+{
+	/* What we do depends on whether we have left the group, and are
+	* waiting to send a BYE (TypeOfEvent(e) == EVENT_BYE) or an RTCP
+	* report.  p represents the packet that was just received.  */
+
+	if (PacketType(p) == PACKET_RTCP_REPORT) {
+		if (NewMember(session, p) && (TypeOfEvent(e) == EVENT_REPORT)) {
+			session->members += (int32_t)AddMember(session, p);
+		}
+		session->avg_rtcp_size = (1./16.)*ReceivedPacketSize + (15./16.)*(session->avg_rtcp_size);
+	} else if (PacketType(p) == PACKET_RTP) {
+#if 0
+		if (NewMember(session, p) && (TypeOfEvent(e) == EVENT_REPORT)) {
+			session->members += AddMember(session, p);
+		}
+		if (NewSender(session, p) && (TypeOfEvent(e) == EVENT_REPORT)) {
+			tsk_size_t count = AddSender(session, p);
+			session->senders += count;
+			session->members += count;
+		}
+#else
+		if (NewSender(session, p)) {
+			tsk_size_t count = AddSender(session, p);
+			session->senders += (int32_t)count;
+			session->members += (int32_t)count;
+		}
+#endif
+	} else if (PacketType(p) == PACKET_BYE) {
+		session->avg_rtcp_size = (1./16.)*ReceivedPacketSize + (15./16.)*(session->avg_rtcp_size);
+
+		if (TypeOfEvent(e) == EVENT_REPORT) {
+			double tc = session->tc();
+			tsk_size_t count = RemoveMember(session, p);
+			session->senders -= (int32_t)count;
+			session->members -= (int32_t)count;
+#if 0
+			if (NewSender(session, p) == tsk_false) {
+				RemoveSender(p);
+				session->senders -= 1;
+			}
+			if (NewMember(session, p) == tsk_false) {
+				RemoveMember(p);
+				session->members -= 1;
+			}
+#endif
+
+			if (session->members < session->pmembers && session->pmembers) {
+				session->tn = (time_tp)(tc +
+					(((double) session->members)/(session->pmembers))*(session->tn - tc));
+				session->tp = (time_tp)(tc -
+					(((double) session->members)/(session->pmembers))*(tc - session->tp));
+
+				/* Reschedule the next report for time tn */
+
+				Reschedule(session, session->tn, e);
+				session->pmembers = session->members;
+			}
+
+		} else if (TypeOfEvent(e) == EVENT_BYE) {
+			session->members += 1;
+		}
+	}
+}
diff --git a/tinyRTP/src/rtp/trtp_rtp_header.c b/tinyRTP/src/rtp/trtp_rtp_header.c
new file mode 100644
index 0000000..e833b10
--- /dev/null
+++ b/tinyRTP/src/rtp/trtp_rtp_header.c
@@ -0,0 +1,259 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtp_header.c
+ * @brief RTP header.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#include "tinyrtp/rtp/trtp_rtp_header.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_memory.h"
+#include "tsk_debug.h"
+
+	/* RFC 3550 section 5.1 - RTP Fixed Header Fields
+		0                   1                   2                   3
+		0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |V=2|P|X|  CC   |M|     PT      |       sequence number         |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |                           timestamp                           |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |           synchronization source (SSRC) identifier            |
+	   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+	   |            contributing source (CSRC) identifiers             |
+	   |                             ....                              |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	*/
+
+/* Create new RTP header */
+trtp_rtp_header_t* trtp_rtp_header_create_null()
+{
+	return tsk_object_new(trtp_rtp_header_def_t);
+}
+
+trtp_rtp_header_t* trtp_rtp_header_create(uint32_t ssrc, uint16_t seq_num, uint32_t timestamp, uint8_t payload_type, tsk_bool_t marker)
+{
+	trtp_rtp_header_t* header;
+	if((header = trtp_rtp_header_create_null())){
+		header->version = TRTP_RTP_VERSION;
+		header->marker = marker ? 1 : 0;
+		header->payload_type = payload_type;
+		header->seq_num = seq_num;
+		header->timestamp = timestamp;
+		header->ssrc = ssrc;
+	}
+	return header;
+}
+
+/* guess what is the minimum required size to serialize the header */
+tsk_size_t trtp_rtp_header_guess_serialbuff_size(const trtp_rtp_header_t *self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	return (TRTP_RTP_HEADER_MIN_SIZE + (self->csrc_count << 2));
+}
+
+/* serialize the RTP header to a buffer */
+// the buffer size must be at least equal to "trtp_rtp_header_guess_serialbuff_size()"
+// returns the number of written bytes
+tsk_size_t trtp_rtp_header_serialize_to(const trtp_rtp_header_t *self, void *buffer, tsk_size_t size)
+{
+	tsk_size_t ret;
+	tsk_size_t i, j;
+	uint8_t* pbuff = (uint8_t*)buffer;
+
+	if(!buffer || (size < (ret = trtp_rtp_header_guess_serialbuff_size(self)))){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+
+	// Octet-0: version(2), Padding(1), Extension(1), CSRC Count(4)
+	pbuff[0] = (((uint8_t)self->version)<< 6) |
+		(((uint8_t)self->padding)<< 5) |
+		(((uint8_t)self->extension)<< 4) |
+		((uint8_t)self->csrc_count);
+	// Octet-1: Marker(1), Payload Type(7)
+	pbuff[1] = (((uint8_t)self->marker)<< 7) |
+		((uint8_t)self->payload_type);
+	// Octet-2-3: Sequence number (16)
+	// *((uint16_t*)&pbuff[2]) = tnet_htons(self->seq_num);
+	pbuff[2] = self->seq_num >> 8;
+	pbuff[3] = self->seq_num & 0xFF;
+	// Octet-4-5-6-7: timestamp (32)
+	// ((uint32_t*)&pbuff[4]) = tnet_htonl(self->timestamp);
+	pbuff[4] = self->timestamp >> 24;
+	pbuff[5] = (self->timestamp >> 16) & 0xFF;
+	pbuff[6] = (self->timestamp >> 8) & 0xFF;
+	pbuff[7] = self->timestamp & 0xFF;	
+	// Octet-8-9-10-11: SSRC (32)
+	//((uint32_t*)&pbuff[8]) = tnet_htonl(self->ssrc);
+	pbuff[8] = self->ssrc >> 24;
+	pbuff[9] = (self->ssrc >> 16) & 0xFF;
+	pbuff[10] = (self->ssrc >> 8) & 0xFF;
+	pbuff[11] = self->ssrc & 0xFF;
+
+	// Octet-12-13-14-15-****: CSRC
+	for(i = 0, j = 12; i<self->csrc_count; ++i, ++j){
+		// *((uint32_t*)&pbuff[12+i]) = tnet_htonl(self->csrc[i]);
+		pbuff[j] = self->csrc[i] >> 24;
+		pbuff[j + 1] = (self->csrc[i] >> 16) & 0xFF;
+		pbuff[j + 2] = (self->csrc[i] >> 8) & 0xFF;
+		pbuff[j + 3] = self->csrc[i] & 0xFF;
+	}
+	
+	return ret;
+}
+
+/** Serialize rtp header object into binary buffer */
+tsk_buffer_t* trtp_rtp_header_serialize(const trtp_rtp_header_t *self)
+{
+	tsk_buffer_t* buffer;
+	tsk_size_t size;
+
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	
+	size = trtp_rtp_header_guess_serialbuff_size(self);
+	if(!(buffer = tsk_buffer_create(tsk_null, size))){
+		TSK_DEBUG_ERROR("Failed to create new buffer");
+		TSK_OBJECT_SAFE_FREE(buffer);
+	}
+	else{
+		size = trtp_rtp_header_serialize_to(self, buffer->data, buffer->size);
+	}
+
+	return buffer;
+}
+
+/** Deserialize rtp header object from binary buffer */
+trtp_rtp_header_t* trtp_rtp_header_deserialize(const void *data, tsk_size_t size)
+{
+	trtp_rtp_header_t* header = tsk_null;
+	const uint8_t* pdata = (const uint8_t*)data;
+	uint8_t csrc_count, i;
+
+	if(!data){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+
+	if(size <TRTP_RTP_HEADER_MIN_SIZE){
+		TSK_DEBUG_ERROR("Too short to contain RTP header");
+		return tsk_null;
+	}
+
+	/* Before starting to deserialize, get the "csrc_count" and check the length validity
+	* CSRC count (4 last bits)
+	*/
+	csrc_count = (*pdata & 0x0F);
+	if(size <(tsk_size_t)TRTP_RTP_HEADER_MIN_SIZE + (csrc_count << 2)){
+		TSK_DEBUG_ERROR("Too short to contain RTP header");
+		return tsk_null;
+	}
+
+	if(!(header = trtp_rtp_header_create_null())){
+		TSK_DEBUG_ERROR("Failed to create new RTP header");
+		return tsk_null;
+	}
+
+	/* version (2bits) */
+	header->version = (*pdata >> 6);
+	/* Padding (1bit) */
+	header->padding = ((*pdata >>5) & 0x01);
+	/* Extension (1bit) */
+	header->extension = ((*pdata >>4) & 0x01);
+	/* CSRC Count (4bits) */
+	header->csrc_count = csrc_count;
+	// skip octet
+	++pdata;
+
+	/* Marker (1bit) */
+	header->marker = (*pdata >> 7);
+	/* Payload Type (7bits) */
+	header->payload_type = (*pdata & 0x7F);
+	// skip octet
+	++pdata;
+
+	/* Sequence Number (16bits) */
+	header->seq_num = pdata[0] << 8 | pdata[1];
+	// skip octets
+	pdata += 2;
+
+	/* timestamp (32bits) */
+	header->timestamp = pdata[0] << 24 | pdata[1] << 16 | pdata[2] << 8 | pdata[3];
+	// skip octets
+	pdata += 4;
+
+	/* synchronization source (SSRC) identifier (32bits) */
+	header->ssrc = pdata[0] << 24 | pdata[1] << 16 | pdata[2] << 8 | pdata[3];
+	// skip octets
+	pdata += 4;
+
+	/* contributing source (CSRC) identifiers */
+	for(i=0; i<csrc_count; i++, pdata += 4){
+		header->csrc[i] = pdata[0] << 24 | pdata[1] << 16 | pdata[2] << 8 | pdata[3];
+	}
+	
+	return header;
+}
+
+
+
+
+
+
+//=================================================================================================
+//	RTP header object definition
+//
+static tsk_object_t* trtp_rtp_header_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtp_header_t *header = self;
+	if(header){
+	}
+	return self;
+}
+
+static tsk_object_t* trtp_rtp_header_dtor(tsk_object_t * self)
+{ 
+	trtp_rtp_header_t *header = self;
+	if(header){
+	}
+
+	return self;
+}
+
+static const tsk_object_def_t trtp_rtp_header_def_s = 
+{
+	sizeof(trtp_rtp_header_t),
+	trtp_rtp_header_ctor, 
+	trtp_rtp_header_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_rtp_header_def_t = &trtp_rtp_header_def_s;
diff --git a/tinyRTP/src/rtp/trtp_rtp_packet.c b/tinyRTP/src/rtp/trtp_rtp_packet.c
new file mode 100644
index 0000000..dc5c7ea
--- /dev/null
+++ b/tinyRTP/src/rtp/trtp_rtp_packet.c
@@ -0,0 +1,260 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtp_packet.c
+ * @brief RTP packet.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#include "tinyrtp/rtp/trtp_rtp_packet.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_memory.h"
+#include "tsk_debug.h"
+
+#include <string.h> /* memcpy() */
+
+/** Create new RTP packet */
+trtp_rtp_packet_t* trtp_rtp_packet_create_null()
+{
+	return tsk_object_new(trtp_rtp_packet_def_t);
+}
+
+trtp_rtp_packet_t* trtp_rtp_packet_create(uint32_t ssrc, uint16_t seq_num, uint32_t timestamp, uint8_t payload_type, tsk_bool_t marker)
+{
+	trtp_rtp_packet_t* packet;
+	if((packet = tsk_object_new(trtp_rtp_packet_def_t))){
+		packet->header = trtp_rtp_header_create(ssrc, seq_num, timestamp, payload_type, marker);
+	}
+	return packet;
+}
+
+trtp_rtp_packet_t* trtp_rtp_packet_create_2(const trtp_rtp_header_t* header)
+{
+	trtp_rtp_packet_t* packet;
+
+	if(!header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	if((packet = tsk_object_new(trtp_rtp_packet_def_t))){
+		packet->header = tsk_object_ref(TSK_OBJECT(header));
+	}
+	return packet;
+}
+
+/* guess what is the minimum required size to serialize the packet */
+tsk_size_t trtp_rtp_packet_guess_serialbuff_size(const trtp_rtp_packet_t *self)
+{	
+	tsk_size_t size = 0;
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	size += trtp_rtp_header_guess_serialbuff_size(self->header);
+	if(self->extension.data && self->extension.size && self->header->extension){
+		size += self->extension.size;
+	}
+	size += self->payload.size;
+	return size;
+}
+
+/* serialize the RTP packet to a buffer */
+// the buffer size must be at least equal to "trtp_rtp_packet_guess_serialbuff_size()"
+// returns the number of written bytes
+tsk_size_t trtp_rtp_packet_serialize_to(const trtp_rtp_packet_t *self, void* buffer, tsk_size_t size)
+{
+	tsk_size_t ret;
+	tsk_size_t s;
+	uint8_t* pbuff = (uint8_t*)buffer;
+
+	if(!buffer || (size < (ret = trtp_rtp_packet_guess_serialbuff_size(self)))){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+
+	s = trtp_rtp_header_serialize_to(self->header, pbuff, size);
+	pbuff += s;
+
+	/* extension */
+	if(self->extension.data && self->extension.size && self->header->extension){
+		memcpy(pbuff, self->extension.data, self->extension.size);
+		pbuff += self->extension.size;
+	}
+	/* append payload */
+	memcpy(pbuff, self->payload.data_const ? self->payload.data_const : self->payload.data, self->payload.size);
+
+	return ret;
+}
+
+/** Serialize rtp packet object into binary buffer */
+// num_bytes_pad: number of bytes to add to the buffer. Useful to have the packet byte aligned or to prepare for SRTP protection
+// the padding bytes will not be added to the final buffer size
+tsk_buffer_t* trtp_rtp_packet_serialize(const trtp_rtp_packet_t *self, tsk_size_t num_bytes_pad)
+{
+	tsk_buffer_t* buffer = tsk_null;
+	tsk_size_t size;
+
+	if(!self || !self->header){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+
+	size = (trtp_rtp_packet_guess_serialbuff_size(self) + num_bytes_pad);
+	if(size & 0x03) size += (4 - (size & 0x03));
+	
+	if(!(buffer = tsk_buffer_create(tsk_null, size))){
+		TSK_DEBUG_ERROR("Failed to create buffer with size = %u", (unsigned)size);
+		return tsk_null;
+	}
+	// shorten the buffer to hide the padding
+	buffer->size = trtp_rtp_packet_serialize_to(self, buffer->data, buffer->size);
+	return buffer;
+}
+
+/** Deserialize rtp packet object from binary buffer */
+trtp_rtp_packet_t* trtp_rtp_packet_deserialize(const void *data, tsk_size_t size)
+{
+	trtp_rtp_packet_t* packet = tsk_null;
+	trtp_rtp_header_t *header;
+	tsk_size_t payload_size;
+	const uint8_t* pdata = data;
+
+	if(!data){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+
+	if(size< TRTP_RTP_HEADER_MIN_SIZE){
+		TSK_DEBUG_ERROR("Too short to contain RTP message");
+		return tsk_null;
+	}
+	
+	/* deserialize the RTP header (the packet itsel will be deserialized only if the header deserialization succeed) */
+	if(!(header = trtp_rtp_header_deserialize(data, size))){
+		TSK_DEBUG_ERROR("Failed to deserialize RTP header");
+		return tsk_null;
+	}
+	else{
+		/* create the packet */
+		if(!(packet = trtp_rtp_packet_create_null())){
+			TSK_DEBUG_ERROR("Failed to create new RTP packet");
+			TSK_OBJECT_SAFE_FREE(header);
+			return tsk_null;
+		}
+		/* set the header */
+		packet->header = header,
+			header = tsk_null;
+		
+		/* do not need to check overflow (have been done by trtp_rtp_header_deserialize()) */
+		payload_size = (size - TRTP_RTP_HEADER_MIN_SIZE - (packet->header->csrc_count << 2));
+		pdata = ((const uint8_t*)data) + (size - payload_size);
+
+		/*	RFC 3550 - 5.3.1 RTP Header Extension
+			If the X bit in the RTP header is one, a variable-length header
+			extension MUST be appended to the RTP header, following the CSRC list
+			if present.  The header extension contains a 16-bit length field that
+			counts the number of 32-bit words in the extension, excluding the
+			four-octet extension header (therefore zero is a valid length).  Only
+			a single extension can be appended to the RTP data header.
+			0                   1                   2                   3
+			0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+		   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		   |      defined by profile       |           length              |
+		   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		   |                        header extension                       |
+		   |                             ....                              |
+		*/
+		if(packet->header->extension && payload_size>=4 /* extension min-size */){
+			packet->extension.size = 4 /* first two 16-bit fields */ + (tnet_ntohs(*((uint16_t*)&pdata[2])) << 2/*words(32-bit)*/);
+			if((packet->extension.data = tsk_calloc(packet->extension.size, sizeof(uint8_t)))){
+				memcpy(packet->extension.data, pdata, packet->extension.size);
+			}
+			payload_size -= packet->extension.size;
+		}
+
+		packet->payload.size = payload_size;
+		if(payload_size && (packet->payload.data = tsk_calloc(packet->payload.size, sizeof(uint8_t)))){
+			memcpy(packet->payload.data, (pdata + packet->extension.size), packet->payload.size);
+		}
+		else{
+			TSK_DEBUG_ERROR("Failed to allocate new buffer");
+			packet->payload.size = 0;
+		}
+	}
+
+	return packet;
+}
+
+
+
+
+
+
+
+
+
+//=================================================================================================
+//	RTP packet object definition
+//
+static tsk_object_t* trtp_rtp_packet_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_rtp_packet_t *packet = self;
+	if(packet){
+	}
+	return self;
+}
+static tsk_object_t* trtp_rtp_packet_dtor(tsk_object_t * self)
+{ 
+	trtp_rtp_packet_t *packet = self;
+	if(packet){
+		TSK_OBJECT_SAFE_FREE(packet->header);
+		TSK_FREE(packet->payload.data);
+		TSK_FREE(packet->extension.data);
+		packet->payload.data_const = tsk_null;
+	}
+
+	return self;
+}
+// comparison must be by sequence number because of the jb
+static int trtp_rtp_packet_cmp(const tsk_object_t *_p1, const tsk_object_t *_p2)
+{
+	const trtp_rtp_packet_t *p1 = _p1;
+	const trtp_rtp_packet_t *p2 = _p2;
+
+	if(p1 && p1->header && p2 && p2->header){
+		return (int)(p1->header->seq_num - p2->header->seq_num);
+	}
+	else if(!p1 && !p2) return 0;
+	else return -1;
+}
+
+static const tsk_object_def_t trtp_rtp_packet_def_s = 
+{
+	sizeof(trtp_rtp_packet_t),
+	trtp_rtp_packet_ctor, 
+	trtp_rtp_packet_dtor,
+	trtp_rtp_packet_cmp, 
+};
+const tsk_object_def_t *trtp_rtp_packet_def_t = &trtp_rtp_packet_def_s;
diff --git a/tinyRTP/src/rtp/trtp_rtp_session.c b/tinyRTP/src/rtp/trtp_rtp_session.c
new file mode 100644
index 0000000..3ebfe03
--- /dev/null
+++ b/tinyRTP/src/rtp/trtp_rtp_session.c
@@ -0,0 +1,29 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_rtp_session.c
+ * @brief RTP session.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#include "tinyrtp/rtp/trtp_rtp_session.h"
\ No newline at end of file
diff --git a/tinyRTP/src/trtp.c b/tinyRTP/src/trtp.c
new file mode 100644
index 0000000..a0150d9
--- /dev/null
+++ b/tinyRTP/src/trtp.c
@@ -0,0 +1,30 @@
+/*
+* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp.h
+ * @brief tinyRTP (Real-time Transport Protocol) as per RFC 3550.
+ *
+ * @author Mamadou Diop <diopmamadou(at)doubango.org>
+ *
+
+ */
+#include "tinyrtp/trtp.h"
+
diff --git a/tinyRTP/src/trtp_manager.c b/tinyRTP/src/trtp_manager.c
new file mode 100644
index 0000000..6e6b00e
--- /dev/null
+++ b/tinyRTP/src/trtp_manager.c
@@ -0,0 +1,1960 @@
+/*
+* Copyright (C) 2012 Mamadou Diop
+* Copyright (C) 2012-2013 Doubango Telecom <http://www.doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+/**@file trtp_manager.c
+* @brief RTP/RTCP manager.
+*
+*/
+#include "tinyrtp/trtp_manager.h"
+
+#include "tinyrtp/rtp/trtp_rtp_packet.h"
+#include "tinyrtp/rtcp/trtp_rtcp_packet.h"
+#include "tinyrtp/rtcp/trtp_rtcp_session.h"
+
+#include "tnet_proxydetect.h"
+#include "turn/tnet_turn_session.h"
+#include "ice/tnet_ice_candidate.h"
+
+#include "tsk_string.h"
+#include "tsk_memory.h"
+#include "tsk_base64.h"
+#include "tsk_md5.h"
+#include "tsk_debug.h"
+
+#include <limits.h> /* INT_MAX */
+
+#if !defined(TRTP_TRANSPORT_NAME)
+#	define TRTP_TRANSPORT_NAME "RTP/RTCP Manager"
+#endif
+
+#if !defined(TRTP_DISABLE_SOCKETS_BEFORE_START)
+#	define TRTP_DISABLE_SOCKETS_BEFORE_START	0
+#endif
+#if !defined(TRTP_TINY_RCVBUF)
+#	define TRTP_TINY_RCVBUF					(256>>1/*Will be doubled and min on linux is 256*/) /* tiny buffer used to disable receiving */
+#endif
+
+#if !defined(TRTP_DSCP_RTP_DEFAULT)
+#	define TRTP_DSCP_RTP_DEFAULT           /* 0x2e */ 0x00
+#endif
+
+#if !defined(TRTP_PORT_RANGE_START)
+#	define TRTP_PORT_RANGE_START 1024
+#endif
+#if !defined(TRTP_PORT_RANGE_STOP)
+#	define TRTP_PORT_RANGE_STOP 65535
+#endif
+
+#if !defined(TRTP_DTLS_HANDSHAKING_TIMEOUT)
+#	define TRTP_DTLS_HANDSHAKING_TIMEOUT 1000
+#endif
+#if !defined(TRTP_DTLS_HANDSHAKING_TIMEOUT_MAX)
+#	define TRTP_DTLS_HANDSHAKING_TIMEOUT_MAX (TRTP_DTLS_HANDSHAKING_TIMEOUT << 20)
+#endif
+
+static const tmedia_srtp_type_t __srtp_types[] = { tmedia_srtp_type_sdes, tmedia_srtp_type_dtls };
+
+static int _trtp_manager_recv_data(const trtp_manager_t* self, const uint8_t* data_ptr, tsk_size_t data_size, tnet_fd_t local_fd, const struct sockaddr_storage* remote_addr);
+#define _trtp_manager_is_rtcpmux_active(self) ( (self) && ( (self)->use_rtcpmux && (!(self)->rtcp.local_socket || ((self)->transport && (self)->transport->master && (self)->transport->master->fd == (self)->rtcp.local_socket->fd)) ) )
+static int _trtp_manager_send_turn_dtls(struct tnet_ice_ctx_s* ice_ctx, const void* handshaking_data_ptr, tsk_size_t handshaking_data_size, tsk_bool_t use_rtcp_channel);
+#define _trtp_manager_send_turn_dtls_rtp(ice_ctx, handshaking_data_ptr, handshaking_data_size) _trtp_manager_send_turn_dtls((ice_ctx), (handshaking_data_ptr), (handshaking_data_size), /*use_rtcp_channel =*/tsk_false)
+#define _trtp_manager_send_turn_dtls_rtcp(ice_ctx, handshaking_data_ptr, handshaking_data_size) _trtp_manager_send_turn_dtls((ice_ctx), (handshaking_data_ptr), (handshaking_data_size), /*use_rtcp_channel =*/tsk_true)
+#if HAVE_SRTP
+static int _trtp_manager_srtp_set_enabled(trtp_manager_t* self, tmedia_srtp_type_t srtp_type, struct tnet_socket_s** sockets, tsk_size_t count, tsk_bool_t enabled);
+static int _trtp_manager_srtp_activate(trtp_manager_t* self, tmedia_srtp_type_t srtp_type);
+static int _trtp_manager_srtp_start(trtp_manager_t* self, tmedia_srtp_type_t srtp_type);
+#endif /* HAVE_SRTP */
+
+
+/* ======================= Transport callback ========================== */
+static int _trtp_transport_layer_cb(const tnet_transport_event_t* e)
+{
+	trtp_manager_t* manager = (trtp_manager_t*)e->callback_data;
+
+	switch(e->type){
+		case event_data:
+			{
+				return _trtp_manager_recv_data(manager, e->data, e->size, e->local_fd, &e->remote_addr);
+			}
+        case event_brokenpipe:
+            {
+                tsk_safeobj_lock(manager);
+                tnet_fd_t broken_fd = e->local_fd;
+                tnet_socket_t* socket = tsk_null;
+                tsk_bool_t is_rtcp_socket = tsk_false;
+                
+                if (manager->transport && manager->transport->master &&  manager->transport->master->fd == broken_fd) {
+                    socket = manager->transport->master;
+                }
+                else if (manager->rtcp.local_socket && manager->rtcp.local_socket->fd == broken_fd) {
+                    socket = manager->rtcp.local_socket;
+                    is_rtcp_socket = tsk_true;
+                }
+                if (socket) {
+                    tsk_bool_t registered_fd = !!tnet_transport_have_socket(manager->transport, broken_fd);
+                    if (registered_fd) {
+                        tnet_transport_remove_socket(manager->transport, &broken_fd); // broken_fd=-1
+                        broken_fd = e->local_fd; // restore
+                    }
+                    if (tnet_socket_handle_brokenpipe(socket) == 0) {
+                        if (registered_fd) {
+                            tnet_transport_add_socket(manager->transport, socket->fd, socket->type, tsk_false/* do not take ownership */, tsk_true/* only Meaningful for tls*/, tsk_null);
+                        }
+                        if (manager->rtcp.session && trtp_rtcp_session_get_local_fd(manager->rtcp.session) == broken_fd) {
+                            trtp_rtcp_session_set_local_fd(manager->rtcp.session, socket->fd);
+                        }
+                    }
+                }
+                tsk_safeobj_unlock(manager);
+                return 0;
+            }
+#if HAVE_SRTP
+			/* DTLS - SRTP events */
+		case event_dtls_handshake_succeed:
+			{
+				const tnet_socket_t* socket = manager->transport && manager->transport->master && (manager->transport->master->fd == e->local_fd)
+					? manager->transport->master
+					: ((manager->rtcp.local_socket && manager->rtcp.local_socket->fd == e->local_fd) ? manager->rtcp.local_socket : tsk_null);
+				if(!socket){
+					TSK_DEBUG_ERROR("DTLS data from unknown socket");
+					break;
+				}
+				
+				if (!manager->dtls.srtp_handshake_succeed) {
+					manager->dtls.srtp_handshake_succeed = (socket == manager->transport->master);
+				}
+				if (!manager->dtls.srtcp_handshake_succeed) {
+					manager->dtls.srtcp_handshake_succeed = (socket == manager->rtcp.local_socket) || _trtp_manager_is_rtcpmux_active(manager);
+				}
+
+				TSK_DEBUG_INFO("dtls.srtp_handshake_succeed=%d, dtls.srtcp_handshake_succeed=%d", manager->dtls.srtp_handshake_succeed, manager->dtls.srtcp_handshake_succeed);
+				TSK_DEBUG_INFO("DTLS-DTLS-SRTP socket [%s]:%d handshake succeed", socket->ip, socket->port);
+
+				if(manager->dtls.srtp_handshake_succeed && manager->dtls.srtcp_handshake_succeed){
+					// alter listeners
+					if(manager->dtls.cb.fun){
+						manager->dtls.cb.fun(manager->dtls.cb.usrdata, trtp_srtp_dtls_event_type_handshake_succeed, "DTLS handshake succeed");
+					}
+				}
+				break;
+			} 
+		case event_dtls_fingerprint_mismatch:
+		case event_dtls_handshake_failed:
+		case event_dtls_error:
+			{
+				// alter listeners
+				if(manager->dtls.cb.fun){
+					const char* reason = (e->type == event_dtls_fingerprint_mismatch) 
+						? "DTLS-SRTP fingerprint mismatch"
+						: (e->type == event_dtls_handshake_failed ? "DTLS-SRTP handshake failed" : "DTLS error");
+					manager->dtls.cb.fun(manager->dtls.cb.usrdata, trtp_srtp_dtls_event_type_handshake_failed, reason);
+				}
+				break;
+			}
+		case event_dtls_srtp_data:
+			{
+				/* KEY||SALT */
+				/* rfc 5764 - 4.2.  Key Derivation */
+				tsk_bool_t is_rtp = (manager->transport->master && manager->transport->master->fd == e->local_fd);
+				tsk_bool_t is_rtcp = (manager->rtcp.local_socket && manager->rtcp.local_socket->fd == e->local_fd);
+				if(is_rtp || is_rtcp){
+					unsigned int master_salt_length, master_key_length;
+					
+#if HAVE_SRTP_PROFILE_GET_MASTER_KEY_LENGTH
+					master_key_length = srtp_profile_get_master_key_length(manager->dtls.crypto_selected == HMAC_SHA1_32 ? srtp_profile_aes128_cm_sha1_32 : srtp_profile_aes128_cm_sha1_80);
+#else
+					master_key_length = (128 >> 3); // cipher_key_length - rfc5764 4.1.2.  SRTP Protection Profiles
+#endif
+#if HAVE_SRTP_PROFILE_GET_MASTER_SALT_LENGTH
+					master_salt_length = srtp_profile_get_master_salt_length(manager->dtls.crypto_selected == HMAC_SHA1_32 ? srtp_profile_aes128_cm_sha1_32 : srtp_profile_aes128_cm_sha1_80);
+#else
+					master_salt_length = (112 >> 3); // cipher_salt_length - rfc5764 4.1.2.  SRTP Protection Profiles
+#endif
+					if(((master_key_length + master_salt_length) << 1) > e->size){
+						TSK_DEBUG_ERROR("%d not a valid size for this profile", (int)e->size);
+					}
+					else{
+						int ret;
+						const uint8_t* data_ptr = e->data;
+						const uint8_t *lk, *ls, *rk, *rs;
+						if(manager->dtls.local.setup == tnet_dtls_setup_passive){
+							rk = &data_ptr[0]; 
+							lk = rk + master_key_length;
+							rs = (lk + master_key_length); 
+							ls = (rs + master_salt_length);
+						}
+						else{
+							lk = &data_ptr[0]; 
+							rk = lk + master_key_length;
+							ls = (rk + master_key_length); 
+							rs = (ls + master_salt_length);
+						}
+						// set key||salt
+						if((ret = trtp_srtp_set_key_and_salt_remote(manager, manager->dtls.crypto_selected, rk, master_key_length, rs, master_salt_length, is_rtp))){
+							if(manager->dtls.cb.fun) manager->dtls.cb.fun(manager->dtls.cb.usrdata, trtp_srtp_dtls_event_type_fatal_error, "Failed to set remote DTSL-SRTP key||salt");
+							return ret;
+						}
+						if((ret = trtp_srtp_set_key_and_salt_local(manager, manager->dtls.crypto_selected, lk, master_key_length, ls, master_salt_length, is_rtp))){
+							if(manager->dtls.cb.fun) manager->dtls.cb.fun(manager->dtls.cb.usrdata, trtp_srtp_dtls_event_type_fatal_error, "Failed to set local DTSL-SRTP key||salt");
+							return ret;
+						}
+						
+						if(is_rtp){
+							manager->dtls.srtp_connected = manager->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][manager->dtls.crypto_selected].rtp.initialized;
+							if(_trtp_manager_is_rtcpmux_active(manager)){
+								manager->dtls.srtcp_connected = tsk_true;
+							}
+						}
+						else{ // rtcp
+							manager->dtls.srtcp_connected = manager->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][manager->dtls.crypto_selected].rtcp.initialized;
+						}
+						TSK_DEBUG_INFO("dtls.srtp_connected=%d, dtls.srtcp_connected=%d", manager->dtls.srtp_connected, manager->dtls.srtcp_connected);
+
+						if(manager->dtls.srtp_connected && manager->dtls.srtcp_connected){
+							// start DTLS-SRTP
+							if((ret = _trtp_manager_srtp_start(manager, manager->srtp_type))){
+								if(manager->dtls.cb.fun) manager->dtls.cb.fun(manager->dtls.cb.usrdata, trtp_srtp_dtls_event_type_fatal_error, "Failed to set start DTSL-SRTP engine");
+								return ret;
+							}
+							
+							TSK_DEBUG_INFO("!!DTLS-SRTP started!!");
+
+							// alter listeners
+							if(manager->dtls.cb.fun){
+								manager->dtls.cb.fun(manager->dtls.cb.usrdata, trtp_srtp_dtls_event_type_started, "DTLS started");
+							}
+						}
+					}
+				}
+
+				break;
+			}
+		case event_dtls_srtp_profile_selected:
+			{
+				if(manager->transport->master && manager->transport->master->fd == e->local_fd){
+					/* Only (SRTP_AES128_CM_SHA1_80 | SRTP_AES128_CM_SHA1_32) because of _trtp_manager_srtp_activate() */
+					TSK_DEBUG_INFO("event_dtls_srtp_profile_selected: %.*s", 22, (const char*)e->data);
+					manager->dtls.crypto_selected = HMAC_SHA1_80;
+					if(tsk_strnequals(e->data, "SRTP_AES128_CM_SHA1_32", 22)){
+						manager->dtls.crypto_selected = HMAC_SHA1_32;
+					}
+				}
+				break;
+			}
+#endif /* HAVE_SRTP */
+
+		case event_connected:
+		case event_closed:
+			{
+				
+				break;
+			}
+		default:
+			break;
+	}
+	return 0;
+}
+
+static int _trtp_transport_dtls_handshaking_timer_cb(const void* arg, tsk_timer_id_t timer_id)
+{
+	int ret = 0;
+#if HAVE_SRTP
+	trtp_manager_t* manager = (trtp_manager_t*)arg;
+
+	tsk_safeobj_lock(manager);
+	if (manager->is_started && manager->dtls.timer_hanshaking.id == timer_id && manager->srtp_state == trtp_srtp_state_activated && manager->srtp_type == tmedia_srtp_type_dtls) {
+		// retry DTLS-SRTP handshaking if srtp-type is DTLS-SRTP and the engine is activated
+		struct tnet_socket_s* sockets[] = { manager->dtls.srtp_connected ? tsk_null : manager->transport->master , manager->dtls.srtcp_connected ? tsk_null : manager->rtcp.local_socket };
+		const struct sockaddr_storage* remote_addrs[] = { &manager->rtp.remote_addr, &manager->rtcp.remote_addr };
+		TSK_DEBUG_INFO("_trtp_transport_dtls_handshaking_timer_cb(timeout=%llu)", manager->dtls.timer_hanshaking.timeout);
+		tnet_transport_dtls_do_handshake(manager->transport, sockets, 2, remote_addrs, 2);
+		if (manager->is_ice_turn_active) {
+			// means TURN is active and handshaking data must be sent using this channel
+			const void* data[] = { tsk_null, tsk_null };
+			tsk_size_t size[] = { 0, 0 };
+			if ((ret = tnet_transport_dtls_get_handshakingdata(manager->transport, (const struct tnet_socket_s**)sockets, 2, data, size))) {
+				return ret;
+			}
+			if (data[0] && size[0]) {
+				ret = _trtp_manager_send_turn_dtls_rtp(manager->ice_ctx, data[0], size[0]);
+			}
+			if (data[1] && size[1]) {
+				ret = _trtp_manager_send_turn_dtls_rtcp(manager->ice_ctx, data[1], size[1]);
+			}
+		}
+		// increase timeout
+		manager->dtls.timer_hanshaking.timeout += (TRTP_DTLS_HANDSHAKING_TIMEOUT >> 1);
+		if ((manager->dtls.timer_hanshaking.timeout < TRTP_DTLS_HANDSHAKING_TIMEOUT_MAX) && !(manager->dtls.srtp_connected && manager->dtls.srtcp_connected)) {
+			manager->dtls.timer_hanshaking.id = tsk_timer_manager_schedule(manager->timer_mgr_global, manager->dtls.timer_hanshaking.timeout, _trtp_transport_dtls_handshaking_timer_cb, manager);
+		}
+		else {
+			manager->dtls.timer_hanshaking.id = TSK_INVALID_TIMER_ID; // invalidate timer id (not required but should be done by good citizen)
+			manager->dtls.timer_hanshaking.timeout = TRTP_DTLS_HANDSHAKING_TIMEOUT; // reset timeout
+		}
+	}
+	tsk_safeobj_unlock(manager);
+#endif
+	
+	return ret;
+}
+
+#if 0
+static int _trtp_manager_enable_sockets(trtp_manager_t* self)
+{
+	int rcv_buf = tmedia_defaults_get_rtpbuff_size();
+	int snd_buf = tmedia_defaults_get_rtpbuff_size();
+	int ret;
+
+	if(!self->socket_disabled){
+		return 0;
+	}
+
+	if(!self || !self->transport){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	if((ret = setsockopt(self->transport->master->fd, SOL_SOCKET, SO_RCVBUF, (char*)&rcv_buf, sizeof(rcv_buf)))){
+		TNET_PRINT_LAST_ERROR("setsockopt(SOL_SOCKET, SO_RCVBUF) has failed with error code %d", ret);
+		return ret;
+	}
+	if((ret = setsockopt(self->transport->master->fd, SOL_SOCKET, SO_SNDBUF, (char*)&snd_buf, sizeof(snd_buf)))){
+		TNET_PRINT_LAST_ERROR("setsockopt(SOL_SOCKET, SO_RCVBUF) has failed with error code %d", ret);
+		return ret;
+	}
+
+	self->socket_disabled = tsk_false;
+	return 0;
+}
+#endif
+
+static trtp_manager_t* _trtp_manager_create(tsk_bool_t use_rtcp, const char* local_ip, tsk_bool_t ipv6, tmedia_srtp_type_t srtp_type, tmedia_srtp_mode_t srtp_mode)
+{
+	trtp_manager_t* manager;
+
+#if HAVE_SRTP
+	static tsk_bool_t __strp_initialized = tsk_false;
+	err_status_t srtp_err;
+	if(!__strp_initialized){
+		if((srtp_err = srtp_init()) != err_status_ok){
+			TSK_DEBUG_ERROR("srtp_init() failed with error code = %d", srtp_err);
+		}
+		__strp_initialized = (srtp_err == err_status_ok);
+	}
+#endif
+
+	if((manager = tsk_object_new(trtp_manager_def_t))){
+		manager->use_rtcp = use_rtcp;
+		manager->local_ip = tsk_strdup(local_ip);
+		manager->use_ipv6 = ipv6;
+#if HAVE_SRTP
+		manager->srtp_type = srtp_type;
+		manager->srtp_mode = srtp_mode;
+#endif
+		manager->rtp.payload_type = 127;
+	}
+	return manager;
+}
+
+static int _trtp_manager_recv_data(const trtp_manager_t* self, const uint8_t* data_ptr, tsk_size_t data_size, tnet_fd_t local_fd, const struct sockaddr_storage* remote_addr)
+{
+	tsk_bool_t is_rtp_rtcp, is_rtcp = tsk_false, is_rtp = tsk_false, is_stun, is_dtls;
+
+	if (!self->is_started) {
+		TSK_DEBUG_INFO("RTP manager not started yet");
+		return 0;
+	}
+
+	// defined when RTCP-MUX is disabled and RTCP port is equal to "RTP Port + 1"
+
+	// rfc5764 - 5.1.2.  Reception
+	// rfc5761 - 4.  Distinguishable RTP and RTCP Packets
+
+	is_rtp_rtcp = (127 < *data_ptr && *data_ptr < 192);
+	if(is_rtp_rtcp){
+		is_stun = is_dtls = tsk_false;
+		is_rtcp = (self->rtcp.local_socket && self->rtcp.local_socket->fd == local_fd);
+		if(!is_rtcp && data_size >= 2 && (data_ptr[1] & 0x80)){
+			if(is_rtp_rtcp){
+				switch((data_ptr[1] & 0x7F)){
+					case 64: case 65: 
+					case 72: case 73: case 74: case 75: case 76:
+					case 77: case 78:
+					case 79: is_rtcp = tsk_true; break;
+				}
+			}
+		}
+		is_rtp = !is_rtcp;
+	}
+	else{
+		is_dtls = !is_rtp_rtcp && (19 < *data_ptr && *data_ptr < 64);
+		is_stun = !is_dtls && TNET_STUN_BUFF_IS_STUN2(data_ptr, data_size); /* MUST NOT USE: "(*data_ptr < 2)" beacause of "Old VAT" which starts with "0x00" */;
+	}
+
+	if(is_dtls){
+		tnet_socket_t* socket = (self->transport && self->transport->master && self->transport->master->fd == local_fd)
+			? self->transport->master
+			: ((self->rtcp.local_socket && self->rtcp.local_socket->fd == local_fd) ? self->rtcp.local_socket : tsk_null);
+		if (socket && socket->dtlshandle) {
+			TSK_DEBUG_INFO("Receive %s-DTLS data on ip=%s and port=%d", (socket == self->transport->master) ? "RTP" : "RTCP", socket->ip, socket->port);
+			// Handle incoming data then do handshaking
+			tnet_dtls_socket_handle_incoming_data(socket->dtlshandle, data_ptr, data_size);
+			if (self->is_ice_turn_active) {
+				// means TURN is active and handshaking data must be sent using the channel
+				const void* data =  tsk_null;
+				tsk_size_t size = 0;
+				if (tnet_transport_dtls_get_handshakingdata(self->transport, (const struct tnet_socket_s**)&socket, 1, &data, &size) == 0) {
+					if (data && size > 0){
+						if (self->rtcp.local_socket == socket) {
+							/*ret = */_trtp_manager_send_turn_dtls_rtcp(self->ice_ctx, data, size);
+						}
+						else {
+							/*ret = */_trtp_manager_send_turn_dtls_rtp(self->ice_ctx, data, size);
+						}
+					}
+				}
+			}
+		}
+		return 0;
+	}
+
+	if(is_stun){
+		static tsk_bool_t role_conflict = tsk_false;
+		if(self->ice_ctx){
+			return tnet_ice_ctx_recv_stun_message(self->ice_ctx, data_ptr, data_size, local_fd, remote_addr, &role_conflict);
+		}
+		return 0;
+	}
+	if(is_rtcp){
+		if(!self->is_symetric_rtcp_checked && self->is_force_symetric_rtp){
+			((trtp_manager_t*)self)->is_symetric_rtcp_checked = tsk_true;
+			if(!self->is_ice_neg_ok && remote_addr){ // do not force symetric RTCP is ICE negotiation succeed
+				TSK_DEBUG_INFO("Using symetric RTCP for [%s]:%d", self->rtcp.remote_ip, self->rtcp.remote_port);
+				((trtp_manager_t*)self)->rtcp.remote_addr = *remote_addr;
+			}
+		}
+
+		if(self->rtcp.session){
+			#if HAVE_SRTP
+			err_status_t status;
+			if(self->srtp_ctx_neg_remote){
+				srtp_t session = self->srtp_ctx_neg_remote->rtcp.initialized ? self->srtp_ctx_neg_remote->rtcp.session : self->srtp_ctx_neg_remote->rtp.session;
+				if((status = srtp_unprotect_rtcp(session, (void*)data_ptr, (int*)&data_size)) != err_status_ok){
+                    if (status == err_status_replay_fail) {
+                        // replay (because of RTCP-NACK nothing to worry about)
+                        TSK_DEBUG_INFO("srtp_unprotect(RTCP) returned 'err_status_replay_fail'");
+                        return 0;
+                    }
+                    else {
+                        TSK_DEBUG_ERROR("srtp_unprotect(RTCP) failed with error code=%d", (int)status);
+                        return -1;
+                    }
+				}
+			}
+			#endif
+			return trtp_rtcp_session_process_rtcp_in(self->rtcp.session, data_ptr, data_size);
+		}
+		TSK_DEBUG_WARN("No RTCP session");
+		return 0;
+	}
+	if(is_rtp){
+		if(!self->is_symetric_rtp_checked && self->is_force_symetric_rtp){
+			((trtp_manager_t*)self)->is_symetric_rtp_checked = tsk_true;
+			if(!self->is_ice_neg_ok && remote_addr){ // do not force symetric RTP is ICE negotiation succeed
+				TSK_DEBUG_INFO("Using symetric RTP for [%s]:%d", self->rtp.remote_ip, self->rtp.remote_port);
+				((trtp_manager_t*)self)->rtp.remote_addr = *remote_addr;
+			}
+		}
+
+		if(self->rtp.cb.fun){
+			trtp_rtp_packet_t* packet_rtp = tsk_null;
+			#if HAVE_SRTP
+			err_status_t status;
+			if(self->srtp_ctx_neg_remote){
+				if((status = srtp_unprotect(self->srtp_ctx_neg_remote->rtp.session, (void*)data_ptr, (int*)&data_size)) != err_status_ok){
+                    if (status == err_status_replay_fail) {
+                        // replay (because of RTCP-NACK nothing to worry about)
+                        TSK_DEBUG_INFO("srtp_unprotect(RTP) returned 'err_status_replay_fail'");
+                        return 0;
+                    }
+                    else {
+                        TSK_DEBUG_ERROR("srtp_unprotect(RTP) failed with error code=%d, seq_num=%u", (int)status,  (data_size > 4 ? tnet_ntohs_2(&data_ptr[2]) : 0x0000));
+                        return -1;
+                    }
+				}
+			}
+			#endif
+			if((packet_rtp = trtp_rtp_packet_deserialize(data_ptr, data_size))){
+				// update remote SSRC based on received RTP packet
+				((trtp_manager_t*)self)->rtp.ssrc.remote = packet_rtp->header->ssrc;
+				// forward to the callback function (most likely "session_av")
+				self->rtp.cb.fun(self->rtp.cb.usrdata, packet_rtp);
+				// forward packet to the RTCP session
+				if(self->rtcp.session){
+					trtp_rtcp_session_process_rtp_in(self->rtcp.session, packet_rtp, data_size);
+				}
+				TSK_OBJECT_SAFE_FREE(packet_rtp);
+				return 0;
+			}
+			else{
+				TSK_DEBUG_ERROR("RTP packet === NOK");
+				return -1;
+			}
+		}
+		return 0;
+	}
+
+	TSK_DEBUG_INFO("Received unknown packet type");
+	return 0;
+}
+
+// Sends DTLS handshaking data record by record to avoid UDP IP fragmentation issues (each record length will be < Length(MTU))
+//!\ This is required even if the local transport is TCP/TLS because the relayed (TURN) transport could be UDP
+static int _trtp_manager_send_turn_dtls(struct tnet_ice_ctx_s* ice_ctx, const void* handshaking_data_ptr, tsk_size_t handshaking_data_size, tsk_bool_t use_rtcp_channel)
+{
+	const uint8_t *record_ptr, *records_ptr = handshaking_data_ptr;
+	tsk_size_t record_size;
+	int records_len = (int)handshaking_data_size, ret = 0;
+	int(*_ice_ctx_send_turn_data)(struct tnet_ice_ctx_s* self, const void* data, tsk_size_t size) = use_rtcp_channel ? tnet_ice_ctx_send_turn_rtcp : tnet_ice_ctx_send_turn_rtp;
+	if (!ice_ctx || !handshaking_data_ptr || !handshaking_data_size) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	while (records_len > 0 && (ret = tnet_dtls_socket_get_record_first(records_ptr, (tsk_size_t)records_len, &record_ptr, &record_size)) == 0) {
+		ret = _ice_ctx_send_turn_data(ice_ctx, record_ptr, record_size);
+		
+		records_len -= (int)record_size;
+		records_ptr += record_size;
+	}
+	return ret;
+}
+
+#if HAVE_SRTP
+/*
+Enables SDES-SRTP and DTLS-SRTP
+Enabling SRTP will allow us to get "crypto" lines for negotiation
+At this stage the sockets are not ready to send DTLS datagrams -> Good for ICE negotiation
+If ICE is enabled DTLS-SRTP will not be enabled as the transport is "null"
+*/
+static int _trtp_manager_srtp_set_enabled(trtp_manager_t* self, tmedia_srtp_type_t srtp_type, struct tnet_socket_s** sockets, tsk_size_t count, tsk_bool_t enabled)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if((self->srtp_mode == tmedia_srtp_mode_optional || self->srtp_mode == tmedia_srtp_mode_mandatory)){
+		int ret;
+		if(enabled){
+			if(srtp_type & tmedia_srtp_type_sdes){
+				trtp_srtp_ctx_init(
+						&self->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_80], 
+						1, 
+						HMAC_SHA1_80,
+						self->rtp.ssrc.local
+					);
+				trtp_srtp_ctx_init(
+						&self->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_32], 
+						2, 
+						HMAC_SHA1_32,
+						self->rtp.ssrc.local
+					);
+			}
+
+			if(srtp_type & tmedia_srtp_type_dtls){
+				/*
+					Enables DTLS on the transport without activating it on the sockets
+					Enabling DTLS will allow us to get the certificate fingerprints for negotiation
+					At this stage the sockets are not ready to send DTLS datagrams -> Good for ICE negotiation
+				*/
+				if(self->transport){
+					if((ret = tnet_transport_dtls_set_enabled(self->transport, enabled, tsk_null, 0))){
+						return ret;
+					}
+					if((ret = trtp_manager_set_dtls_certs(self, self->dtls.file_ca, self->dtls.file_pbk, self->dtls.file_pvk, self->dtls.cert_verif))){
+						return ret;
+					}
+					self->dtls.state = trtp_srtp_state_enabled;
+				}
+				else{
+					self->dtls.enable_postponed = tsk_true;
+				}
+			}
+			self->srtp_state = trtp_srtp_state_enabled;
+		}
+		else {
+			if (srtp_type & tmedia_srtp_type_dtls) {
+				if (self->transport) {
+					ret = tnet_transport_dtls_set_enabled(self->transport, tsk_false, sockets, count);
+				}
+				self->dtls.state = trtp_srtp_state_none;
+				self->dtls.enable_postponed = tsk_false;
+				self->dtls.srtp_connected = self->dtls.srtp_handshake_succeed = tsk_false;
+				self->dtls.srtcp_connected = self->dtls.srtcp_handshake_succeed = tsk_false;
+			}
+
+			// SRTP context is used by both DTLS and SDES -> only destroy them if requested to be disabled on both
+			if((~srtp_type & self->srtp_type) == tmedia_srtp_type_none){
+				trtp_srtp_ctx_deinit(&self->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][0]);
+				trtp_srtp_ctx_deinit(&self->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][1]);
+				self->srtp_ctx_neg_local = tsk_null;
+				self->srtp_ctx_neg_remote = tsk_null;
+				self->srtp_state = trtp_srtp_state_none;
+				// Reset SRTP session to the RTCP session manager
+				if (self->rtcp.session) {
+					trtp_rtcp_session_set_srtp_sess(self->rtcp.session, tsk_null);
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int _trtp_manager_srtp_activate(trtp_manager_t* self, tmedia_srtp_type_t srtp_type)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(srtp_type != tmedia_srtp_type_none && (self->srtp_mode == tmedia_srtp_mode_optional || self->srtp_mode == tmedia_srtp_mode_mandatory)){
+		int ret;
+		if(self->srtp_state < trtp_srtp_state_enabled){
+			TSK_DEBUG_ERROR("SRTP engine not enabled yet");
+			return -2;
+		}
+		if((srtp_type & tmedia_srtp_type_dtls) && (self->dtls.state >= trtp_srtp_state_enabled || self->dtls.enable_postponed)){
+			/*
+				Activates DTLS on the transport and on both RTP and RTCP sockets
+				At this stage the sockets are ready to send/recv DTLS datagrams
+			*/
+			struct tnet_socket_s* sockets[] = { self->transport->master , self->rtcp.local_socket };
+			const struct sockaddr_storage* remote_addrs[] = { &self->rtp.remote_addr, &self->rtcp.remote_addr };
+			tsk_bool_t store_handshakingdata[] = { self->is_ice_turn_active, self->is_ice_turn_active };
+
+			// check if DTLS-SRTP enabling was postponed because the net transport was not ready (could happen if ICE is ON)
+			if(self->dtls.enable_postponed){
+				if ((ret = _trtp_manager_srtp_set_enabled(self, self->srtp_type, sockets, sizeof(sockets) / sizeof(sockets[0]), tsk_true))) {
+					return ret;
+				}
+				self->dtls.enable_postponed = tsk_false;
+			}
+			
+			// activate "use_srtp" (rfc5764 section 4.1) on the transport
+			// this should be done before enabling DTLS sockets to be sure that newly created/enabled ones will use "use_srtp" extension
+			if((ret = tnet_transport_dtls_use_srtp(self->transport, "SRTP_AES128_CM_SHA1_80:SRTP_AES128_CM_SHA1_32", sockets, 2))){
+				return ret;
+			}
+			// enabling DTLS on the sockets will create the "dtlshandle" field and change the type from UDP to DTLS
+			if((ret = tnet_transport_dtls_set_enabled(self->transport, tsk_true, sockets, 2))){
+				return ret;
+			}
+
+			/* At this step the DTLS "dtlshandle" is created and the socket types changed from UDP to DTLS */
+
+			// pass the remote certificate fingerprint to both SRTP and SRTCP sockets
+			// the fingerprint will be verified if this option is enabled on the SSL context
+			// we'll be notified via the callback if there are fingerprint mismatch after the begining of the handshaking
+			if((ret = tnet_transport_dtls_set_remote_fingerprint(self->transport, &self->dtls.remote.fp, self->dtls.remote.fp_hash, sockets, 2))){
+				return ret;
+			}
+			// setting the "setup" allow each DTLS socket to know if it's a client or server
+			// setup="active" means it's up to us to send the "DTLS client hello" message (otherwise "server hello" will be sent)
+			if((ret = tnet_transport_dtls_set_setup(self->transport, self->dtls.local.setup, sockets, 2))){
+				return ret;
+			}
+			// whether to send DTLS handshaking data using the provided sockets or TURN session
+			if ((ret = tnet_transport_dtls_set_store_handshakingdata(self->transport, store_handshakingdata[0], sockets, 2))) {
+				return ret;
+			}
+			// start handshaking process (will do nothing if already completed)
+			if ((ret = tnet_transport_dtls_do_handshake(self->transport, sockets, 2, remote_addrs, 2))) {
+				return ret;
+			}
+			if (store_handshakingdata[0]) {
+				// means TURN is active and handshaking data must be sent using the channel
+				const void* data[] = { tsk_null, tsk_null };
+				tsk_size_t size[] = { 0, 0 };
+				if ((ret = tnet_transport_dtls_get_handshakingdata(self->transport, (const struct tnet_socket_s**)sockets, 2, data, size))) {
+					return ret;
+				}
+				if (data[0] && size[0]) {
+					ret = tnet_ice_ctx_send_turn_rtp(self->ice_ctx, data[0], size[0]);
+				}
+				if (data[1] && size[1]) {
+					ret = tnet_ice_ctx_send_turn_rtcp(self->ice_ctx, data[1], size[1]);
+				}
+			}
+
+			self->dtls.state = trtp_srtp_state_activated;
+		}
+
+		self->srtp_state = trtp_srtp_state_activated;
+
+		// SDES-SRTP could be started right now while DTLS requires the handshaking to terminate
+		if (srtp_type & tmedia_srtp_type_sdes) {
+			return _trtp_manager_srtp_start(self, self->srtp_type);
+		}
+	}
+	return 0;
+}
+
+static int _trtp_manager_srtp_start(trtp_manager_t* self, tmedia_srtp_type_t srtp_type)
+{
+	const trtp_srtp_ctx_xt *ctx_remote, *ctx_local;
+	tsk_bool_t use_different_keys;
+
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	if(self->srtp_state < trtp_srtp_state_activated){
+		TSK_DEBUG_ERROR("SRTP engine not activated yet");
+		return -2;
+	}
+	
+	ctx_remote = self->srtp_contexts[TRTP_SRTP_LINE_IDX_REMOTE][HMAC_SHA1_80].rtp.initialized
+		? &self->srtp_contexts[TRTP_SRTP_LINE_IDX_REMOTE][HMAC_SHA1_80]
+		: &self->srtp_contexts[TRTP_SRTP_LINE_IDX_REMOTE][HMAC_SHA1_32];
+
+	// dtls uses different keys for rtp and srtp which is not the case for sdes
+	use_different_keys = !_trtp_manager_is_rtcpmux_active(self) && ((srtp_type & tmedia_srtp_type_dtls) == tmedia_srtp_type_dtls);
+	TSK_DEBUG_INFO("srtp_use_different_keys=%s", use_different_keys ? "true" : "false");
+
+	if(!ctx_remote->rtp.initialized || (use_different_keys && !ctx_remote->rtcp.initialized)){
+		TSK_DEBUG_ERROR("SRTP remote context not initialized: Not expected at this state");
+		return -2;
+	}
+
+	// use same crypto type on both sides
+	ctx_local = &self->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][(int32_t)ctx_remote->rtp.crypto_type];
+	if(!ctx_local->rtp.initialized || (use_different_keys && !ctx_local->rtcp.initialized)){
+		TSK_DEBUG_ERROR("SRTP local context not initialized: Not expected at this state");
+		return -2;
+	}
+	
+	// update negotiated crypto contexts used to encrypt()/decrypt() SRTP data
+	self->srtp_ctx_neg_remote = ctx_remote;
+	self->srtp_ctx_neg_local = ctx_local;
+
+	self->srtp_state = trtp_srtp_state_started;
+	if(self->dtls.state >= trtp_srtp_state_activated){
+		// this means the DTLS-SRTP is the active type intead of SDES
+		self->dtls.state = trtp_srtp_state_started;
+	}
+
+	// Pass SRTP session to the RTCP session manager
+	trtp_rtcp_session_set_srtp_sess(
+			self->rtcp.session, 
+			self->srtp_ctx_neg_local ? (use_different_keys ? &self->srtp_ctx_neg_local->rtcp.session : &self->srtp_ctx_neg_local->rtp.session) : tsk_null
+		);
+
+	/* At this step we are able to encrypt()/decrypt() SRTP data */	
+
+	return 0;
+}
+
+#endif /* HAVE_SRTP */
+
+static int _trtp_manager_ice_init(trtp_manager_t* self)
+{
+	int ret = 0;
+	const tnet_ice_candidate_t *candidate_offer, *candidate_answer_src, *candidate_answer_dest;
+	struct tnet_socket_s *rtp_socket = tsk_null;
+
+	if (!self || !self->ice_ctx) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	if (!self->transport) {
+		// get rtp nominated symetric candidates
+		ret = tnet_ice_ctx_get_nominated_symetric_candidates(self->ice_ctx, TNET_ICE_CANDIDATE_COMPID_RTP,
+			&candidate_offer, &candidate_answer_src, &candidate_answer_dest);
+		self->is_ice_neg_ok = (ret == 0 && candidate_offer && candidate_answer_src && candidate_answer_dest);
+		self->is_ice_turn_active = self->is_ice_neg_ok && tnet_ice_ctx_is_turn_rtp_active(self->ice_ctx);
+		if (!self->is_ice_neg_ok) {
+			// If this code is called this means that ICE negotiation has failed
+			// This is not really an error because it could happen if the remote peer is not an ICE agent or is an ICE-lite
+			// in this case, use the first offered candidate which is the best one and already used in the "c=" line
+			if (!(candidate_offer = tnet_ice_ctx_get_local_candidate_first(self->ice_ctx))) {
+				// Must never happen as we always have at least one local "host" candidate
+				TSK_DEBUG_ERROR("ICE context not ready");
+				ret = -3;
+				goto bail;
+			}
+		}
+		
+		// Get RTP socket
+		if (self->is_ice_turn_active && candidate_offer->turn.ss) {
+			if ((ret = tnet_turn_session_get_socket_local(candidate_offer->turn.ss, &rtp_socket))) {
+				goto bail;
+			}
+		}
+		else {
+			rtp_socket = tsk_object_ref(candidate_offer->socket);
+		}
+
+		// create transport
+		if (!(self->transport = tnet_transport_create_2(rtp_socket, TRTP_TRANSPORT_NAME))) {
+			TSK_DEBUG_ERROR("Failed to create transport(%s:%u)", rtp_socket->ip, rtp_socket->port);
+			ret = -4;
+			goto bail;
+		}
+		// set rtp local and remote IPs and ports
+		if (candidate_answer_dest) { // could be "null" if remote peer is ICE-lite
+			tsk_strupdate(&self->rtp.remote_ip, candidate_answer_dest->connection_addr);
+			self->rtp.remote_port = candidate_answer_dest->port;
+			tsk_strupdate(&self->rtp.public_ip, candidate_offer->connection_addr);
+			self->rtp.public_port = candidate_offer->port;
+		}
+
+		// get rtp nominated symetric candidates
+		if (self->use_rtcp) {
+			ret = tnet_ice_ctx_get_nominated_symetric_candidates(self->ice_ctx, TNET_ICE_CANDIDATE_COMPID_RTCP,
+				&candidate_offer, &candidate_answer_src, &candidate_answer_dest);
+			if (ret == 0 && candidate_offer && candidate_answer_src && candidate_answer_dest) {
+				// set rtp local and remote IPs and ports
+				tsk_strupdate(&self->rtcp.remote_ip, candidate_answer_dest->connection_addr);
+				self->rtcp.remote_port = candidate_answer_dest->port;
+				tsk_strupdate(&self->rtcp.public_ip, candidate_offer->connection_addr);
+				self->rtcp.public_port = candidate_offer->port;
+				TSK_OBJECT_SAFE_FREE(self->rtcp.local_socket);
+				// Get RTCP socket
+				if (self->is_ice_turn_active && candidate_offer->turn.ss) {
+					ret = tnet_turn_session_get_socket_local(candidate_offer->turn.ss, &self->rtcp.local_socket);
+					if (ret) {
+						goto bail;
+					}
+				}
+				else {
+					self->rtcp.local_socket = tsk_object_ref(candidate_offer->socket);
+				}
+			}
+		}
+	}
+
+	// set callback functions
+	ret = tnet_transport_set_callback(self->transport, _trtp_transport_layer_cb, self); // NetTransport -> RtpManager
+	ret = tnet_ice_ctx_rtp_callback(self->ice_ctx, (tnet_ice_rtp_callback_f)_trtp_manager_recv_data, self); // ICE -> RtpManager
+
+bail:
+	TSK_OBJECT_SAFE_FREE(rtp_socket);
+	return ret;
+}
+
+
+/** Create RTP/RTCP manager */
+trtp_manager_t* trtp_manager_create(tsk_bool_t use_rtcp, const char* local_ip, tsk_bool_t ipv6, tmedia_srtp_type_t srtp_type, tmedia_srtp_mode_t srtp_mode)
+{
+	trtp_manager_t* manager;
+	if((manager = _trtp_manager_create(use_rtcp, local_ip, ipv6, srtp_type, srtp_mode))){
+	}
+	return manager;
+}
+
+/** Create RTP/RTCP manager */
+trtp_manager_t* trtp_manager_create_2(struct tnet_ice_ctx_s* ice_ctx, tmedia_srtp_type_t srtp_type, tmedia_srtp_mode_t srtp_mode)
+{
+	trtp_manager_t* manager;
+	const char* local_ip;
+	tsk_bool_t use_ipv6, use_rtcp;
+
+	if(!ice_ctx){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+
+	local_ip = (use_ipv6 = tnet_ice_ctx_use_ipv6(ice_ctx)) ? "::1" : "127.0.0.1";
+	use_rtcp = tnet_ice_ctx_use_rtcp(ice_ctx);
+
+	if((manager = _trtp_manager_create(use_rtcp, local_ip, use_ipv6, srtp_type, srtp_mode))){
+		manager->ice_ctx = tsk_object_ref(ice_ctx);
+	}
+	return manager;
+}
+
+int trtp_manager_set_ice_ctx(trtp_manager_t* self, struct tnet_ice_ctx_s* ice_ctx)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid ICE context");
+		return -1;
+	}
+	TSK_OBJECT_SAFE_FREE(self->ice_ctx);
+	self->ice_ctx = tsk_object_ref(ice_ctx);
+	return 0;
+}
+
+/** Prepares the RTP/RTCP manager */
+int trtp_manager_prepare(trtp_manager_t* self)
+{
+	const char *rtp_local_ip = tsk_null, *rtcp_local_ip = tsk_null;
+	tnet_port_t rtp_local_port = 0, rtcp_local_port = 0;
+
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(self->transport){
+		TSK_DEBUG_ERROR("RTP/RTCP manager already prepared");
+		return -2;
+	}
+
+	if(self->ice_ctx){
+		TSK_DEBUG_INFO("ICE enabled on RTP manager");
+		// Get Sockets when the transport is started
+		rtp_local_ip = rtcp_local_ip = self->use_ipv6 ? "::1" : "127.0.0.1";
+		rtp_local_port = 2; // ICE default rtp port, do not use zero which is reserved to disabled medias
+		rtcp_local_port = 1; // ICE default rtcp port, do not use zero which is reserved to disabled medias
+	}
+	else{
+		#define __retry_count_max 5
+		#define __retry_count_max_minus1 (__retry_count_max - 1)
+		uint8_t retry_count = __retry_count_max;
+		tnet_socket_type_t socket_type = self->use_ipv6 ? tnet_socket_type_udp_ipv6 : tnet_socket_type_udp_ipv4;
+
+		/* Creates local rtp and rtcp sockets */
+		while(retry_count--){
+			/* random number in the range 1024 to 65535 */
+			static int counter = 0;
+#if 0
+			tnet_port_t local_port = 6060;
+#else
+			// first check => try to use port from latest active session if exist
+			tnet_port_t local_port = (retry_count == __retry_count_max_minus1 && (self->port_range.start <= self->rtp.public_port && self->rtp.public_port <= self->port_range.stop))
+				? self->rtp.public_port
+				: (((rand() ^ ++counter) % (self->port_range.stop - self->port_range.start)) + self->port_range.start);
+#endif
+			local_port = (local_port & 0xFFFE); /* turn to even number */
+
+			/* beacuse failure will cause errors in the log, print a message to alert that there is
+			* nothing to worry about */
+			TSK_DEBUG_INFO("RTP/RTCP manager[Begin]: Trying to bind to random ports");
+
+			/* RTP */
+			if(!(self->transport = tnet_transport_create(self->local_ip, local_port, socket_type, TRTP_TRANSPORT_NAME))){
+				TSK_DEBUG_ERROR("Failed to create RTP/RTCP Transport");
+				return -3;
+			}
+
+			/* RTCP */
+			if (self->use_rtcp) {
+				if(!(self->rtcp.local_socket = tnet_socket_create(self->local_ip, local_port+1, socket_type))){
+					TSK_DEBUG_WARN("Failed to bind to %d", local_port+1);
+					TSK_OBJECT_SAFE_FREE(self->transport);
+					continue;
+				}
+			}
+
+			TSK_DEBUG_INFO("RTP/RTCP manager[End]: Trying to bind to random ports");
+			break;
+		}// end-of-while(retry_count)
+
+		rtp_local_ip = self->transport->master->ip;
+		rtp_local_port = self->transport->master->port;
+		if(self->rtcp.local_socket){
+			rtcp_local_ip = self->rtcp.local_socket->ip;
+			rtcp_local_port = self->rtcp.local_socket->port;
+
+		}
+	}// end-of-else(!ice)
+
+	tsk_strupdate(&self->rtp.public_ip, rtp_local_ip);
+	self->rtp.public_port = rtp_local_port;
+
+	tsk_strupdate(&self->rtcp.public_ip, rtcp_local_ip);
+	self->rtcp.public_port = rtcp_local_port;
+
+	if(self->transport){
+		/* set callback function */
+		tnet_transport_set_callback(self->transport, _trtp_transport_layer_cb, self);
+		/* Disable receiving until we start the transport (To avoid buffering) */
+#if TRTP_DISABLE_SOCKETS_BEFORE_START
+		if(!self->socket_disabled){
+			int err, optval = TRTP_TINY_RCVBUF;
+			if((err = setsockopt(self->transport->master->fd, SOL_SOCKET, SO_RCVBUF, (char*)&optval, sizeof(optval)))){
+				TNET_PRINT_LAST_ERROR("setsockopt(SOL_SOCKET, SO_RCVBUF) has failed with error code %d", err);
+			}
+			self->socket_disabled = (err == 0);
+		}
+#endif
+	}
+
+	/* SRTP */
+#if HAVE_SRTP
+	{		
+		// enable SRTP to allow negotiation
+		if (self->srtp_type != tmedia_srtp_mode_none) {
+			struct tnet_socket_s* sockets[] = { self->transport ? self->transport->master : tsk_null, self->rtcp.local_socket };
+			_trtp_manager_srtp_set_enabled(self, self->srtp_type, sockets, sizeof(sockets)/sizeof(sockets[0]), tsk_true);
+		}
+	}
+#endif
+
+	return 0;
+}
+
+#if HAVE_SRTP
+
+int trtp_manager_set_dtls_certs(trtp_manager_t* self, const char* ca, const char* pbk, const char* pvk, tsk_bool_t verify)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	// always save certificates even if not DTLS-SRTP transport
+	tsk_strupdate(&self->dtls.file_ca, ca);
+	tsk_strupdate(&self->dtls.file_pbk, pbk);
+	tsk_strupdate(&self->dtls.file_pvk, pvk);
+	self->dtls.cert_verif = verify;
+
+	if((self->srtp_type & tmedia_srtp_type_dtls) && (self->srtp_mode == tmedia_srtp_mode_optional || self->srtp_mode == tmedia_srtp_mode_mandatory)){
+		if(self->transport && tnet_transport_dtls_is_enabled(self->transport)){
+			return tnet_transport_dtls_srtp_set_certs(self->transport, self->dtls.file_ca, self->dtls.file_pbk, self->dtls.file_pvk, self->dtls.cert_verif);
+		}
+	}
+	else{
+		TSK_DEBUG_ERROR("DTLS certificates setting ignored for non-DTLS-SRTP transport");
+		return -2;
+	}
+
+	return 0;
+}
+
+int trtp_manager_set_dtls_callback(trtp_manager_t* self, const void* usrdata, trtp_srtp_dtls_cb_f fun)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	self->dtls.cb.usrdata = usrdata;
+	self->dtls.cb.fun = fun;
+
+	return 0;
+}
+
+int trtp_manager_set_dtls_remote_fingerprint(trtp_manager_t* self, const tnet_fingerprint_t* fp, const char* fp_hash)
+{
+	tnet_dtls_hash_type_t hash;
+	if(!self || !fp || !fp_hash){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	hash = tnet_dtls_get_hash_from_string(fp_hash);
+	if(hash != tnet_dtls_hash_type_sha1 && hash != tnet_dtls_hash_type_sha256){
+		TSK_DEBUG_ERROR("%s not supported as fingerprint hash", fp_hash);
+		return -2;
+	}
+	self->dtls.remote.fp_hash = hash;
+	memcpy(self->dtls.remote.fp, &(*fp)[0], sizeof(tnet_fingerprint_t));
+	return 0;
+}
+
+enum tnet_dtls_hash_type_e trtp_manager_get_dtls_remote_fingerprint_hash(trtp_manager_t* self)
+{
+	return (self ? self->dtls.remote.fp_hash : tnet_dtls_hash_type_none);
+}
+
+int trtp_manager_set_dtls_local_setup(trtp_manager_t* self, tnet_dtls_setup_t setup, tsk_bool_t connection_new)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	self->dtls.local.setup = setup;
+	self->dtls.local.connection_new = connection_new;
+	return 0;
+}
+
+const char* trtp_manager_get_dtls_local_fingerprint(trtp_manager_t* self, enum tnet_dtls_hash_type_e hash)
+{
+	if(!self || (int32_t)hash < 0 || (int32_t)hash >= TNET_DTLS_HASH_TYPE_MAX){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_null;
+	}
+	if(!self->transport && self->dtls.file_pbk){
+		static tnet_fingerprint_t fingerprint[TNET_DTLS_HASH_TYPE_MAX];
+		if(tnet_dtls_get_fingerprint(self->dtls.file_pbk, &fingerprint[hash], hash) == 0){
+			return (const char*)fingerprint[hash];
+		}
+	}
+	return tnet_transport_dtls_get_local_fingerprint(self->transport, hash);
+}
+
+tsk_bool_t trtp_manager_is_dtls_enabled(trtp_manager_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_false;
+	}
+	return (self->dtls.state >= trtp_srtp_state_enabled);
+}
+
+tsk_bool_t trtp_manager_is_dtls_activated(trtp_manager_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_false;
+	}
+	return (self->dtls.state >= trtp_srtp_state_activated);
+}
+
+tsk_bool_t trtp_manager_is_dtls_started(trtp_manager_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_false;
+	}
+	return (self->dtls.state >= trtp_srtp_state_started);
+}
+
+tsk_bool_t trtp_manager_is_srtp_activated(trtp_manager_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_false;
+	}
+	return (self->srtp_state >= trtp_srtp_state_activated);
+}
+
+tsk_bool_t trtp_manager_is_srtp_started(trtp_manager_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_false;
+	}
+	return (self->srtp_state >= trtp_srtp_state_started);
+}
+
+/** Sets SRTP type used by the remote party */
+int trtp_manager_set_srtp_type_remote(trtp_manager_t* self, tmedia_srtp_type_t srtp_type_remote)
+{
+	tsk_size_t i;
+	int ret;
+
+	if (!self) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	for(i = 0; i < sizeof(__srtp_types)/sizeof(__srtp_types[i]); ++i) {
+		if ((self->srtp_type & __srtp_types[i]) && !(srtp_type_remote & __srtp_types[i])) {
+			struct tnet_socket_s* sockets[] = { self->transport ? self->transport->master : tsk_null, self->rtcp.local_socket };
+			if ((ret = _trtp_manager_srtp_set_enabled(self, __srtp_types[i], sockets, sizeof(sockets) / sizeof(sockets[0]), tsk_false))) {
+				return ret;
+			}
+			self->srtp_type &= ~__srtp_types[i];
+		}
+	}
+	return 0;
+}
+
+int trtp_manager_set_srtp_type_local(trtp_manager_t* self, enum tmedia_srtp_type_e srtp_type, enum tmedia_srtp_mode_e srtp_mode)
+{
+	if (!self) {
+		TSK_DEBUG_ERROR("Invalid ICE context");
+		return -1;
+	}
+	if (srtp_mode == tmedia_srtp_mode_none || srtp_type == tmedia_srtp_type_none) {
+		struct tnet_socket_s* sockets[] = { self->transport ? self->transport->master : tsk_null, self->rtcp.local_socket };
+		_trtp_manager_srtp_set_enabled(self, self->srtp_type, sockets, sizeof(sockets) / sizeof(sockets[0]), tsk_false);
+		self->srtp_type = srtp_type;
+		self->srtp_mode = srtp_mode;
+		return 0;
+	}
+
+	self->srtp_mode = srtp_mode;
+	return trtp_manager_set_srtp_type_remote(self, srtp_type);
+}
+
+#endif /* HAVE_SRTP */
+
+/** Indicates whether the manager is already ready or not */
+tsk_bool_t trtp_manager_is_ready(trtp_manager_t* self)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return tsk_false;
+	}
+	return (self->transport != tsk_null);
+}
+
+/** Sets NAT Traversal context */
+int trtp_manager_set_natt_ctx(trtp_manager_t* self, struct tnet_nat_ctx_s* natt_ctx)
+{
+	int ret;
+
+	if(!self || !self->transport || !natt_ctx){
+		if(self && self->ice_ctx){
+			return 0; // Nat context is not needed when ICE is enabled
+		}
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(!(ret = tnet_transport_set_natt_ctx(self->transport, natt_ctx))){
+		tnet_ip_t public_ip = {0};
+		tnet_port_t public_port = 0;
+		// get RTP public IP and Port
+		if(!tnet_transport_get_public_ip_n_port(self->transport, self->transport->master->fd, &public_ip, &public_port)){
+			tsk_strupdate(&self->rtp.public_ip, public_ip);
+			self->rtp.public_port = public_port;
+		}
+		// get RTCP public IP and Port
+		memset(public_ip, 0, sizeof(public_ip));
+		public_port = 0;
+		if(self->rtcp.local_socket && !tnet_transport_get_public_ip_n_port(self->transport, self->rtcp.local_socket->fd, &public_ip, &public_port)){
+			tsk_strupdate(&self->rtcp.public_ip, public_ip);
+			self->rtcp.public_port = public_port;
+		}
+		// re-enable sockets to be able to receive STUN packets
+#if 0
+		_trtp_manager_enable_sockets(self);
+#endif
+	}
+	return ret;
+}
+
+/** Sets RTP callback */
+int trtp_manager_set_rtp_callback(trtp_manager_t* self, trtp_rtp_cb_f fun, const void* usrdata)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	self->rtp.cb.fun = fun;
+	self->rtp.cb.usrdata = usrdata;
+
+	return 0;
+}
+
+/** Sets RTCP callback */
+int trtp_manager_set_rtcp_callback(trtp_manager_t* self, trtp_rtcp_cb_f fun, const void* usrdata)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	self->rtcp.cb.fun = fun;
+	self->rtcp.cb.usrdata = usrdata;
+	if(self->rtcp.session){
+		return trtp_rtcp_session_set_callback(self->rtcp.session, fun, usrdata);
+	}
+
+	return 0;
+}
+
+/** Sets the payload type */
+int trtp_manager_set_payload_type(trtp_manager_t* self, uint8_t payload_type)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	self->rtp.payload_type = payload_type;
+	return 0;
+}
+
+int trtp_manager_set_rtp_dscp(trtp_manager_t* self, int32_t dscp)
+{
+    if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	self->rtp.dscp = dscp;
+	return 0;
+}
+
+/** Sets remote parameters for rtp session */
+int trtp_manager_set_rtp_remote(trtp_manager_t* self, const char* remote_ip, tnet_port_t remote_port)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	// if ICE is enabled then, these values will be updated when the manager start()s and call ice_init()
+	tsk_strupdate(&self->rtp.remote_ip, remote_ip);
+	self->rtp.remote_port = remote_port;
+	return 0;
+}
+
+/** Sets remote parameters for rtcp session */
+int trtp_manager_set_rtcp_remote(trtp_manager_t* self, const char* remote_ip, tnet_port_t remote_port)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if(self->ice_ctx){
+		TSK_DEBUG_WARN("Manually setting RTCP remote IP and Port while ICE is enabled");
+	}
+	tsk_strupdate(&self->rtcp.remote_ip, remote_ip);
+	self->rtcp.remote_port = remote_port;
+	return 0;
+}
+
+int trtp_manager_set_port_range(trtp_manager_t* self, uint16_t start, uint16_t stop)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	self->port_range.start = start;
+	self->port_range.stop = stop;
+	return 0;
+}
+
+int trtp_manager_set_rtcweb_type_remote(trtp_manager_t* self, tmedia_rtcweb_type_t rtcweb_type)
+{
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	self->rtcweb_type.remote = rtcweb_type;
+	return 0;
+}
+
+int trtp_manager_set_proxy_auto_detect(trtp_manager_t* self, tsk_bool_t auto_detect)
+{
+    if (!self){
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    self->proxy.auto_detect = auto_detect;
+    return 0;
+}
+
+int trtp_manager_set_proxy_info(trtp_manager_t* self, enum tnet_proxy_type_e type, const char* host, tnet_port_t port, const char* login, const char* password)
+{
+    if (!self){
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (!self->proxy.info && !(self->proxy.info = tnet_proxyinfo_create())) {
+        return -2;
+    }
+    self->proxy.info->type = type;
+    self->proxy.info->port = port;
+    tsk_strupdate(&self->proxy.info->hostname, host);
+    tsk_strupdate(&self->proxy.info->username, login);
+    tsk_strupdate(&self->proxy.info->password, password);
+    return 0;
+}
+
+/** Starts the RTP/RTCP manager */
+int trtp_manager_start(trtp_manager_t* self)
+{
+	int ret = 0;
+	int rcv_buf = (int)tmedia_defaults_get_rtpbuff_size();
+	int snd_buf = (int)tmedia_defaults_get_rtpbuff_size();
+#if !TRTP_UNDER_WINDOWS_CE
+    int32_t dscp_rtp;
+#endif
+
+	if(!self){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	tsk_safeobj_lock(self);
+
+	if (self->is_started) {
+		goto bail;
+	}
+
+	// Initialize transport with ICE context
+	if (self->ice_ctx && (ret = _trtp_manager_ice_init(self)) != 0) {
+		TSK_DEBUG_ERROR("_trtp_manager_ice_init() failed");
+		goto bail;
+	}
+
+	if(!self->transport && (ret = trtp_manager_prepare(self))){
+		TSK_DEBUG_ERROR("Failed to prepare RTP/RTCP mamanger");
+		goto bail;
+	}
+
+	if(!self->transport || !self->transport->master){
+		TSK_DEBUG_ERROR("RTP/RTCP manager not prepared");
+		ret = -2;
+		goto bail;
+	}
+    
+    /* Proxy */
+    // Proxy info
+    if ((ret = tnet_transport_set_proxy_auto_detect(self->transport, self->proxy.auto_detect))) {
+        TSK_DEBUG_ERROR("Failed to set proxy autodetect option");
+        goto bail;
+    }
+    if (self->proxy.info) {
+        if ((ret = tnet_transport_set_proxy_info(self->transport, self->proxy.info->type, self->proxy.info->hostname, self->proxy.info->port, self->proxy.info->username, self->proxy.info->password))) {
+            TSK_DEBUG_ERROR("Failed to set proxy info");
+            goto bail;
+        }
+    }
+
+	/* Flush buffers and re-enable sockets */
+	if(self->transport->master && self->is_socket_disabled){
+		static char buff[1024];
+		tsk_size_t guard_count = 0;
+#if 0
+		// re-enable sockets
+		_trtp_manager_enable_sockets(self);
+#endif
+
+		TSK_DEBUG_INFO("Start flushing RTP socket...");
+		// Buffer should be empty ...but who know?
+		// rcv() should never block() as we are always using non-blocking sockets
+		while ((ret = (int)recv(self->transport->master->fd, buff, sizeof(buff), 0)) > 0 && ++guard_count < 0xF0){
+			TSK_DEBUG_INFO("Flushing RTP Buffer %d", ret);
+		}
+		TSK_DEBUG_INFO("End flushing RTP socket");
+	}
+
+	/* enlarge socket buffer */
+#if !TRTP_UNDER_WINDOWS_CE
+	TSK_DEBUG_INFO("SO_RCVBUF = %d, SO_SNDBUF = %d", rcv_buf, snd_buf);
+	if ((ret = setsockopt(self->transport->master->fd, SOL_SOCKET, SO_RCVBUF, (char*)&rcv_buf, sizeof(rcv_buf)))) {
+		TNET_PRINT_LAST_ERROR("setsockopt(SOL_SOCKET, SO_RCVBUF, %d) has failed with error code %d", rcv_buf, ret);
+	}
+	if ((ret = setsockopt(self->transport->master->fd, SOL_SOCKET, SO_SNDBUF, (char*)&snd_buf, sizeof(snd_buf)))) {
+		TNET_PRINT_LAST_ERROR("setsockopt(SOL_SOCKET, SO_SNDBUF, %d) has failed with error code %d", snd_buf, ret);
+	}
+	dscp_rtp = (self->rtp.dscp << 2);
+	if ((ret = setsockopt(self->transport->master->fd, IPPROTO_IP, IP_TOS, (char*)&dscp_rtp, sizeof(dscp_rtp)))) {
+		TNET_PRINT_LAST_ERROR("setsockopt(IPPROTO_IP, IP_TOS) has failed with error code %d", ret);
+	}
+#endif /* !TRTP_UNDER_WINDOWS_CE */
+
+	/* RTP */
+
+	// check remote IP address validity
+	if((tsk_striequals(self->rtp.remote_ip, "0.0.0.0") || tsk_striequals(self->rtp.remote_ip, "::"))) { // most likely loopback testing
+		tnet_ip_t source = {0};
+		tsk_bool_t updated = tsk_false;
+		if(self->transport && self->transport->master){
+			updated = (tnet_getbestsource(self->transport->master->ip, self->transport->master->port, self->transport->master->type, &source) == 0);
+		}
+		// Not allowed to send data to "0.0.0.0"
+		TSK_DEBUG_INFO("RTP remote IP contains not allowed value ...changing to '%s'", updated ? source : "oops");
+		if(updated){
+			tsk_strupdate(&self->rtp.remote_ip, source);
+		}
+	}
+	if((ret = tnet_sockaddr_init(self->rtp.remote_ip, self->rtp.remote_port, self->transport->master->type, &self->rtp.remote_addr))){
+		tnet_transport_shutdown(self->transport);
+		TSK_OBJECT_SAFE_FREE(self->transport);
+		TSK_DEBUG_ERROR("Invalid RTP host:port [%s:%u]", self->rtp.remote_ip, self->rtp.remote_port);
+		goto bail;
+	}
+	TSK_DEBUG_INFO("rtp.remote_ip=%s, rtp.remote_port=%d, rtp.local_fd=%d", self->rtp.remote_ip, self->rtp.remote_port, self->transport->master->fd);
+
+	/* RTCP */
+	if(self->use_rtcp){
+		tnet_fd_t local_rtcp_fd = self->rtcp.local_socket ? self->rtcp.local_socket->fd : -1;
+		if(local_rtcp_fd < 0 || self->use_rtcpmux){ // use RTP local port to send RTCP packets
+			local_rtcp_fd = self->transport->master->fd;
+		}
+		
+		if(!self->rtcp.remote_ip){
+			self->rtcp.remote_ip = tsk_strdup(self->rtcp.remote_ip ? self->rtcp.remote_ip : self->rtp.remote_ip);
+		}
+		if(!self->rtcp.remote_port){
+			self->rtcp.remote_port = self->rtcp.remote_port ? self->rtcp.remote_port : (self->use_rtcpmux ? self->rtp.remote_port : (self->rtp.remote_port + 1));
+		}
+
+		TSK_DEBUG_INFO("rtcp.remote_ip=%s, rtcp.remote_port=%d, rtcp.local_fd=%d", self->rtcp.remote_ip, self->rtcp.remote_port, local_rtcp_fd);
+		if((ret = tnet_sockaddr_init(self->rtcp.remote_ip, self->rtcp.remote_port, self->transport->master->type, &self->rtcp.remote_addr))){
+			TSK_DEBUG_ERROR("Invalid RTCP host:port [%s:%u]", self->rtcp.remote_ip, self->rtcp.remote_port);
+			/* do not exit */
+		}
+
+		/* add RTCP socket to the transport */
+		if(self->rtcp.local_socket){
+			TSK_DEBUG_INFO("rtcp.local_ip=%s, rtcp.local_port=%d, rtcp.local_fd=%d", self->rtcp.local_socket->ip, self->rtcp.local_socket->port, self->rtcp.local_socket->fd);
+			if(ret == 0 && (ret = tnet_transport_add_socket(self->transport, self->rtcp.local_socket->fd, self->rtcp.local_socket->type, tsk_false/* do not take ownership */, tsk_true/* only Meaningful for tls*/, tsk_null))){
+				TSK_DEBUG_ERROR("Failed to add RTCP socket");
+				/* do not exit */
+			}
+		}
+		/* create and start RTCP session */
+		if(!self->rtcp.session && ret == 0){
+			self->rtcp.session = trtp_rtcp_session_create_2(self->ice_ctx, self->rtp.ssrc.local, self->rtcp.cname);
+		}
+		if(self->rtcp.session){
+			ret = trtp_rtcp_session_set_callback(self->rtcp.session, self->rtcp.cb.fun, self->rtcp.cb.usrdata);
+			ret = trtp_rtcp_session_set_app_bandwidth_max(self->rtcp.session, self->app_bw_max_upload, self->app_bw_max_download);
+            ret = trtp_rtcp_session_set_net_transport(self->rtcp.session, self->transport);
+			if((ret = trtp_rtcp_session_start(self->rtcp.session, local_rtcp_fd, (const struct sockaddr *)&self->rtcp.remote_addr))){
+				TSK_DEBUG_ERROR("Failed to start RTCP session");
+				goto bail;
+			}
+		}
+	}
+
+	/*SRTP*/
+#if HAVE_SRTP
+	{
+		// activate SRTP (nothing will be done is srtp_mode is # "optional/mandatory")
+		// will also start the manager if we're using SDES mode
+		if((ret = _trtp_manager_srtp_activate(self, self->srtp_type))){
+			goto bail;
+		}
+
+		/* DTLS handshaking Timer */
+		if (self->timer_mgr_global && self->srtp_state == trtp_srtp_state_activated && (self->srtp_type & tmedia_srtp_type_dtls) == tmedia_srtp_type_dtls) {
+			ret = tsk_timer_manager_start(self->timer_mgr_global);
+			self->dtls.timer_hanshaking.timeout = TRTP_DTLS_HANDSHAKING_TIMEOUT;
+			// start handshaking timer
+			// never mind if net work transport not started yet: the DTLS sockets will send the handshaking data by themself
+			self->dtls.timer_hanshaking.id = tsk_timer_manager_schedule(self->timer_mgr_global, self->dtls.timer_hanshaking.timeout, _trtp_transport_dtls_handshaking_timer_cb, self);
+		}
+	}
+#endif /* HAVE_SRTP */
+
+
+	/* start the transport if TURN is not active (otherwise TURN data will be received directly on RTP manager with channel headers) */
+	if (!self->is_ice_turn_active && (ret = tnet_transport_start(self->transport))) {
+		TSK_DEBUG_ERROR("Failed to start the RTP/RTCP transport");
+		goto bail;
+	}
+
+	self->is_started = tsk_true;
+
+bail:
+
+	tsk_safeobj_unlock(self);
+
+	return ret;
+}
+
+/* Encapsulate raw data into RTP packet and send it over the network 
+* Very IMPORTANT: For voice packets, the marker bits indicates the beginning of a talkspurt */
+tsk_size_t trtp_manager_send_rtp(trtp_manager_t* self, const void* data, tsk_size_t size, uint32_t duration, tsk_bool_t marker, tsk_bool_t last_packet)
+{
+	trtp_rtp_packet_t* packet;
+	tsk_size_t ret;
+
+	if(!self || !self->transport || !data || !size){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	
+	/* check if transport is started */
+	if(!self->is_started || !self->transport->master){
+		TSK_DEBUG_WARN("RTP engine not ready yet");
+		return 0;
+	}
+#if HAVE_SRTP
+	/* check that SRTP engine is ready or disabled */
+	if(self->srtp_state != trtp_srtp_state_none && self->srtp_state != trtp_srtp_state_started){
+		TSK_DEBUG_WARN("SRTP engine not ready yet");
+		return 0;
+	}
+#endif
+	/* create packet with header */
+	if(!(packet = trtp_rtp_packet_create(self->rtp.ssrc.local, ++self->rtp.seq_num, self->rtp.timestamp, self->rtp.payload_type, marker))){
+		return 0;
+	}
+	if(last_packet){
+		self->rtp.timestamp += duration;
+	}
+
+	/* set data */
+#if 0
+	if((packet->payload.data = tsk_calloc(size, sizeof(uint8_t)))){
+		memcpy(packet->payload.data, data, size);
+		packet->payload.size = size;
+	}
+#else
+	packet->payload.data_const = data;
+	packet->payload.size = size;
+#endif
+
+	ret = trtp_manager_send_rtp_packet(self, packet, tsk_false);
+	TSK_OBJECT_SAFE_FREE(packet);
+	return ret;
+}
+
+// serialize, encrypt then send the data
+tsk_size_t trtp_manager_send_rtp_packet(trtp_manager_t* self, const struct trtp_rtp_packet_s* packet, tsk_bool_t bypass_encrypt)
+{
+	int ret = 0;
+	tsk_size_t rtp_buff_pad_count = 0;
+	tsk_size_t xsize;
+
+	/* check validity */
+	if(!self || !packet){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+
+	tsk_safeobj_lock(self);
+    
+    // reset index
+    self->rtp.serial_buffer.index = 0;
+
+	/* check if transport is started */
+	if(!self->is_started || !self->transport || !self->transport->master){
+		TSK_DEBUG_WARN("RTP engine not ready yet");
+		ret = 0;
+		goto bail;
+	}
+#if HAVE_SRTP
+	/* check that SRTP engine is ready or disabled */
+	if(self->srtp_state != trtp_srtp_state_none && self->srtp_state != trtp_srtp_state_started){
+		TSK_DEBUG_WARN("SRTP engine not ready yet");
+		ret = 0;
+		goto bail;
+	}
+	if(self->srtp_ctx_neg_local && !bypass_encrypt){
+		rtp_buff_pad_count = (SRTP_MAX_TRAILER_LEN + 0x04);
+	}
+#endif /* HAVE_SRTP */
+
+	xsize = (trtp_rtp_packet_guess_serialbuff_size(packet) + rtp_buff_pad_count);
+	if(self->rtp.serial_buffer.size < xsize){
+		if(!(self->rtp.serial_buffer.ptr = tsk_realloc(self->rtp.serial_buffer.ptr, xsize))){
+			TSK_DEBUG_ERROR("Failed to allocate buffer with size = %d", (int)xsize);
+			self->rtp.serial_buffer.size = 0;
+			goto bail;
+		}
+		self->rtp.serial_buffer.size = xsize;
+	}
+
+	/* serialize and send over the network */
+	if ((ret = (int)trtp_rtp_packet_serialize_to(packet, self->rtp.serial_buffer.ptr, xsize))) {
+		void* data_ptr = self->rtp.serial_buffer.ptr;
+		int data_size = ret;
+#if HAVE_SRTP
+		err_status_t status;
+		if(self->srtp_ctx_neg_local && !bypass_encrypt){
+			if((status = srtp_protect(self->srtp_ctx_neg_local->rtp.session, data_ptr, &data_size)) != err_status_ok){
+				TSK_DEBUG_ERROR("srtp_protect() failed with error code =%d", (int)status);
+				goto bail;
+			}
+		}
+#endif
+        self->rtp.serial_buffer.index = data_size; // update index
+		if (/* number of bytes sent */(ret = (int)trtp_manager_send_rtp_raw(self, data_ptr, data_size)) > 0) {
+			// forward packet to the RTCP session
+			if (self->rtcp.session) {
+				trtp_rtcp_session_process_rtp_out(self->rtcp.session, packet, data_size);
+			}
+		}
+		else ret = 0; 
+	}
+	else{
+		TSK_DEBUG_ERROR("Failed to serialize RTP packet");
+	}
+
+bail:
+	tsk_safeobj_unlock(self);
+	return ret;
+}
+
+// send raw data "as is" without adding any RTP header or SRTP encryption
+tsk_size_t trtp_manager_send_rtp_raw(trtp_manager_t* self, const void* data, tsk_size_t size)
+{
+	tsk_size_t ret = 0;
+
+	if(!self || !self->transport || !self->transport->master || !data || !size){
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return 0;
+	}
+	tsk_safeobj_lock(self);
+	if (self->is_ice_turn_active) {
+		// Send UDP/TCP/TLS buffer using TURN sockets
+		ret = (tnet_ice_ctx_send_turn_rtp(self->ice_ctx, data, size) == 0) ? size : 0; // returns #0 if ok
+	}
+	else {
+#if 1
+        ret = tnet_transport_sendto(self->transport, self->transport->master->fd, (const struct sockaddr *)&self->rtp.remote_addr, data, size); // returns number of sent bytes
+#else
+		ret = tnet_sockfd_sendto(self->transport->master->fd, (const struct sockaddr *)&self->rtp.remote_addr, data, size); // returns number of sent bytes
+#endif
+	}
+	tsk_safeobj_unlock(self);
+	return ret;
+}
+
+int trtp_manager_get_bytes_count(trtp_manager_t* self, uint64_t* bytes_in, uint64_t* bytes_out)
+{
+    if (!self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (!self->is_started) {
+        TSK_DEBUG_INFO("trtp_manager_get_bytes_count() called before starting RTP manager... returning zeros");
+        if (bytes_in) *bytes_in = 0;
+        if (bytes_out) *bytes_out = 0;
+        return 0;
+    }
+    
+    if (self->is_ice_turn_active) {
+        return tnet_ice_ctx_turn_get_bytes_count(self->ice_ctx, bytes_in, bytes_out);
+    }
+    return tnet_transport_get_bytes_count(self->transport, bytes_in, bytes_out);
+}
+
+int trtp_manager_set_app_bandwidth_max(trtp_manager_t* self, int32_t bw_upload_kbps, int32_t bw_download_kbps)
+{
+	if(self){
+		self->app_bw_max_upload = bw_upload_kbps;
+		self->app_bw_max_download = bw_download_kbps;
+		if(self->rtcp.session){
+			return trtp_rtcp_session_set_app_bandwidth_max(self->rtcp.session, bw_upload_kbps, bw_download_kbps);
+		}
+		return 0;
+	}
+	return -1;
+}
+
+int trtp_manager_signal_pkt_loss(trtp_manager_t* self, uint32_t ssrc_media, const uint16_t* seq_nums, tsk_size_t count)
+{
+	if(self && self->rtcp.session){
+		return trtp_rtcp_session_signal_pkt_loss(self->rtcp.session, ssrc_media, seq_nums, count);
+	}
+	return -1;
+}
+
+int trtp_manager_signal_frame_corrupted(trtp_manager_t* self, uint32_t ssrc_media)
+{
+	if(self && self->rtcp.session){
+		return trtp_rtcp_session_signal_frame_corrupted(self->rtcp.session, ssrc_media);
+	}
+	return -1;
+}
+
+int trtp_manager_signal_jb_error(trtp_manager_t* self, uint32_t ssrc_media)
+{
+	if(self && self->rtcp.session){
+		return trtp_rtcp_session_signal_jb_error(self->rtcp.session, ssrc_media);
+	}
+	return -1;
+}
+
+/** Stops the RTP/RTCP manager */
+int trtp_manager_stop(trtp_manager_t* self)
+{
+	int ret = 0;
+
+	if (!self) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+
+	TSK_DEBUG_INFO("trtp_manager_stop()");
+
+	tsk_safeobj_lock(self);
+
+	// We haven't started the ICE context which means we must not stop it
+	//if(self->ice_ctx){
+	//	ret = tnet_ice_ctx_stop(self->ice_ctx);
+	//}
+
+	// callbacks
+	if (self->transport) {
+		ret = tnet_transport_set_callback(self->transport, tsk_null, tsk_null);
+	}
+	if (self->ice_ctx) {
+		ret = tnet_ice_ctx_rtp_callback(self->ice_ctx, tsk_null, tsk_null);
+	}
+
+	// Stop the RTCP session first (will send BYE)
+	if(self->rtcp.session){
+		ret = trtp_rtcp_session_stop(self->rtcp.session);
+        ret = trtp_rtcp_session_set_net_transport(self->rtcp.session, tsk_null);
+	}
+
+	// Free transport to force next call to start() to create new one with new sockets
+	if (self->transport) {
+		tnet_socket_t *master_copy = tsk_object_ref(self->transport->master); // "tnet_transport_shutdown" will free the master
+		tnet_transport_shutdown(self->transport);
+#if HAVE_SRTP
+		{
+			struct tnet_socket_s* sockets[] = { master_copy, self->rtcp.local_socket };
+			// cancel DTLS handshaking timer
+			if (self->timer_mgr_global && self->dtls.timer_hanshaking.id != TSK_INVALID_TIMER_ID) {
+				tsk_timer_manager_cancel(self->timer_mgr_global, self->dtls.timer_hanshaking.id);
+				self->dtls.timer_hanshaking.id = TSK_INVALID_TIMER_ID; // invalidate timer id
+				self->dtls.timer_hanshaking.timeout = TRTP_DTLS_HANDSHAKING_TIMEOUT; // reset timeout
+			}
+			// destroy all SRTP contexts
+			_trtp_manager_srtp_set_enabled(self, self->srtp_type, sockets, sizeof(sockets) / sizeof(sockets[0]), tsk_false);
+		}
+#endif /* HAVE_SRTP */
+		TSK_OBJECT_SAFE_FREE(master_copy);
+		TSK_OBJECT_SAFE_FREE(self->transport);
+	}
+	// Free RTCP info to make sure these values will be updated in next start()
+	TSK_OBJECT_SAFE_FREE(self->rtcp.local_socket);
+    TSK_OBJECT_SAFE_FREE(self->rtcp.session);
+    self->rtcp.public_port = self->rtcp.remote_port = 0;
+    TSK_FREE(self->rtcp.public_ip);
+    TSK_FREE(self->rtcp.remote_ip);
+
+	// reset default values
+	self->is_symetric_rtp_checked = self->is_symetric_rtcp_checked = tsk_false;
+	self->is_ice_neg_ok = tsk_false;
+	self->is_ice_turn_active = tsk_false;
+	self->is_socket_disabled = tsk_false;
+
+	self->is_started = tsk_false;
+
+	tsk_safeobj_unlock(self);
+
+	return ret;
+}
+
+
+
+
+//=================================================================================================
+//	RTP manager object definition
+//
+static tsk_object_t* trtp_manager_ctor(tsk_object_t * self, va_list * app)
+{
+	trtp_manager_t *manager = (trtp_manager_t*)self;
+	if(manager){
+		manager->port_range.start = tmedia_defaults_get_rtp_port_range_start();
+		manager->port_range.stop = tmedia_defaults_get_rtp_port_range_stop();
+		manager->is_force_symetric_rtp = tmedia_defaults_get_rtp_symetric_enabled();
+		manager->app_bw_max_upload = INT_MAX; // INT_MAX or <=0 means undefined
+		manager->app_bw_max_download = INT_MAX; // INT_MAX or <=0 means undefined
+
+		/* srtp */
+#if HAVE_SRTP
+		manager->srtp_type = tmedia_defaults_get_srtp_type();
+		manager->srtp_mode = tmedia_defaults_get_srtp_mode();
+		manager->dtls.timer_hanshaking.id = TSK_INVALID_TIMER_ID;
+		manager->dtls.timer_hanshaking.timeout = TRTP_DTLS_HANDSHAKING_TIMEOUT;
+#endif /* HAVE_SRTP */
+
+		/* rtp */
+		manager->rtp.timestamp = rand()^rand();
+		manager->rtp.seq_num = rand()^rand();
+		manager->rtp.ssrc.local = rand()^rand()^(int)tsk_time_epoch();
+        manager->rtp.dscp = TRTP_DSCP_RTP_DEFAULT;
+
+		/* rtcp */
+        {
+            // use MD5 string to avoid padding issues
+            tsk_md5string_t md5 = { 0 };
+            tsk_sprintf(&manager->rtcp.cname, "doubango.%llu", (tsk_time_now() + rand()));
+            tsk_md5compute(manager->rtcp.cname, tsk_strlen(manager->rtcp.cname), &md5);
+            tsk_strupdate(&manager->rtcp.cname, md5);
+        }
+
+		/* timer */
+		manager->timer_mgr_global = tsk_timer_mgr_global_ref();
+
+		tsk_safeobj_init(manager);
+	}
+	return self;
+}
+
+static tsk_object_t* trtp_manager_dtor(tsk_object_t * self)
+{ 
+	trtp_manager_t *manager = self;
+	if(manager){
+		/* callbacks */
+		if (manager->ice_ctx) {
+			tnet_ice_ctx_rtp_callback(manager->ice_ctx, tsk_null, tsk_null);
+		}
+		if (manager->transport) {
+
+		}
+
+		/* stop */
+		if (manager->is_started) {
+			trtp_manager_stop(manager);
+		}
+
+		TSK_OBJECT_SAFE_FREE(manager->transport);
+
+		TSK_FREE(manager->local_ip);
+		
+		/* rtp */
+		TSK_FREE(manager->rtp.remote_ip);
+		TSK_FREE(manager->rtp.public_ip);
+		TSK_FREE(manager->rtp.serial_buffer.ptr);
+
+		/* rtcp */
+		TSK_OBJECT_SAFE_FREE(manager->rtcp.session);
+		TSK_FREE(manager->rtcp.remote_ip);
+		TSK_FREE(manager->rtcp.public_ip);
+		TSK_FREE(manager->rtcp.cname);
+		TSK_OBJECT_SAFE_FREE(manager->rtcp.local_socket);
+
+		/* SRTP */
+#if HAVE_SRTP
+		{
+			int i;
+			
+			/* Timer */
+			// cancel DTLS handshaking timer
+			if(manager->timer_mgr_global && manager->dtls.timer_hanshaking.id != TSK_INVALID_TIMER_ID){
+				tsk_timer_manager_cancel(manager->timer_mgr_global, manager->dtls.timer_hanshaking.id);
+				manager->dtls.timer_hanshaking.id = TSK_INVALID_TIMER_ID;
+			}
+
+			for(i = 0; i < 2; ++i){
+				trtp_srtp_ctx_deinit(&manager->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][i]);
+				trtp_srtp_ctx_deinit(&manager->srtp_contexts[TRTP_SRTP_LINE_IDX_REMOTE][i]);
+			}
+
+			/* SRTP-DTLS */
+			TSK_FREE(manager->dtls.file_ca);
+			TSK_FREE(manager->dtls.file_pbk);
+			TSK_FREE(manager->dtls.file_pvk);
+		}
+#endif /* HAVE_SRTP */
+
+		/* Timer manager */
+		if(manager->timer_mgr_global){
+			tsk_timer_mgr_global_unref(&manager->timer_mgr_global);
+		}
+
+		/* ICE */
+		if (manager->ice_ctx) {
+			TSK_OBJECT_SAFE_FREE(manager->ice_ctx);
+		}
+        
+        /* Proxy */
+        TSK_OBJECT_SAFE_FREE(manager->proxy.info);
+
+		tsk_safeobj_deinit(manager);
+
+		TSK_DEBUG_INFO("*** RTP manager destroyed ***");
+	}
+
+	return self;
+}
+
+static const tsk_object_def_t trtp_manager_def_s = 
+{
+	sizeof(trtp_manager_t),
+	trtp_manager_ctor, 
+	trtp_manager_dtor,
+	tsk_null, 
+};
+const tsk_object_def_t *trtp_manager_def_t = &trtp_manager_def_s;
diff --git a/tinyRTP/src/trtp_srtp.c b/tinyRTP/src/trtp_srtp.c
new file mode 100644
index 0000000..5e2d033
--- /dev/null
+++ b/tinyRTP/src/trtp_srtp.c
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2012 Mamadou Diop
+ * Copyright (C) 2012-2013 Doubango Telecom <http://www.doubango.org>
+ *
+ * This file is part of Open Source Doubango Framework.
+ *
+ * DOUBANGO is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * DOUBANGO is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with DOUBANGO.
+ *
+ */
+/**@file trtp_srtp.c
+ */
+#include "tinyrtp/trtp_srtp.h"
+#include "tinyrtp/trtp_manager.h"
+
+#if HAVE_SRTP
+
+extern err_status_t
+crypto_get_random(unsigned char *buffer, unsigned int length);
+
+int trtp_srtp_ctx_internal_init(struct trtp_srtp_ctx_internal_xs* ctx, int32_t tag, trtp_srtp_crypto_type_t type, uint32_t ssrc)
+{
+    char* key_str = ctx->key_str;
+    err_status_t srtp_err;
+    tsk_size_t size;
+    
+    if (!ctx) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    
+    if (ctx->initialized) {
+        trtp_srtp_ctx_internal_deinit(ctx);
+    }
+    
+    ctx->tag = tag;
+    ctx->crypto_type = type;
+    if (!ctx->have_valid_key) { // use same key to avoid unseless SRTP re-negs (also fix interop-issues against buggy clients -reINVITEs-)
+        if ((srtp_err = crypto_get_random((unsigned char*)ctx->key_bin, sizeof(ctx->key_bin))) != err_status_ok) {
+            TSK_DEBUG_ERROR("crypto_get_random() failed");
+            return -2;
+        }
+        size = tsk_base64_encode((const uint8_t*)ctx->key_bin, sizeof(ctx->key_bin), &key_str);
+        key_str[size] = '\0';
+        ctx->have_valid_key = tsk_true;
+    }
+    
+    switch(ctx->crypto_type){
+        case HMAC_SHA1_80:
+        {
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&ctx->policy.rtp);
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&ctx->policy.rtcp);
+            break;
+        }
+        case HMAC_SHA1_32:
+        default:
+        {
+            crypto_policy_set_aes_cm_128_hmac_sha1_32(&ctx->policy.rtp);
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&ctx->policy.rtcp); // RTCP always 80
+            break;
+        }
+    }
+    
+    ctx->policy.key = (unsigned char*)ctx->key_bin;
+    ctx->policy.ssrc.type = ssrc_any_outbound;
+    ctx->policy.ssrc.value = ssrc;
+    ctx->policy.window_size = 2048;
+    ctx->policy.allow_repeat_tx = 1;
+    if ((srtp_err = srtp_create(&ctx->session, &ctx->policy)) != err_status_ok) {
+        TSK_DEBUG_ERROR("srtp_create() failed");
+        return -3;
+    }
+    ctx->initialized = tsk_true;
+    return 0;
+}
+
+int trtp_srtp_ctx_internal_deinit(struct trtp_srtp_ctx_internal_xs* ctx)
+{
+    if(!ctx){
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if(ctx->initialized){
+        /*err_status_t srtp_err =*/ srtp_dealloc(ctx->session);
+        memset(&ctx->policy, 0, sizeof(ctx->policy));
+        ctx->initialized = tsk_false;
+    }
+    return 0;
+}
+
+int trtp_srtp_ctx_init(trtp_srtp_ctx_xt* ctx, int32_t tag, trtp_srtp_crypto_type_t type, uint32_t ssrc)
+{
+    int ret;
+    if(!ctx){
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if((ret = trtp_srtp_ctx_internal_init(&ctx->rtp, tag, type, ssrc))){
+        return ret;
+    }
+    return trtp_srtp_ctx_internal_init(&ctx->rtcp, tag, type, ssrc);
+}
+
+int trtp_srtp_ctx_deinit(trtp_srtp_ctx_xt* ctx)
+{
+    int ret;
+    if(!ctx){
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if((ret = trtp_srtp_ctx_internal_deinit(&ctx->rtp))){
+        return ret;
+    }
+    return trtp_srtp_ctx_internal_deinit(&ctx->rtcp);
+}
+
+int trtp_srtp_match_line(const char* crypto_line, int32_t* tag, int32_t* crypto_type, char* key, tsk_size_t key_size)
+{
+    char* copyptr = tsk_strdup(crypto_line); // "strtok_r" will insert "\0" and modify the string
+    char* saveptr = tsk_null;
+    char* v = tsk_strtok_r(copyptr, " :|;", &saveptr);
+    int32_t k = 0;
+    int ret = -0xF0;
+    while(v){
+        switch(k){
+            case 0:
+            {
+                if(tag){
+                    *tag = atoi(v);
+                }
+                break;
+            }
+            case 1:
+            {
+                if(tsk_striequals(v, TRTP_SRTP_AES_CM_128_HMAC_SHA1_80)){
+                    if(crypto_type){
+                        *crypto_type = HMAC_SHA1_80;
+                    }
+                }
+                else if(tsk_striequals(v, TRTP_SRTP_AES_CM_128_HMAC_SHA1_32)){
+                    if(crypto_type){
+                        *crypto_type = HMAC_SHA1_32;
+                    }
+                }
+                else {
+                    ret = -0xFF; goto bail;
+                }
+                break;
+            }
+            case 2:
+            {
+                if(!tsk_striequals(v, "inline")){
+                    ret = -0xFF; goto bail;
+                }
+                break;
+            }
+            case 3:
+            {
+                if(key && key_size){
+                    memset(key, 0, key_size);
+                    memcpy(key, v, TSK_MIN(key_size, tsk_strlen(v)));
+                }
+                ret = 0; goto bail;
+            }
+        }
+        ++k;
+        v = tsk_strtok_r(tsk_null, " :|;", &saveptr);
+    }
+bail:
+    TSK_FREE(copyptr);
+    return ret;
+}
+
+tsk_size_t trtp_srtp_get_local_contexts(trtp_manager_t* rtp_mgr, const struct trtp_srtp_ctx_xs ** contexts, tsk_size_t contexts_count)
+{
+    tsk_size_t ret = 0;
+    if(!rtp_mgr || !contexts){
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return 0;
+    }
+    
+    if (contexts_count > ret && rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_80].rtp.initialized) {
+        contexts[ret++] = &rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_80];
+    }
+    if (contexts_count > ret && rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_32].rtp.initialized) {
+        contexts[ret++] = &rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_32];
+    }
+    return ret;
+}
+
+int trtp_srtp_set_crypto(struct trtp_manager_s* rtp_mgr, const char* crypto_line, int32_t idx)
+{
+    //e.g. 2 F8_128_HMAC_SHA1_80 inline:MTIzNDU2Nzg5QUJDREUwMTIzNDU2Nzg5QUJjZGVm|2^20|1:4;inline:QUJjZGVmMTIzNDU2Nzg5QUJDREUwMTIzNDU2Nzg5|2^20|2:4"
+    trtp_srtp_ctx_xt* srtp_ctx;
+    int ret;
+    uint8_t *key_bin;
+    err_status_t srtp_err;
+    int32_t tag, crypto_type;
+    char key_str[SRTP_MAX_KEY_LEN + 1];
+    
+    memset(key_str, 0, sizeof(key_str));
+    
+    if ((ret = trtp_srtp_match_line(crypto_line, &tag, &crypto_type, key_str, sizeof(key_str) - 1))) {
+        return ret;
+    }
+    
+    srtp_ctx = &rtp_mgr->srtp_contexts[idx][crypto_type];
+    ret = trtp_srtp_ctx_deinit(srtp_ctx);
+    
+    srtp_ctx->rtp.tag = tag;
+    srtp_ctx->rtp.crypto_type = (trtp_srtp_crypto_type_t)crypto_type;
+    memcpy(srtp_ctx->rtp.key_str, key_str, sizeof(srtp_ctx->rtp.key_str));
+    
+    switch(srtp_ctx->rtp.crypto_type){
+        case HMAC_SHA1_80:
+        {
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&srtp_ctx->rtp.policy.rtp);
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&srtp_ctx->rtp.policy.rtcp);
+            if (idx == TRTP_SRTP_LINE_IDX_REMOTE) {
+                trtp_srtp_ctx_deinit(&rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_32]);
+                rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_80].rtp.tag =
+                rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_80].rtcp.tag = srtp_ctx->rtp.tag;
+            }
+            break;
+        }
+        case HMAC_SHA1_32:
+        {
+            crypto_policy_set_aes_cm_128_hmac_sha1_32(&srtp_ctx->rtp.policy.rtp);
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&srtp_ctx->rtp.policy.rtcp); // RTCP always 80
+            if (idx == TRTP_SRTP_LINE_IDX_REMOTE) {
+                trtp_srtp_ctx_deinit(&rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_80]);
+                rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_32].rtp.tag =
+                rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][HMAC_SHA1_32].rtcp.tag = srtp_ctx->rtp.tag;
+            }
+            break;
+        }
+        default: break;
+    }
+    
+    key_bin = (unsigned char*)srtp_ctx->rtp.key_bin;
+    tsk_base64_decode((const uint8_t*)srtp_ctx->rtp.key_str, (tsk_size_t)tsk_strlen(srtp_ctx->rtp.key_str), (char**)&key_bin);
+    srtp_ctx->rtp.policy.key = key_bin;
+    srtp_ctx->rtp.policy.ssrc.type = idx == TRTP_SRTP_LINE_IDX_REMOTE ? ssrc_any_inbound : ssrc_any_outbound;
+    srtp_ctx->rtp.policy.window_size = 2048;
+    srtp_ctx->rtp.policy.allow_repeat_tx = 1;
+    if ((srtp_err = srtp_create(&srtp_ctx->rtp.session, &srtp_ctx->rtp.policy)) != err_status_ok) {
+        TSK_DEBUG_ERROR("srtp_create() failed: %d", srtp_err);
+        return -3;
+    }
+    srtp_ctx->rtp.initialized = tsk_true;
+    return 0;
+}
+
+int trtp_srtp_set_key_and_salt(trtp_manager_t* rtp_mgr, trtp_srtp_crypto_type_t crypto_type, const void* key, tsk_size_t key_size, const void* salt, tsk_size_t salt_size, int32_t idx, tsk_bool_t is_rtp)
+{
+    int ret;
+    trtp_srtp_ctx_internal_xt* srtp_ctx;
+    err_status_t srtp_err;
+    if (!rtp_mgr || !key || !key_size || !salt || !salt_size) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    
+    srtp_ctx = is_rtp ? &rtp_mgr->srtp_contexts[idx][crypto_type].rtp : &rtp_mgr->srtp_contexts[idx][crypto_type].rtcp;
+    if ((ret = trtp_srtp_ctx_internal_deinit(srtp_ctx))) {
+        return ret;
+    }
+    
+    switch ((srtp_ctx->crypto_type = crypto_type)) {
+        case HMAC_SHA1_80:
+        default:
+        {
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&srtp_ctx->policy.rtp);
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&srtp_ctx->policy.rtcp);
+            break;
+        }
+        case HMAC_SHA1_32:
+        {
+            crypto_policy_set_aes_cm_128_hmac_sha1_32(&srtp_ctx->policy.rtp);
+            crypto_policy_set_aes_cm_128_hmac_sha1_80(&srtp_ctx->policy.rtcp); // always 80
+            break;
+        }
+    }
+    
+    memcpy(srtp_ctx->key_bin, key, key_size);
+#if HAVE_APPEND_SALT_TO_KEY
+    append_salt_to_key(srtp_ctx->key_bin, key_size, (void*)salt, salt_size);
+#else
+    memcpy(&srtp_ctx->key_bin[key_size], salt, salt_size);
+#endif
+    
+    srtp_ctx->policy.key = (unsigned char *)srtp_ctx->key_bin;
+    srtp_ctx->policy.ssrc.type = idx == TRTP_SRTP_LINE_IDX_REMOTE ? ssrc_any_inbound : ssrc_any_outbound;
+    srtp_ctx->policy.window_size = 2048;
+    srtp_ctx->policy.allow_repeat_tx = 1;
+    if((srtp_err = srtp_create(&srtp_ctx->session, &srtp_ctx->policy)) != err_status_ok){
+        TSK_DEBUG_ERROR("srtp_create() failed: %d", srtp_err);
+        return -3;
+    }
+    srtp_ctx->initialized = tsk_true;
+    return 0;
+}
+
+tsk_bool_t trtp_srtp_is_initialized(trtp_manager_t* rtp_mgr)
+{
+    if (!rtp_mgr) {
+        return tsk_false;
+    }
+    return ((rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][0].rtp.initialized || rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_LOCAL][1].rtp.initialized) 
+            && rtp_mgr->srtp_contexts[TRTP_SRTP_LINE_IDX_REMOTE][0].rtp.initialized);
+}
+
+tsk_bool_t trtp_srtp_is_started(trtp_manager_t* rtp_mgr)
+{
+    if (!rtp_mgr) {
+        TSK_DEBUG_ERROR("Invalid argument");
+        return tsk_false;
+    }
+    return (rtp_mgr ->srtp_ctx_neg_remote && rtp_mgr ->srtp_ctx_neg_local);
+}
+
+#endif /* HAVE_SRTP */
\ No newline at end of file
diff --git a/tinyRTP/test/test.c b/tinyRTP/test/test.c
new file mode 100644
index 0000000..f0f15f6
--- /dev/null
+++ b/tinyRTP/test/test.c
@@ -0,0 +1,65 @@
+/*
+* Copyright (C) 2009 Mamadou Diop.
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include <string.h>
+#include <stdlib.h>
+
+#include "tinyrtp.h"
+
+#define LOOP						1
+
+#define RUN_TEST_ALL				0
+#define RUN_TEST_PARSER				0
+#define RUN_TEST_MANAGER			1
+
+#include "test_parser.h"
+#include "test_manager.h"
+
+
+
+#ifdef _WIN32_WCE
+int _tmain(int argc, _TCHAR* argv[])
+#else
+int main()
+#endif
+{
+	tnet_startup();
+
+	do{
+		/* Print copyright information */
+		printf("Doubango Project\nCopyright (C) 2009-2010 Mamadou Diop \n\n");
+
+#if RUN_TEST_PARSER || RUN_TEST_ALL
+		test_parser();
+#endif
+
+#if RUN_TEST_MANAGER || RUN_TEST_ALL
+		test_manager();
+#endif
+
+	}
+	while(LOOP);
+
+	tnet_cleanup();
+
+	return 0;
+}
+
diff --git a/tinyRTP/test/test.vcproj b/tinyRTP/test/test.vcproj
new file mode 100644
index 0000000..53adaaf
--- /dev/null
+++ b/tinyRTP/test/test.vcproj
@@ -0,0 +1,200 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="test"
+	ProjectGUID="{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}"
+	RootNamespace="test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\thirdparties\win32\include;..\..\tinyRTP\include;..\..\tinySAK\src;..\..\tinyNET\src"
+				PreprocessorDefinitions="DEBUG_LEVEL=DEBUG_LEVEL_INFO;WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				WarnAsError="true"
+				DebugInformationFormat="4"
+				CompileAs="1"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="$(OutDir)\tinySAK.lib $(OutDir)\tinyNET.lib $(OutDir)\tinyRTP.lib"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+				CompileAs="1"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="source"
+			>
+			<File
+				RelativePath=".\test.c"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="include"
+			>
+		</Filter>
+		<Filter
+			Name="tests"
+			>
+			<File
+				RelativePath=".\test_manager.h"
+				>
+			</File>
+			<File
+				RelativePath=".\test_parser.h"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/tinyRTP/test/test_manager.h b/tinyRTP/test/test_manager.h
new file mode 100644
index 0000000..29c2dcc
--- /dev/null
+++ b/tinyRTP/test/test_manager.h
@@ -0,0 +1,69 @@
+/*
+* Copyright (C) 2009 Mamadou Diop.
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef _TEST_MANAGER_H_
+#define _TEST_MANAGER_H_
+
+void test_manager()
+{
+	tsk_size_t i;
+	trtp_manager_t* manager;
+
+	if(!(manager = trtp_manager_create(tsk_true, "192.168.0.12", tsk_false))){
+		goto bail;
+	}
+
+	trtp_manager_set_payload_type(manager, 8);
+
+	/* Prepare: this will allow you to generate local port and ip */
+	if(trtp_manager_prepare(manager)){
+		goto bail;
+	}
+
+	/* set remote parameters (rtcp ip:port not mandator, could be retrieved from rtp values) */
+	if(trtp_manager_set_rtp_remote(manager, "192.168.0.13", 5081)){
+		goto bail;
+	}
+	if(trtp_manager_set_rtcp_remote(manager, "192.168.0.13", 2861)){
+		goto bail;
+	}
+
+	/* start */
+	if(trtp_manager_start(manager)){
+		goto bail;
+	}
+	
+	/* send data */
+	for(i=0;i<2; i++){
+		if(trtp_manager_send_rtp(manager, "test", tsk_strlen("test"), 160, tsk_true)){
+			goto bail;
+		}
+	}
+	
+	getchar();
+
+bail:
+	/* stop and destroy */
+	TSK_OBJECT_SAFE_FREE(manager);
+}
+
+#endif /* _TEST_MANAGER_H_ */
+
diff --git a/tinyRTP/test/test_parser.h b/tinyRTP/test/test_parser.h
new file mode 100644
index 0000000..a65b816
--- /dev/null
+++ b/tinyRTP/test/test_parser.h
@@ -0,0 +1,331 @@
+/*
+* Copyright (C) 2009 Mamadou Diop.
+*
+* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
+*	
+* This file is part of Open Source Doubango Framework.
+*
+* DOUBANGO is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*	
+* DOUBANGO is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+*	
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#ifndef _TEST_PARSER_H_
+#define _TEST_PARSER_H_
+
+char packet_0[] = {
+0x80, 0x88, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa0, 
+0xd2, 0xbd, 0x4e, 0x3e, 0xdc, 0xde, 0xc4, 0xc5, 
+0xdc, 0xd0, 0xd5, 0x51, 0x53, 0x5d, 0x5f, 0x5b, 
+0x46, 0x46, 0x46, 0x5b, 0x44, 0x41, 0x42, 0x4f, 
+0x42, 0x47, 0x42, 0x43, 0x59, 0x58, 0x59, 0x5f, 
+0x5f, 0x52, 0x59, 0x44, 0x44, 0x5f, 0x51, 0x54, 
+0x55, 0x55, 0x51, 0x56, 0x50, 0x52, 0x5e, 0x58, 
+0x5d, 0x52, 0x52, 0x50, 0x57, 0x54, 0xd4, 0xd6, 
+0xd5, 0x51, 0x53, 0x57, 0xd6, 0xd6, 0xd0, 0xd7, 
+0x57, 0x56, 0x57, 0xd0, 0xd3, 0xd6, 0xd5, 0x55, 
+0x51, 0x50, 0xd6, 0xdf, 0xd2, 0xd1, 0xd4, 0xd6, 
+0xdc, 0xdb, 0xda, 0xdd, 0xd6, 0x55, 0xdc, 0xd0, 
+0xd4, 0x5d, 0x44, 0x5c, 0x56, 0xd6, 0xd5, 0xd4, 
+0xd5, 0xd7, 0x50, 0xd4, 0x51, 0xd0, 0x61, 0x6f, 
+0x76, 0xfe, 0xef, 0xf7, 0x77, 0x66, 0x50, 0xff, 
+0xe5, 0xd7, 0x74, 0x4a, 0xc9, 0xf9, 0xf7, 0x5c, 
+0x76, 0x5f, 0xf5, 0xf3, 0xdd, 0x4e, 0x42, 0xd8, 
+0xf7, 0xc9, 0x50, 0x44, 0x50, 0xcd, 0xc9, 0xd4, 
+0x4d, 0x41, 0x57, 0xd1, 0x51, 0x58, 0x44, 0x52, 
+0xd3, 0xd1, 0x50, 0x58, 0x5b, 0x55, 0xd4, 0x53, 
+0x59, 0x43, 0x47, 0x5f, 0x51, 0x5d, 0x56, 0xd2, 
+0xde, 0xd7, 0x52, 0xd5 };
+char packet_1[] = {
+0x80, 0x08, 0x00, 0x02, 0x00, 0x00, 0x01, 0x40, 
+0xd2, 0xbd, 0x4e, 0x3e, 0xd2, 0xc7, 0xc5, 0xd3, 
+0xd1, 0xd6, 0xd5, 0x55, 0xd2, 0xd2, 0xd3, 0xdf, 
+0xc4, 0xd9, 0xdb, 0xc6, 0xc6, 0xc9, 0xc1, 0xf5, 
+0xcf, 0xf0, 0xcb, 0xe4, 0x7d, 0x14, 0x7a, 0xfd, 
+0xfd, 0x62, 0x63, 0x41, 0xee, 0xe7, 0x40, 0x6c, 
+0x46, 0xf8, 0xf3, 0x74, 0x7b, 0x58, 0xf3, 0xf1, 
+0xd6, 0x5d, 0xc7, 0xfd, 0xff, 0xf5, 0x55, 0xd9, 
+0xcb, 0xcb, 0xde, 0xd1, 0xda, 0xca, 0xcd, 0xc5, 
+0xc4, 0x41, 0x72, 0x41, 0x55, 0xda, 0x54, 0x5c, 
+0x40, 0x59, 0xd1, 0x5f, 0x4b, 0x40, 0x51, 0x52, 
+0x45, 0x4b, 0x77, 0x49, 0x4e, 0x4e, 0x48, 0x4a, 
+0x75, 0x47, 0x75, 0x7b, 0x72, 0x42, 0x58, 0x4c, 
+0x46, 0xd5, 0xc2, 0xd1, 0x5d, 0x44, 0x50, 0xd0, 
+0x53, 0x43, 0x41, 0x52, 0x53, 0x5a, 0x44, 0x50, 
+0xdd, 0x45, 0x65, 0x7d, 0x74, 0x4c, 0x70, 0x43, 
+0x53, 0xc4, 0xc5, 0x5b, 0x5a, 0x5c, 0x51, 0x4f, 
+0x70, 0x4a, 0x58, 0x5e, 0x75, 0x76, 0x40, 0x57, 
+0x51, 0x46, 0x5e, 0x5c, 0xd5, 0x5c, 0x5c, 0x5e, 
+0x5e, 0x4d, 0x41, 0x44, 0xd4, 0xd6, 0xd5, 0x52, 
+0x54, 0xdd, 0xd7, 0xd3, 0x56, 0x51, 0x55, 0xdf, 
+0x54, 0xd1, 0xd2, 0xda };
+char packet_2[] = {
+0x80, 0x08, 0x00, 0x03, 0x00, 0x00, 0x01, 0xe0, 
+0xd2, 0xbd, 0x4e, 0x3e, 0xdb, 0xd1, 0xd5, 0xd0, 
+0xd2, 0xd3, 0x57, 0xd5, 0xd6, 0xd6, 0xd1, 0xd5, 
+0xd1, 0xdd, 0xd5, 0xd1, 0xd1, 0xd4, 0x5f, 0x56, 
+0x5f, 0x5a, 0x53, 0x59, 0x5c, 0x5f, 0x5d, 0x5d, 
+0xd6, 0xd0, 0xd8, 0x54, 0xc4, 0xd9, 0xc6, 0xdc, 
+0x57, 0x56, 0x56, 0x57, 0x51, 0x54, 0x53, 0x57, 
+0x59, 0x44, 0x44, 0x5e, 0x45, 0x45, 0x5a, 0x5e, 
+0x53, 0x58, 0x4c, 0x45, 0x59, 0x45, 0x5b, 0x57, 
+0x52, 0x5e, 0x5e, 0x59, 0x5c, 0x51, 0xd7, 0xd0, 
+0xc5, 0xc1, 0xd8, 0xc1, 0xcd, 0xcd, 0xc2, 0xcd, 
+0xc6, 0xcc, 0xc0, 0xc6, 0xc1, 0xc9, 0xcb, 0xdb, 
+0xd0, 0xdd, 0xc6, 0xd8, 0xd5, 0x5f, 0x41, 0x46, 
+0x4f, 0x74, 0x76, 0x70, 0x72, 0x7f, 0x72, 0x77, 
+0x49, 0x4a, 0x76, 0x4a, 0x44, 0x45, 0x44, 0x59, 
+0x50, 0x55, 0xd3, 0xd9, 0xcc, 0xf7, 0xf1, 0xca, 
+0xc2, 0xf7, 0xf8, 0xe7, 0xe7, 0xe2, 0xee, 0xe9, 
+0xed, 0xe4, 0xc2, 0xcb, 0xf7, 0xd2, 0x48, 0x76, 
+0x45, 0x77, 0x64, 0x64, 0x4a, 0x51, 0x46, 0x41, 
+0xdd, 0xc2, 0xd4, 0x51, 0x50, 0x4a, 0x74, 0x71, 
+0x7e, 0x61, 0x67, 0x7e, 0x67, 0x60, 0x67, 0x77, 
+0x45, 0x43, 0x5f, 0xc8 };
+char packet_3[] = {
+0x80, 0x08, 0x2c, 0x43, 0x11, 0x47, 0x31, 0xa2, 
+0x58, 0xf3, 0x3d, 0xea, 0x53, 0x45, 0x56, 0x47, 
+0x5f, 0xd4, 0xd4, 0x55, 0x56, 0x58, 0x40, 0x53, 
+0x54, 0xd5, 0xc7, 0xc4, 0x57, 0xd5, 0xdd, 0xd9, 
+0xde, 0xdd, 0xdc, 0xd4, 0x55, 0x54, 0xdc, 0xcf, 
+0xc7, 0x5e, 0x43, 0x5a, 0x5a, 0x43, 0x5b, 0x51, 
+0x54, 0x51, 0xd6, 0xd4, 0x5b, 0x53, 0xd3, 0x57, 
+0xd5, 0xc0, 0xc7, 0x53, 0x5d, 0xd1, 0xc5, 0xc1, 
+0xd9, 0x5d, 0x57, 0xdc, 0xd0, 0xd0, 0x54, 0x45, 
+0x44, 0x42, 0x45, 0xd0, 0xd4, 0xd5, 0xd9, 0xc7, 
+0x57, 0x5e, 0x5f, 0x47, 0x56, 0xc5, 0xca, 0xc5, 
+0xd3, 0xdf, 0x57, 0x43, 0x4b, 0x5a, 0x5c, 0x5f, 
+0x45, 0x52, 0xd0, 0xc7, 0xcb, 0xc9, 0xc5, 0x5f, 
+0x47, 0x57, 0x55, 0xdc, 0xc7, 0x5d, 0x4b, 0x5a, 
+0xdb, 0xcf, 0xc5, 0x52, 0x43, 0x5a, 0x56, 0xde, 
+0xdf, 0xd6, 0xd5, 0x45, 0x5b, 0xdc, 0xdb, 0x55, 
+0x52, 0x54, 0x51, 0xd5, 0xc4, 0xdf, 0xd1, 0x56, 
+0x51, 0xd5, 0xd3, 0xde, 0x54, 0x44, 0x46, 0x52, 
+0x56, 0x5b, 0x5a, 0xd3, 0xc3, 0xdf, 0x57, 0xd1, 
+0xd9, 0xd6, 0x5f, 0x5f, 0xd4, 0xd6, 0xd5, 0xd1, 
+0x53, 0xd4, 0xc1, 0xdb, 0xdd, 0xd8, 0xd7, 0x47, 
+0x4b, 0x75, 0x4c, 0x5c };
+char packet_4[] = {
+0x80, 0x08, 0x00, 0x04, 0x00, 0x00, 0x02, 0x80, 
+0xd2, 0xbd, 0x4e, 0x3e, 0xff, 0xf3, 0xff, 0xe1, 
+0xe7, 0xe4, 0xe5, 0xe2, 0xec, 0xef, 0xeb, 0xe9, 
+0x95, 0x97, 0xf8, 0xcc, 0xe4, 0xf9, 0x58, 0x6d, 
+0x72, 0x46, 0x7c, 0x62, 0x60, 0x42, 0x40, 0x70, 
+0x4e, 0xd3, 0xcb, 0xda, 0xd9, 0x54, 0x57, 0xd6, 
+0x4a, 0x62, 0x6e, 0x64, 0x60, 0x15, 0x15, 0x63, 
+0x67, 0x62, 0x60, 0x7f, 0x46, 0x46, 0x40, 0xd5, 
+0xcf, 0xf6, 0xc9, 0xcb, 0xf0, 0xfd, 0xf8, 0xe6, 
+0xec, 0xe9, 0x94, 0x91, 0x96, 0xf7, 0xd0, 0xe7, 
+0xf3, 0x7d, 0x6b, 0x7d, 0x5d, 0x65, 0x68, 0x61, 
+0x5d, 0x5c, 0x72, 0x43, 0xcd, 0xf6, 0xdf, 0xd2, 
+0xd2, 0x51, 0xdf, 0x49, 0x62, 0x14, 0x68, 0x6e, 
+0x10, 0x11, 0x69, 0x64, 0x61, 0x6d, 0x64, 0x75, 
+0x44, 0x74, 0x5e, 0xcf, 0xff, 0xf1, 0xc1, 0xf7, 
+0xf6, 0xe5, 0xe4, 0xe6, 0xe9, 0x91, 0x93, 0x90, 
+0x95, 0xce, 0xe5, 0xe0, 0xc7, 0x66, 0x62, 0x45, 
+0x75, 0x63, 0x6e, 0x79, 0x55, 0x49, 0x71, 0x53, 
+0xca, 0xcb, 0xd0, 0xdb, 0xd3, 0xd5, 0x5b, 0x67, 
+0x6b, 0x15, 0x61, 0x69, 0x17, 0x14, 0x6c, 0x66, 
+0x6f, 0x62, 0x7f, 0x48, 0x74, 0x75, 0x59, 0xd0, 
+0xdb, 0x54, 0xd7, 0xc3 };
+char packet_5[] = {
+0x80, 0x08, 0x2c, 0x44, 0x11, 0x47, 0x32, 0x42, 
+0x58, 0xf3, 0x3d, 0xea, 0x54, 0xd5, 0xde, 0xc4, 
+0xc0, 0xce, 0xd8, 0xd5, 0xdc, 0xde, 0xd4, 0xd9, 
+0x54, 0x4d, 0x74, 0x47, 0x44, 0x58, 0xc7, 0xc3, 
+0xc4, 0xd4, 0x55, 0x50, 0x43, 0x45, 0xd4, 0xc7, 
+0xcf, 0xc0, 0x55, 0x42, 0x48, 0x76, 0x4f, 0xd7, 
+0xc7, 0xcf, 0xc6, 0xc6, 0xf5, 0xc6, 0x53, 0x5a, 
+0x42, 0x5e, 0x51, 0xd6, 0xc4, 0xde, 0x56, 0x42, 
+0x42, 0x5e, 0xd7, 0xd4, 0xdb, 0xcb, 0xda, 0xd6, 
+0xd7, 0x53, 0x47, 0x4d, 0xd4, 0xdf, 0xdc, 0xd5, 
+0x5a, 0x59, 0x5a, 0x5a, 0xd5, 0xc4, 0xd7, 0x55, 
+0xc3, 0xce, 0xde, 0xd2, 0xd6, 0x46, 0x71, 0x7c, 
+0x4c, 0xd8, 0xf5, 0xf7, 0xcf, 0x54, 0x56, 0xd5, 
+0xdc, 0xda, 0xd7, 0xd7, 0x57, 0x5a, 0x5c, 0x52, 
+0x47, 0x5c, 0xd4, 0xd3, 0xd4, 0x47, 0x42, 0x4d, 
+0x54, 0xcf, 0xf3, 0xf0, 0xc0, 0xdb, 0xd1, 0x50, 
+0x47, 0x5e, 0x58, 0x49, 0x43, 0x5a, 0x54, 0xdc, 
+0x56, 0x56, 0xd9, 0xc8, 0xc2, 0xd2, 0x5d, 0x5a, 
+0x5a, 0x49, 0x40, 0x57, 0xda, 0xdb, 0xd6, 0x55, 
+0xdd, 0xcf, 0xdb, 0x5c, 0x51, 0xd0, 0xd5, 0x5f, 
+0x53, 0xd8, 0xc3, 0xc3, 0xd0, 0x5c, 0x5b, 0x44, 
+0x4e, 0x74, 0x4f, 0x56 };
+char packet_6[] = {
+0x80, 0x08, 0x00, 0x05, 0x00, 0x00, 0x03, 0x20, 
+0xd2, 0xbd, 0x4e, 0x3e, 0xca, 0xf0, 0xfd, 0xe2, 
+0xea, 0x96, 0x91, 0x91, 0xe7, 0xd9, 0xf9, 0xf9, 
+0x48, 0x6b, 0x61, 0x74, 0x66, 0x15, 0x69, 0x74, 
+0x42, 0x7d, 0x75, 0xd2, 0xf7, 0xc8, 0xc3, 0xd1, 
+0x5f, 0x5f, 0x7d, 0x6f, 0x15, 0x6d, 0x6e, 0x16, 
+0x16, 0x68, 0x61, 0x62, 0x6c, 0x66, 0x79, 0x7d, 
+0x7f, 0x77, 0x5c, 0xd9, 0xdb, 0x5e, 0x55, 0xcf, 
+0xf1, 0xf0, 0xe5, 0xef, 0x95, 0x96, 0x93, 0x97, 
+0xcd, 0xc3, 0xe4, 0xf7, 0x64, 0x15, 0x7a, 0x73, 
+0x60, 0x68, 0x64, 0xd1, 0x53, 0x4e, 0x5d, 0xf7, 
+0xf9, 0xf3, 0xf5, 0xd5, 0xd4, 0x58, 0x67, 0x6e, 
+0x6c, 0x61, 0x68, 0x14, 0x68, 0x61, 0x64, 0x63, 
+0x61, 0x79, 0x75, 0x4b, 0x4f, 0x44, 0xd7, 0xcb, 
+0xc0, 0xd8, 0xf6, 0xe4, 0xe1, 0xe7, 0xed, 0x97, 
+0x91, 0x93, 0x9d, 0x96, 0xff, 0xfd, 0xe5, 0xc7, 
+0x66, 0x67, 0x4d, 0x4e, 0x64, 0x62, 0x71, 0x54, 
+0xd5, 0x5f, 0xd0, 0xce, 0xce, 0xdf, 0x5d, 0x73, 
+0x72, 0x73, 0x6c, 0x15, 0x6d, 0x6d, 0x15, 0x14, 
+0x69, 0x63, 0x62, 0x62, 0x66, 0x78, 0x72, 0x76, 
+0x43, 0x5b, 0xd5, 0xc0, 0xd9, 0xdd, 0xca, 0xf8, 
+0xe4, 0xe7, 0xef, 0x96 };
+char packet_7[] = {
+0x80, 0x08, 0x2c, 0x45, 0x11, 0x47, 0x32, 0xe2, 
+0x58, 0xf3, 0x3d, 0xea, 0xdd, 0xd9, 0xd2, 0xd6, 
+0xd0, 0xd6, 0xdf, 0xd7, 0xd7, 0x54, 0xd5, 0x57, 
+0x57, 0xd0, 0xd4, 0x55, 0xd5, 0xd8, 0xdb, 0xc0, 
+0xc2, 0x53, 0x58, 0x5d, 0x57, 0x5e, 0x47, 0x41, 
+0x4a, 0x5f, 0xde, 0xd9, 0x55, 0xd0, 0xc5, 0xdd, 
+0xd3, 0xdd, 0xc6, 0xc1, 0xd1, 0x52, 0x5b, 0xd1, 
+0xcc, 0xd9, 0x43, 0x7a, 0x78, 0x4e, 0x55, 0xd2, 
+0xc5, 0xc3, 0xda, 0xc5, 0xd4, 0xd3, 0xc7, 0xd2, 
+0xd9, 0xdb, 0x55, 0x45, 0x59, 0x51, 0x59, 0xd4, 
+0xc2, 0xc6, 0xd0, 0xd1, 0x59, 0x48, 0x40, 0x47, 
+0x5a, 0x55, 0xd2, 0xdc, 0xd9, 0xc9, 0xf6, 0xd9, 
+0x42, 0x72, 0x40, 0xd1, 0x50, 0xd7, 0xc4, 0xc9, 
+0xc5, 0xc1, 0xc3, 0x54, 0x5b, 0x48, 0x43, 0x57, 
+0xd3, 0xd1, 0x5c, 0x47, 0x47, 0x49, 0x47, 0x59, 
+0xd1, 0xf5, 0xd8, 0xd6, 0xdd, 0xd8, 0x5c, 0x53, 
+0xc7, 0xc9, 0xc9, 0xc0, 0xd4, 0x4d, 0x4f, 0x47, 
+0x50, 0xdf, 0xce, 0xd8, 0x5d, 0x43, 0x40, 0x5f, 
+0xd1, 0x56, 0x58, 0xd0, 0xd0, 0xd0, 0xdb, 0x55, 
+0x5b, 0x5b, 0xd4, 0xda, 0xc0, 0xc6, 0xd4, 0x58, 
+0x5a, 0xd8, 0xc7, 0xdf, 0x54, 0x4a, 0x71, 0x43, 
+0xd0, 0xc3, 0xc9, 0xde };
+char packet_8[] = {
+0x80, 0x08, 0x00, 0x06, 0x00, 0x00, 0x03, 0xc0, 
+0xd2, 0xbd, 0x4e, 0x3e, 0x90, 0x93, 0x92, 0x92, 
+0xe0, 0xf1, 0xff, 0xf6, 0x73, 0x60, 0x73, 0x75, 
+0x7f, 0x66, 0x7e, 0x5b, 0xd7, 0x56, 0xd5, 0xd2, 
+0xdf, 0xd2, 0xd0, 0x48, 0x78, 0x65, 0x66, 0x6f, 
+0x6b, 0x6c, 0x6f, 0x68, 0x6b, 0x6e, 0x6c, 0x62, 
+0x65, 0x78, 0x7d, 0x48, 0x4b, 0x4a, 0x42, 0xda, 
+0xf4, 0xc0, 0xcf, 0xfd, 0xe6, 0xe0, 0xe3, 0xe9, 
+0x91, 0x92, 0x9c, 0x9f, 0x90, 0xe2, 0xe7, 0xfa, 
+0xc3, 0x46, 0x75, 0x5f, 0x47, 0x42, 0x48, 0x44, 
+0xd3, 0xd0, 0xc5, 0xdf, 0xd2, 0xd8, 0xd8, 0x58, 
+0x7c, 0x72, 0x73, 0x7e, 0x60, 0x61, 0x65, 0x67, 
+0x60, 0x6d, 0x66, 0x7c, 0x71, 0x7d, 0x7d, 0x4a, 
+0xd4, 0xd8, 0xd2, 0xc1, 0xf5, 0xce, 0xdb, 0xf0, 
+0xe6, 0xe6, 0xe6, 0xed, 0xea, 0x97, 0x91, 0x92, 
+0x9c, 0x97, 0xe4, 0xfb, 0xe4, 0xc1, 0x74, 0x40, 
+0x54, 0x50, 0x4e, 0x75, 0x45, 0x54, 0x50, 0x44, 
+0x5f, 0x5d, 0x5b, 0x46, 0x73, 0x64, 0x7a, 0x7e, 
+0x67, 0x63, 0x66, 0x60, 0x6c, 0x69, 0x6c, 0x60, 
+0x64, 0x7a, 0x7b, 0x7c, 0x48, 0x45, 0x5b, 0x59, 
+0xd8, 0xca, 0xcc, 0xc3, 0xf0, 0xfa, 0xe5, 0xe1, 
+0xed, 0xea, 0x96, 0x91 };
+char packet_9[] = {
+0x80, 0x08, 0x2c, 0x46, 0x11, 0x47, 0x33, 0x82, 
+0x58, 0xf3, 0x3d, 0xea, 0x5b, 0x47, 0x55, 0xdf, 
+0xd1, 0xd5, 0x54, 0xd3, 0xc4, 0x55, 0x5e, 0x56, 
+0xd1, 0xd2, 0xde, 0xdd, 0x54, 0x5c, 0x45, 0x5d, 
+0x55, 0x5d, 0x59, 0xd6, 0x55, 0x5a, 0xd3, 0xd9, 
+0xd0, 0xdc, 0xd8, 0xd8, 0xc6, 0xca, 0xc6, 0xd1, 
+0x5a, 0x7f, 0x7e, 0x4f, 0xdd, 0xd9, 0x57, 0x45, 
+0x59, 0xd7, 0xdd, 0xc3, 0xc6, 0x54, 0x5c, 0xd4, 
+0xdd, 0xdd, 0x5d, 0x43, 0x55, 0xdf, 0xda, 0xcc, 
+0xc9, 0x54, 0x4f, 0x5c, 0x55, 0xd2, 0xd0, 0xd1, 
+0x52, 0x5f, 0xdd, 0x53, 0x58, 0x53, 0xd6, 0xdd, 
+0xd9, 0xdc, 0xc1, 0xd7, 0x4a, 0x4e, 0x47, 0x51, 
+0xdf, 0xf5, 0xc6, 0x57, 0x5b, 0x75, 0x74, 0x55, 
+0xf6, 0xdb, 0x5e, 0x50, 0xd4, 0xd3, 0x56, 0x58, 
+0x5f, 0xd7, 0xdd, 0xde, 0xd2, 0xd5, 0x4d, 0x71, 
+0x5f, 0xf4, 0xf2, 0xc0, 0x50, 0x41, 0x5c, 0xd0, 
+0xd7, 0xdc, 0xd1, 0x45, 0x4e, 0x5c, 0x54, 0x5e, 
+0x77, 0x72, 0x5a, 0xcf, 0xf2, 0xf4, 0xda, 0xd2, 
+0xd6, 0x58, 0x5e, 0xdf, 0xc1, 0xc2, 0x57, 0x40, 
+0x56, 0xd7, 0xd7, 0xd5, 0x56, 0x45, 0x43, 0x50, 
+0xd9, 0xd2, 0x52, 0x5e, 0x5d, 0xd2, 0xd8, 0xd2, 
+0x54, 0x58, 0x41, 0x43 };
+char packet_10[] = {
+0x80, 0x08, 0x2c, 0x47, 0x11, 0x47, 0x34, 0x22, 
+0x58, 0xf3, 0x3d, 0xea, 0x56, 0xd4, 0xd6, 0x58, 
+0x42, 0x53, 0xc4, 0xf7, 0xcb, 0xf5, 0xf4, 0xc1, 
+0xd0, 0x4d, 0x45, 0xd6, 0x57, 0xd0, 0xd9, 0xdb, 
+0x50, 0x44, 0x59, 0x4b, 0x4f, 0xd6, 0xd8, 0x57, 
+0x5e, 0xd6, 0x57, 0xd0, 0xc5, 0xdf, 0xc6, 0xcd, 
+0xc5, 0x51, 0x50, 0xd0, 0xd6, 0xd2, 0xdb, 0x5d, 
+0x75, 0x75, 0x73, 0x75, 0xc0, 0xf7, 0xf0, 0xf6, 
+0xc9, 0xd8, 0xd5, 0x57, 0x56, 0x48, 0x70, 0x75, 
+0x42, 0x42, 0x5f, 0xd0, 0x5d, 0x5b, 0x5c, 0x55, 
+0xd6, 0xc1, 0xcf, 0xd8, 0xd3, 0xd0, 0x45, 0x4f, 
+0x54, 0xc6, 0xd0, 0x59, 0x55, 0xc4, 0xd1, 0x5a, 
+0x73, 0x7f, 0x47, 0x54, 0xd1, 0xdf, 0xdc, 0xd7, 
+0xc7, 0xc8, 0xdb, 0xc7, 0xca, 0xc9, 0xc0, 0xc7, 
+0xc1, 0x51, 0x40, 0x5f, 0x52, 0xd7, 0xda, 0xdf, 
+0x41, 0x4c, 0x56, 0x54, 0x5f, 0x4a, 0x4a, 0x4e, 
+0x5d, 0xc4, 0xc6, 0xcd, 0xc7, 0xd6, 0x52, 0xd4, 
+0xc4, 0xc4, 0xc6, 0xd5, 0x5b, 0x41, 0x4e, 0x56, 
+0xc4, 0xd8, 0x54, 0x5e, 0x4d, 0x48, 0x76, 0x73, 
+0x4d, 0x5b, 0x59, 0xd8, 0xf0, 0xf7, 0xde, 0x52, 
+0xd0, 0xc3, 0xfd, 0xfa, 0xfd, 0xc1, 0x40, 0x4a, 
+0x5a, 0x45, 0x5d, 0xd0 };
+
+#define MAKE_TEST(n) \
+	/* deserialize the packet*/ \
+	if((packet = trtp_rtp_packet_deserialize(packet_##n, sizeof(packet_##n)))){ \
+		/* serialize the packet */ \
+		if((buffer = trtp_rtp_packet_serialize(packet))){ \
+			/* compare data */ \
+			if(sizeof(packet_##n) != buffer->size){ \
+				TSK_DEBUG_ERROR("Test-%d: Sizes are different", n); \
+			} \
+			else{ \
+				for(i=0; i<buffer->size; i++){ \
+					if(packet_##n[i] != ((char*)buffer->data)[i]){ \
+						TSK_DEBUG_ERROR("Test-%d: Data is different", n); \
+						break; \
+					} \
+				} \
+				if(i==buffer->size){ \
+					TSK_DEBUG_INFO("Test-%d: OK", n); \
+				} \
+			} \
+		} \
+		else{ \
+			TSK_DEBUG_ERROR("Failed to serialize packet-%d", n); \
+		} \
+		\
+		TSK_OBJECT_SAFE_FREE(buffer); \
+		TSK_OBJECT_SAFE_FREE(packet); \
+	} \
+	else{ \
+		TSK_DEBUG_ERROR("Failed to deserialize packet-%d", n); \
+	}
+
+void test_parser()
+{
+	trtp_rtp_packet_t* packet;
+	tsk_buffer_t* buffer;
+	tsk_size_t i;
+
+	MAKE_TEST(0);
+	MAKE_TEST(1);
+	MAKE_TEST(2);
+	MAKE_TEST(3);
+	MAKE_TEST(4);
+	MAKE_TEST(5);
+	MAKE_TEST(6);
+	MAKE_TEST(7);
+	MAKE_TEST(8);
+	MAKE_TEST(9);
+	MAKE_TEST(10);	
+}
+
+
+#endif /* _TEST_PARSER_H_ */
diff --git a/tinyRTP/tinyRTP.pc.in b/tinyRTP/tinyRTP.pc.in
new file mode 100644
index 0000000..621003d
--- /dev/null
+++ b/tinyRTP/tinyRTP.pc.in
@@ -0,0 +1,14 @@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+libdir = @libdir@
+includedir = @includedir@
+
+Name : libtinyRTP
+Description : Doubango Telecom tinyRTP ((S)RTP/(S)RTCP protocols) library
+Version : @PACKAGE_VERSION@
+Requires: 
+Requires.private: tinySAK = @PACKAGE_VERSION@ tinyNET = @PACKAGE_VERSION@ tinyMEDIA = @PACKAGE_VERSION@
+Conflicts:
+Cflags : -I${includedir}/tinyrtp
+Libs : -L${libdir} -ltinyRTP
+Libs.private: 
diff --git a/tinyRTP/tinyRTP.sln b/tinyRTP/tinyRTP.sln
new file mode 100644
index 0000000..ec6e279
--- /dev/null
+++ b/tinyRTP/tinyRTP.sln
@@ -0,0 +1,92 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tinyRTP", "tinyRTP.vcproj", "{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tinySAK", "..\tinySAK\tinySAK.vcproj", "{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tinyNET", "..\tinyNET\tinyNET.vcproj", "{7522A458-92F4-4259-B906-E84C2A65D9F1}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test", "test\test.vcproj", "{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I) = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		Release|Win32 = Release|Win32
+		Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I) = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		Static_Debug|Win32 = Static_Debug|Win32
+		Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I) = Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		Static_Release|Win32 = Static_Release|Win32
+		Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I) = Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Debug|Win32.ActiveCfg = Debug|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Debug|Win32.Build.0 = Debug|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Debug|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Release|Win32.ActiveCfg = Release|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Release|Win32.Build.0 = Release|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Release|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Static_Debug|Win32.ActiveCfg = Debug|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Static_Debug|Win32.Build.0 = Debug|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Debug|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Static_Release|Win32.ActiveCfg = Release|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Static_Release|Win32.Build.0 = Release|Win32
+		{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Release|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Debug|Win32.Build.0 = Debug|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Release|Win32.ActiveCfg = Release|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Release|Win32.Build.0 = Release|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Debug|Win32.ActiveCfg = Static_Debug|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Debug|Win32.Build.0 = Static_Debug|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Release|Win32.ActiveCfg = Static_Release|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Release|Win32.Build.0 = Static_Release|Win32
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{6BC9B796-10C6-4CF7-A6E4-E2DACCDA84DA}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Debug|Win32.Build.0 = Debug|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Release|Win32.ActiveCfg = Release|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Release|Win32.Build.0 = Release|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Debug|Win32.ActiveCfg = Debug|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Debug|Win32.Build.0 = Debug|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Release|Win32.ActiveCfg = Release|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Release|Win32.Build.0 = Release|Win32
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Build.0 = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{7522A458-92F4-4259-B906-E84C2A65D9F1}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).Deploy.0 = Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I)
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Debug|Win32.Build.0 = Debug|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Debug|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Release|Win32.ActiveCfg = Release|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Release|Win32.Build.0 = Release|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Release|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Static_Debug|Win32.ActiveCfg = Debug|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Static_Debug|Win32.Build.0 = Debug|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Static_Debug|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Debug|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Static_Release|Win32.ActiveCfg = Release|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Static_Release|Win32.Build.0 = Release|Win32
+		{A6C1CDCE-63E1-4B60-AC4C-EF0410ED4432}.Static_Release|Windows Mobile 5.0 Pocket PC SDK (ARMV4I).ActiveCfg = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/tinyRTP/tinyRTP.vcproj b/tinyRTP/tinyRTP.vcproj
new file mode 100644
index 0000000..794128b
--- /dev/null
+++ b/tinyRTP/tinyRTP.vcproj
@@ -0,0 +1,384 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tinyRTP"
+	ProjectGUID="{99B7D02F-8C70-4B45-AF3C-92313C3CEE15}"
+	RootNamespace="tinyRTP"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="include;..\tinySAK\src;..\tinyNET\src;..\tinyMEDIA\include;..\thirdparties\win32\include"
+				PreprocessorDefinitions="DEBUG_LEVEL=DEBUG_LEVEL_INFO;HAVE_SRTP=1;WIN32;_DEBUG;_WINDOWS;_USRDLL;TINYRTP_EXPORTS"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				WarnAsError="true"
+				DebugInformationFormat="4"
+				CompileAs="1"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="ws2_32.lib $(OutDir)\tinySAK.lib $(OutDir)\tinyNET.lib $(OutDir)\tinyMEDIA.lib &quot;..\thirdparties\win32\lib\srtp\libsrtp.a&quot; ..\thirdparties\win32\lib\libgcc.a"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="..\thirdparties\win32\include;include;..\tinySAK\src;..\tinyNET\src;..\tinyMEDIA\include"
+				PreprocessorDefinitions="HAVE_SRTP=1;WIN32;NDEBUG;_WINDOWS;_USRDLL;TINYRTP_EXPORTS"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				WarnAsError="true"
+				DebugInformationFormat="0"
+				CompileAs="1"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="ws2_32.lib $(OutDir)\tinySAK.lib $(OutDir)\tinyNET.lib $(OutDir)\tinyMEDIA.lib &quot;..\thirdparties\win32\lib\srtp\libsrtp.a&quot; &quot;..\thirdparties\win32\lib\libgcc.a&quot;"
+				LinkIncremental="1"
+				IgnoreDefaultLibraryNames="MSVCRTD"
+				GenerateDebugInformation="false"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="source(*.c)"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\src\trtp.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\trtp_manager.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\trtp_srtp.c"
+				>
+			</File>
+			<Filter
+				Name="rtp"
+				>
+				<File
+					RelativePath=".\src\rtp\trtp_rtp_header.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtp\trtp_rtp_packet.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtp\trtp_rtp_session.c"
+					>
+				</File>
+			</Filter>
+			<Filter
+				Name="rtcp"
+				>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_header.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_packet.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_rblock.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_report.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_report_bye.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_report_fb.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_report_rr.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_report_sdes.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_report_sr.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_report_xr.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_sdes_chunck.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_sdes_item.c"
+					>
+				</File>
+				<File
+					RelativePath=".\src\rtcp\trtp_rtcp_session.c"
+					>
+				</File>
+			</Filter>
+			<Filter
+				Name="rtsp"
+				>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="include(*.h)"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\include\tinyrtp.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\tinyrtp_config.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\tinyrtp\trtp.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\tinyrtp\trtp_manager.h"
+				>
+			</File>
+			<File
+				RelativePath=".\include\tinyrtp\trtp_srtp.h"
+				>
+			</File>
+			<Filter
+				Name="rtp"
+				>
+				<File
+					RelativePath=".\include\tinyrtp\rtp\trtp_rtp_header.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtp\trtp_rtp_packet.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtp\trtp_rtp_session.h"
+					>
+				</File>
+			</Filter>
+			<Filter
+				Name="rtcp"
+				>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_header.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_packet.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_rblock.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_report.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_report_bye.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_report_fb.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_report_rr.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_report_sdes.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_report_sr.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_report_xr.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_sdes_chunck.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_sdes_item.h"
+					>
+				</File>
+				<File
+					RelativePath=".\include\tinyrtp\rtcp\trtp_rtcp_session.h"
+					>
+				</File>
+			</Filter>
+			<Filter
+				Name="rtsp"
+				>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="resources(*.rc)"
+			>
+			<File
+				RelativePath=".\version.rc"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/tinyRTP/version.rc b/tinyRTP/version.rc
new file mode 100644
index 0000000..9592d2e
--- /dev/null
+++ b/tinyRTP/version.rc
@@ -0,0 +1,102 @@
+// Microsoft Visual C++ generated resource script.
+//
+// #include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 2.0.0.1156
+ PRODUCTVERSION 2.0.0.1156
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "Doubango telecom"
+            VALUE "FileDescription", "Doubango IMS Framework"
+            VALUE "FileVersion", "2.0.0.1156"
+            VALUE "InternalName", "tinyrtp.dll"
+            VALUE "LegalCopyright", "(c) 2010-2013 Doubango Telecom.  All rights reserved."
+            VALUE "OriginalFilename", "tinyrtp.dll"
+            VALUE "ProductName", "Doubango IMS Framework"
+            VALUE "ProductVersion", "2.0.0.1156"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+