huangxiyun
/
ZLKMedia
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
1 提交
1 分支
21MB
分支: master
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 'master'
${ noResults }
ZLKMedia/3rdpart/media-server/librtp/source/rtcp-rtpfb.c

1187 行
42KB
原始文件 永久链接 Blame 文件历史 

  1. #include "rtp-internal.h"

  2. #include "rtp-util.h"

  3. #include <errno.h>

  4. 

  5. #define TCC01_CLOCK_RESOLUTION 250 // us

  6. 

  7. static int rtcp_rtpfb_nack_pack(const rtcp_nack_t* nack, int count, uint8_t* ptr, uint32_t bytes);

  8. static int rtcp_rtpfb_tmmbr_pack(const rtcp_tmmbr_t* tmmbr, int count, uint8_t* ptr, uint32_t bytes);

  9. static int rtcp_rtpfb_tmmbn_pack(const rtcp_tmmbr_t* tmmbr, int count, uint8_t* ptr, uint32_t bytes);

  10. static int rtcp_rtpfb_tllei_pack(const rtcp_nack_t* nack, int count, uint8_t* ptr, uint32_t bytes);

  11. static int rtcp_rtpfb_ecn_pack(const rtcp_ecn_t* ecn, uint8_t* ptr, uint32_t bytes);

  12. static int rtcp_rtpfb_ps_pack(uint32_t target, uint8_t cmd, uint8_t len, uint16_t id, const uint8_t* payload, uint8_t* ptr, uint32_t bytes);

  13. static int rtcp_rtpfb_ccfb_pack(uint32_t ssrc, uint16_t begin, const rtcp_ccfb_t* ccfb, int count, uint32_t timestamp, uint8_t* ptr, uint32_t bytes);

  14. static int rtcp_rtpfb_tcc01_pack(uint16_t begin, const rtcp_ccfb_t* ccfb, int count, uint32_t timestamp, uint8_t cc, uint8_t* ptr, uint32_t bytes);

  15. 

  16. static int rtcp_rtpfb_nack_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  17. static int rtcp_rtpfb_tmmbr_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  18. static int rtcp_rtpfb_tmmbn_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  19. static int rtcp_rtpfb_srreq_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  20. static int rtcp_rtpfb_rams_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  21. static int rtcp_rtpfb_tllei_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  22. static int rtcp_rtpfb_ecn_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  23. static int rtcp_rtpfb_ps_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  24. static int rtcp_rtpfb_dbi_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  25. static int rtcp_rtpfb_ccfb_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  26. static int rtcp_rtpfb_tcc01_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  27. 

  28. // https://datatracker.ietf.org/doc/html/rfc4585#section-6.2.1

  29. /*

  30. 	0                   1                   2                   3

  31. 	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

  32.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  33.    |            PID                |             BLP               |

  34.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  35. */

  36. static int rtcp_rtpfb_nack_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  37. {

  38. 	uint32_t i;

  39. 	rtcp_nack_t* nack, nack0[32];

  40. 

  41. 	if (bytes / 4 > sizeof(nack0) / sizeof(nack0[0]))

  42. 	{

  43. 		nack = calloc(bytes / 4, sizeof(*nack));

  44. 		if (!nack) return -ENOMEM;

  45. 	}

  46. 	else

  47. 	{

  48. 		nack = nack0;

  49. 		memset(nack, 0, sizeof(nack[0]) * (bytes / 4));

  50. 	}

  51. 

  52. 	for (i = 0; i < bytes / 4; i++)

  53. 	{

  54. 		nack[i].pid = nbo_r16(ptr);

  55. 		nack[i].blp = nbo_r16(ptr + 2);

  56. 		ptr += 4;

  57. 	}

  58. 

  59. 	msg->u.rtpfb.u.nack.nack = nack;

  60. 	msg->u.rtpfb.u.nack.count = i;

  61. 	ctx->handler.on_rtcp(ctx->cbparam, msg);

  62. 	(void)ctx, (void)header;

  63. 	if (nack && nack != nack0)

  64. 		free(nack);

  65. 	return 0;

  66. }

  67. 

  68. static int rtcp_rtpfb_nack_pack(const rtcp_nack_t* nack, int count, uint8_t* ptr, uint32_t bytes)

  69. {

  70. 	int i;

  71. 	for (i = 0; i < count && bytes >= 4; i++)

  72. 	{

  73. 		nbo_w16(ptr, nack[i].pid);

  74. 		nbo_w16(ptr+2, nack[i].blp);

  75. 		

  76. 		bytes -= 4;

  77. 		ptr += 4;

  78. 	}

  79. 	return i * 4;

  80. }

  81. 

  82. // https://www.rfc-editor.org/rfc/rfc5104.html#section-4.2.1

  83. /*

  84. 	0                   1                   2                   3

  85. 	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

  86.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  87.    |                              SSRC                             |

  88.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  89.    | MxTBR Exp |  MxTBR Mantissa                 |Measured Overhead|

  90.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  91. */

  92. static int rtcp_rtpfb_tmmbr_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  93. {

  94. 	uint32_t i;

  95. 	rtcp_tmmbr_t* tmmbr, tmmbr0[4];

  96. 

  97. 	if (bytes / 8 > sizeof(tmmbr0) / sizeof(tmmbr0[0]))

  98. 	{

  99. 		tmmbr = calloc(bytes / 8, sizeof(*tmmbr));

  100. 		if (!tmmbr) return -ENOMEM;

  101. 	}

  102. 	else

  103. 	{

  104. 		tmmbr = tmmbr0;

  105. 		memset(tmmbr, 0, sizeof(tmmbr[0]) * (bytes / 8));

  106. 	}

  107. 

  108. 	for (i = 0; i < bytes / 8; i++)

  109. 	{

  110. 		tmmbr[i].ssrc = nbo_r32(ptr);

  111. 		tmmbr[i].exp = (ptr[4] >> 2) & 0x3F;

  112. 		tmmbr[i].mantissa = ((ptr[4] & 0x03) << 15) | (ptr[5] << 7) | ((ptr[6] >> 1) & 0x7F);

  113. 		tmmbr[i].overhead = ((ptr[6] & 0x01) << 8) | ptr[7];

  114. 		ptr += 8;

  115. 	}

  116. 

  117. 	msg->u.rtpfb.u.tmmbr.tmmbr = tmmbr;

  118. 	msg->u.rtpfb.u.tmmbr.count = i;

  119. 	ctx->handler.on_rtcp(ctx->cbparam, msg);

  120. 	(void)ctx, (void)header;

  121. 	if (tmmbr && tmmbr != tmmbr0)

  122. 		free(tmmbr);

  123. 	return 0;

  124. }

  125. 

  126. static int rtcp_rtpfb_tmmbr_pack(const rtcp_tmmbr_t* tmmbr, int count, uint8_t* ptr, uint32_t bytes)

  127. {

  128. 	int i;

  129. 	for (i = 0; i < count && bytes >= 8; i++)

  130. 	{

  131. 		nbo_w32(ptr, tmmbr[i].ssrc);

  132. 		nbo_w32(ptr + 4, ((tmmbr[i].exp & 0x3F) << 26) | ((tmmbr[i].mantissa & 0x1FFFF) << 9) | (tmmbr[i].overhead & 0x1FF));

  133. 

  134. 		bytes -= 8;

  135. 		ptr += 8;

  136. 	}

  137. 	return i * 8;

  138. }

  139. 

  140. // https://www.rfc-editor.org/rfc/rfc5104.html#section-4.2.2

  141. static int rtcp_rtpfb_tmmbn_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  142. {

  143. 	uint32_t i;

  144. 	rtcp_tmmbr_t* tmmbr, tmmbr0[4];

  145. 

  146. 	if (bytes / 8 > sizeof(tmmbr0) / sizeof(tmmbr0[0]))

  147. 	{

  148. 		tmmbr = calloc(bytes / 8, sizeof(*tmmbr));

  149. 		if (!tmmbr) return -ENOMEM;

  150. 	}

  151. 	else

  152. 	{

  153. 		tmmbr = tmmbr0;

  154. 		memset(tmmbr, 0, sizeof(tmmbr[0]) * (bytes / 8));

  155. 	}

  156. 

  157. 	for (i = 0; i < bytes / 8; i++)

  158. 	{

  159. 		tmmbr[i].ssrc = nbo_r32(ptr);

  160. 		tmmbr[i].exp = (ptr[4] >> 2) & 0x3F;

  161. 		tmmbr[i].mantissa = ((ptr[4] & 0x03) << 15) | (ptr[5] << 7) | ((ptr[6] >> 1) & 0x7F);

  162. 		tmmbr[i].overhead = ((ptr[6] & 0x01) << 8) | ptr[7];

  163. 		ptr += 8;

  164. 	}

  165. 

  166. 	msg->u.rtpfb.u.tmmbr.tmmbr = tmmbr;

  167. 	msg->u.rtpfb.u.tmmbr.count = i;

  168. 	ctx->handler.on_rtcp(ctx->cbparam, msg);

  169. 	(void)ctx, (void)header;

  170. 	if (tmmbr && tmmbr != tmmbr0)

  171. 		free(tmmbr);

  172. 	return 0;

  173. }

  174. 

  175. static int rtcp_rtpfb_tmmbn_pack(const rtcp_tmmbr_t* tmmbr, int count, uint8_t* ptr, uint32_t bytes)

  176. {

  177. 	return rtcp_rtpfb_tmmbr_pack(tmmbr, count, ptr, bytes);

  178. }

  179. 

  180. // https://www.rfc-editor.org/rfc/rfc6051.html#section-3.2

  181. static int rtcp_rtpfb_srreq_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  182. {

  183. 	// The SSRC of the packet sender indicates the member that is unable to synchronise media streams, 

  184. 	// while the SSRC of the media source indicates the sender of the media it is unable to synchronise.

  185. 	// The length MUST equal 2.

  186. 	assert(bytes == 0);

  187. 	(void)ctx, (void)header, (void)msg, (void)ptr;

  188. 	return 0;

  189. }

  190. 

  191. // https://www.rfc-editor.org/rfc/rfc6285.html#section-7

  192. /*

  193. 	  0                   1                   2                   3

  194. 	  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

  195. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  196. 	 |     Type      |   Reserved    |            Length             |

  197. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  198. 	 :                             Value                             :

  199. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  200. 

  201. 				   Figure 5: Structure of a TLV Element

  202. 

  203. 	  0                   1                   2                   3

  204. 	  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

  205. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  206. 	 |    SFMT=1     |                    Reserved                   |

  207. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  208. 	 :                  Requested Media Sender SSRC(s)               :

  209. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  210. 	 :      Optional TLV-encoded Fields (and Padding, if needed)     :

  211. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  212. 

  213. 		  Figure 7: FCI Field Syntax for the RAMS Request Message

  214. 

  215. 	  0                   1                   2                   3

  216. 	  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

  217. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  218. 	 |    SFMT=2     |      MSN      |          Response             |

  219. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  220. 	 :      Optional TLV-encoded Fields (and Padding, if needed)     :

  221. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  222. 

  223. 		Figure 8: FCI Field Syntax for the RAMS Information Message

  224. */

  225. static int rtcp_rtpfb_rams_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  226. {

  227. 	uint8_t sfmt;

  228. 	if (bytes < 4)

  229. 		return -1;

  230. 	sfmt = ptr[0];

  231. 	(void)ctx, (void)header, (void)msg;

  232. 	return 0;

  233. }

  234. 

  235. // https://www.rfc-editor.org/rfc/rfc6642.html#section-5.1

  236. /*

  237. 	   0                   1                   2                   3

  238. 	   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

  239. 	  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  240. 	  |            PID                |             BLP               |

  241. 	  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  242. */

  243. static int rtcp_rtpfb_tllei_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  244. {

  245. 	uint32_t i;

  246. 	rtcp_nack_t* nack, nack0[32];

  247. 

  248. 	if (bytes / 4 > sizeof(nack0) / sizeof(nack0[0]))

  249. 	{

  250. 		nack = calloc(bytes / 4, sizeof(*nack));

  251. 		if (!nack) return -ENOMEM;

  252. 	}

  253. 	else

  254. 	{

  255. 		nack = nack0;

  256. 		memset(nack, 0, sizeof(nack[0]) * (bytes / 4));

  257. 	}

  258. 

  259. 	for (i = 0; i < bytes / 4; i++)

  260. 	{

  261. 		nack[i].pid = nbo_r16(ptr);

  262. 		nack[i].blp = nbo_r16(ptr + 2);

  263. 		ptr += 4;

  264. 	}

  265. 

  266. 	msg->u.rtpfb.u.nack.nack = nack;

  267. 	msg->u.rtpfb.u.nack.count = i;

  268. 	ctx->handler.on_rtcp(ctx->cbparam, msg);

  269. 	(void)ctx, (void)header;

  270. 	if (nack && nack != nack0)

  271. 		free(nack);

  272. 	return 0;

  273. }

  274. 

  275. static int rtcp_rtpfb_tllei_pack(const rtcp_nack_t* nack, int count, uint8_t* ptr, uint32_t bytes)

  276. {

  277. 	return rtcp_rtpfb_nack_pack(nack, count, ptr, bytes);

  278. }

  279. 

  280. // https://www.rfc-editor.org/rfc/rfc6679.html#section-5.1

  281. /*

  282. 	0                   1                   2                   3

  283. 	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

  284.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  285.    | Extended Highest Sequence Number                              |

  286.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  287.    | ECT (0) Counter                                               |

  288.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  289.    | ECT (1) Counter                                               |

  290.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  291.    | ECN-CE Counter                | not-ECT Counter               |

  292.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  293.    | Lost Packets Counter          | Duplication Counter           |

  294.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  295. */

  296. static int rtcp_rtpfb_ecn_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  297. {

  298. 	rtcp_ecn_t ecn;

  299. 	if (bytes < 20)

  300. 		return -1;

  301. 	ecn.ext_highest_seq = nbo_r32(ptr);

  302. 	ecn.ect[0] = nbo_r32(ptr + 4);

  303. 	ecn.ect[1] = nbo_r32(ptr + 8);

  304. 	ecn.ect_ce_counter = nbo_r16(ptr + 12);

  305. 	ecn.not_ect_counter = nbo_r16(ptr + 14);

  306. 	ecn.lost_packets_counter = nbo_r16(ptr + 16);

  307. 	ecn.duplication_counter = nbo_r16(ptr + 18);

  308. 

  309. 	memcpy(&msg->u.rtpfb.u.ecn, &ecn, sizeof(ecn));

  310. 	ctx->handler.on_rtcp(ctx->cbparam, msg);

  311. 	(void)ctx, (void)header;

  312. 	return 0;

  313. }

  314. 

  315. static int rtcp_rtpfb_ecn_pack(const rtcp_ecn_t* ecn, uint8_t* ptr, uint32_t bytes)

  316. {

  317. 	if (bytes < 20)

  318. 		return -1;

  319. 

  320. 	nbo_w32(ptr, ecn->ext_highest_seq);

  321. 	nbo_w32(ptr + 4, ecn->ect[0]);

  322. 	nbo_w32(ptr + 8, ecn->ect[1]);

  323. 	nbo_w16(ptr + 12, ecn->ect_ce_counter);

  324. 	nbo_w16(ptr + 14, ecn->not_ect_counter);

  325. 	nbo_w16(ptr + 16, ecn->lost_packets_counter);

  326. 	nbo_w16(ptr + 18, ecn->duplication_counter);

  327. 	return 20;

  328. }

  329. 

  330. // https://www.rfc-editor.org/rfc/rfc7728.html#section-7

  331. /*

  332. 	  0                   1                   2                   3

  333. 	  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

  334. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  335. 	 |                           Target SSRC                         |

  336. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  337. 	 | Type  |  Res  | Parameter Len |           PauseID             |

  338. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  339. 	 :                         Type Specific                         :

  340. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  341. */

  342. static int rtcp_rtpfb_ps_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  343. {

  344. 	uint16_t id;

  345. 	uint32_t target;

  346. 	uint8_t cmd;

  347. 	uint32_t len;

  348. 

  349. 	while(bytes >= 8)

  350. 	{

  351. 		target = nbo_r32(ptr); // target ssrc

  352. 		cmd = ptr[4] >> 4;

  353. 		len = ptr[5];

  354. 		id = nbo_r16(ptr + 6);

  355. 

  356. 		if (len * 4 + 8 > bytes)

  357. 		{

  358. 			assert(0);

  359. 			return -1;

  360. 		}

  361. 

  362. 		msg->u.rtpfb.u.ps.target = target;

  363. 		msg->u.rtpfb.u.ps.cmd = cmd;

  364. 		msg->u.rtpfb.u.ps.len = len;

  365. 		msg->u.rtpfb.u.ps.id = id;

  366. 		msg->u.rtpfb.u.ps.payload = (uint8_t*)ptr + 8;

  367. 		ctx->handler.on_rtcp(ctx->cbparam, msg);

  368. 

  369. 		ptr += 8 + len * 4;

  370. 		bytes -= 8 + len * 4;

  371. 	}

  372. 

  373. 	(void)ctx, (void)header;

  374. 	return 0;

  375. }

  376. 

  377. static int rtcp_rtpfb_ps_pack(uint32_t target, uint8_t cmd, uint8_t len, uint16_t id, const uint8_t* payload, uint8_t* ptr, uint32_t bytes)

  378. {

  379. 	if (bytes < 8 + (uint32_t)len * 4)

  380. 		return -1;

  381. 

  382. 	nbo_w32(ptr, target);

  383. 	nbo_w32(ptr + 4, ((cmd & 0x0F) << 28) | ((len & 0xFF) << 16) | id);

  384. 	if (len > 0)

  385. 		memcpy(ptr + 8, payload, len * 4);

  386. 	return 8 + len * 4;

  387. }

  388. 

  389. // https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=1404

  390. /*

  391.  0                1                   2                   3

  392.  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

  393. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  394. |            delay              |s|q|     zero padding          |

  395. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  396. */

  397. static int rtcp_rtpfb_dbi_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  398. {

  399. 	if (bytes < 4)

  400. 		return -1;

  401. 

  402. 	msg->u.rtpfb.u.dbi.delay = nbo_r16(ptr);

  403. 	msg->u.rtpfb.u.dbi.s = (ptr[2] >> 7) & 0x01;

  404. 	msg->u.rtpfb.u.dbi.q = (ptr[2] >> 6) & 0x01;

  405. 	ctx->handler.on_rtcp(ctx->cbparam, msg);

  406. 	(void)ctx, (void)header, (void)ptr;

  407. 	return 0;

  408. }

  409. 

  410. // https://www.rfc-editor.org/rfc/rfc8888.html#section-3.1

  411. /*

  412.    0                   1                   2                   3

  413.    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

  414.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  415.   |V=2|P| FMT=11  |   PT = 205    |          length               |

  416.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  417.   |                 SSRC of RTCP packet sender                    |

  418.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  419.   |                   SSRC of 1st RTP Stream                      |

  420.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  421.   |          begin_seq            |          num_reports          |

  422.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  423.   |R|ECN|  Arrival time offset    | ...                           .

  424.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  425.   .                                                               .

  426.   .                                                               .

  427.   .                                                               .

  428.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  429.   |                   SSRC of nth RTP Stream                      |

  430.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  431.   |          begin_seq            |          num_reports          |

  432.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  433.   |R|ECN|  Arrival time offset    | ...                           |

  434.   .                                                               .

  435.   .                                                               .

  436.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  437.   |                 Report Timestamp (32 bits)                    |

  438.   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  439. */

  440. static int rtcp_rtpfb_ccfb_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  441. {

  442. 	uint32_t i, num, ssrc;

  443. 	uint32_t timestamp;

  444. 	uint16_t begin;

  445. 	rtcp_ccfb_t* ccfb, ccfb0[32];

  446. 

  447. 	timestamp = bytes >= 4 ? nbo_r32(ptr + bytes - 4) : 0; // get last report timestamp

  448. 

  449. 	while(bytes >= 8)

  450. 	{

  451. 		ssrc = nbo_r32(ptr); // target ssrc

  452. 		begin = nbo_r16(ptr + 4);

  453. 		num = nbo_r16(ptr + 6);

  454. 

  455. 		ptr += 8;

  456. 		bytes -= 8;

  457. 		if ( (num * 2 + 3) / 4 * 4 > bytes) // 4-bytes padding

  458. 		{

  459. 			assert(0);

  460. 			return -1;

  461. 		}

  462. 

  463. 		if (num > sizeof(ccfb0) / sizeof(ccfb0[0]))

  464. 		{

  465. 			ccfb = calloc(num, sizeof(*ccfb));

  466. 			if (!ccfb) return -ENOMEM;

  467. 		}

  468. 		else

  469. 		{

  470. 			ccfb = ccfb0;

  471. 			memset(ccfb, 0, sizeof(ccfb[0]) * num);

  472. 		}

  473. 

  474. 		for (i = 0; i < num; i++)

  475. 		{

  476. 			ccfb[i].seq = begin + i;

  477. 			ccfb[i].received = (ptr[i * 2] >> 7) & 0x01;

  478. 			ccfb[i].ecn = (ptr[i * 2] >> 5) & 0x03;

  479. 			ccfb[i].ato = ((ptr[i * 2] & 0x1F) << 8) | ptr[i * 2 + 1];

  480. 		}

  481. 

  482. 		msg->u.rtpfb.u.tcc01.timestamp = 0; // fixme

  483. 		msg->u.rtpfb.u.tcc01.ssrc = ssrc;

  484. 		msg->u.rtpfb.u.tcc01.begin = begin;

  485. 		msg->u.rtpfb.u.tcc01.ccfb = ccfb;

  486. 		msg->u.rtpfb.u.tcc01.count = i;

  487. 		ctx->handler.on_rtcp(ctx->cbparam, msg);

  488. 

  489. 		num = (num + 1) / 2 * 2; // 4-bytes padding

  490. 		assert(bytes >= num * 2); // check again

  491. 		ptr += num * 2;

  492. 		bytes -= num * 2;

  493. 

  494. 		if (ccfb && ccfb != ccfb0)

  495. 			free(ccfb);

  496. 	}

  497. 

  498. 	if (bytes >= 4)

  499. 	{

  500. 		timestamp = nbo_r32(ptr);

  501. 		ptr += 4;

  502. 		bytes -= 4;

  503. 	}

  504. 

  505. 	(void)ctx, (void)header;

  506. 	assert(0 == bytes);

  507. 	return 0;

  508. }

  509. 

  510. static int rtcp_rtpfb_ccfb_pack(uint32_t ssrc, uint16_t begin, const rtcp_ccfb_t* ccfb, int count, uint32_t timestamp, uint8_t* ptr, uint32_t bytes)

  511. {

  512. 	int i;

  513. 	if (bytes < 8 + (uint32_t)count * 2 + 4 || count > 0xFFFF)

  514. 		return -1;

  515. 

  516. 	nbo_w32(ptr, ssrc);

  517. 	nbo_w16(ptr + 4, begin);

  518. 	nbo_w16(ptr + 6, (uint16_t)count);

  519. 	ptr += 8;

  520. 

  521. 	for (i = 0; i < count; i++)

  522. 	{

  523. 		nbo_w16(ptr, (ccfb[i].received ? 0x8000 : 0) | ((ccfb[i].ecn & 0x03) << 13) | (ccfb->ato & 0x1FFF));

  524. 		bytes -= 2;

  525. 		ptr += 2;

  526. 	}

  527. 

  528. 	nbo_w32(ptr, timestamp);

  529. 	return 8 + count * 2 + 4;

  530. }

  531. 

  532. // https://datatracker.ietf.org/doc/html/draft-holmer-rmcat-transport-wide-cc-extensions-00#section-3.1

  533. /*

  534. 	 0                   1                   2                   3

  535. 	  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

  536. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  537. 	 | fb seq num                  |r|       base sequence number    |

  538. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  539. 	 |       base receive time       |  sequence number ack vector   |

  540. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  541. 	 | recv delta        | recv delta        | recv delta        |...|

  542. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  543. 	 .                                                               .

  544. 	 .                                                               .

  545. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  546. 	 | recovery base sequence number |  recovery vector              |

  547. 	 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  548. */

  549. 

  550. // https://datatracker.ietf.org/doc/html/draft-holmer-rmcat-transport-wide-cc-extensions#section-3.1

  551. /*

  552.         0                   1                   2                   3

  553.         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

  554.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  555.        |V=2|P|  FMT=15 |    PT=205     |           length              |

  556.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  557.        |                     SSRC of packet sender                     |

  558.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  559.        |                      SSRC of media source                     |

  560.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  561.        |      base sequence number     |      packet status count      |

  562.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  563.        |                 reference time                | fb pkt. count |

  564.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  565.        |          packet chunk         |         packet chunk          |

  566.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  567.        .                                                               .

  568.        .                                                               .

  569.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  570.        |         packet chunk          |  recv delta   |  recv delta   |

  571.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  572.        .                                                               .

  573.        .                                                               .

  574.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  575.        |           recv delta          |  recv delta   | zero padding  |

  576.        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  577. */

  578. static int rtcp_rtpfb_tcc01_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes)

  579. {

  580. 	int r;

  581. 	uint16_t i, j;

  582. 	uint32_t timestamp;

  583. 	uint16_t seq, num, chunk;

  584. 	uint8_t cc;

  585. 	rtcp_ccfb_t* ccfb, ccfb0[32];

  586. 

  587. 	if (bytes < 8)

  588. 		return -1;

  589. 	seq = nbo_r16(ptr);

  590. 	num = nbo_r16(ptr + 2);

  591. 	timestamp = (ptr[4] << 16) | (ptr[5] << 8) | ptr[6];

  592. 	cc = ptr[7];

  593. 	msg->u.rtpfb.u.tcc01.cc = cc;

  594. 	msg->u.rtpfb.u.tcc01.begin = seq;

  595. 	msg->u.rtpfb.u.tcc01.timestamp = timestamp | ((timestamp & 0x00800000) ? 0xFF000000 : 0); // signed-24 -> signed-32

  596. 

  597. 	if (num > sizeof(ccfb0) / sizeof(ccfb0[0]))

  598. 	{

  599. 		ccfb = calloc(num, sizeof(*ccfb));

  600. 		if (!ccfb) return -ENOMEM;

  601. 	}

  602. 	else

  603. 	{

  604. 		ccfb = ccfb0;

  605. 		memset(ccfb, 0, sizeof(ccfb[0]) * num);

  606. 	}

  607. 

  608. 	r = 0;

  609. 	ptr += 8;

  610. 	bytes -= 8;

  611. 	for (i = 0; bytes >= 2 && i < num; bytes -= 2, ptr += 2)

  612. 	{

  613. 		chunk = nbo_r16(ptr); // packet chunk

  614. 

  615. 		if (0 == (0x8000 & chunk))

  616. 		{

  617. 			// Run Length Chunk

  618. 			for (j = 0; j < (chunk & 0x1FFF) && i < num; j++, i++)

  619. 			{

  620. 				ccfb[i].seq = seq++;

  621. 				ccfb[i].ecn = (chunk >> 13) & 0x03;

  622. 				ccfb[i].received = ccfb[i].ecn ? 1 : 0;

  623. 				ccfb[i].ato = 0;

  624. 			}

  625. 		}

  626. 		else

  627. 		{

  628. 			// Status Vector Chunk

  629. 			if (0x4000 & chunk)

  630. 			{

  631. 				// two bits

  632. 				for (j = 0; j < 7 && i < num; j++, i++)

  633. 				{

  634. 					ccfb[i].seq = seq++;

  635. 					ccfb[i].ecn = (chunk >> (2 * (6 - j))) & 0x03;

  636. 					ccfb[i].received = ccfb[i].ecn ? 1 : 0;

  637. 					ccfb[i].ato = 0;

  638. 				}

  639. 			}

  640. 			else

  641. 			{

  642. 				// one bits

  643. 				for (j = 0; j < 14 && i < num; j++, i++)

  644. 				{

  645. 					ccfb[i].seq = seq++;

  646. 					ccfb[i].ecn = (chunk & (1 << (13 - j))) ? 0x01 : 0x00; // small delta

  647. 					ccfb[i].received = ccfb[i].ecn ? 1 : 0;

  648. 					ccfb[i].ato = 0;

  649. 				}

  650. 			}

  651. 		}

  652. 	}

  653. 

  654. 	for (i = 0; i < num && bytes > 0; i++)

  655. 	{

  656. 		if (!ccfb[i].received)

  657. 			continue;

  658. 

  659. 		assert(ccfb[i].ecn == 0x01 || ccfb[i].ecn == 0x02);

  660. 		if (ccfb[i].ecn == 0x01)

  661. 		{

  662. 			ccfb[i].ato = ptr[0] >> 2; // 250us

  663. 			bytes -= 1;

  664. 			ptr += 1;

  665. 		}

  666. 		else

  667. 		{

  668. 			if (bytes < 2)

  669. 			{

  670. 				assert(0);

  671. 				r = -1;

  672. 				break;

  673. 			}

  674. 			ccfb[i].ato = ((int16_t)nbo_r16(ptr)) >> 2; // 250us -> 1/1024(s)

  675. 			bytes -= 2;

  676. 			ptr += 2;

  677. 		}

  678. 	}

  679. 

  680. 	if (0 == r)

  681. 	{

  682. 		msg->u.rtpfb.u.tcc01.ccfb = ccfb;

  683. 		msg->u.rtpfb.u.tcc01.count = num;

  684. 		ctx->handler.on_rtcp(ctx->cbparam, msg);

  685. 	}

  686. 	(void)ctx, (void)header;

  687. 	if (ccfb && ccfb != ccfb0)

  688. 		free(ccfb);

  689. 	return r;

  690. }

  691. 

  692. static int rtcp_rtpfb_tcc01_pack(uint16_t begin, const rtcp_ccfb_t* ccfb, int count, uint32_t timestamp, uint8_t cc, uint8_t* ptr, uint32_t bytes)

  693. {

  694. 	int i, n;

  695. 	int16_t ato;

  696. 	uint16_t k, chunk, two;

  697. 	uint32_t seq, received;

  698. 	const uint8_t* p;

  699. 	if (bytes < 8 || count < 1)

  700. 		return -1;

  701. 

  702. 	nbo_w16(ptr, begin);

  703. 	nbo_w16(ptr + 2, (uint16_t)count); // placeholder

  704. 	nbo_w32(ptr + 4, ((timestamp & 0xFFFFFF) << 8) | cc);

  705. 	ptr += 8;

  706. 	p = ptr; // chunk pointer

  707. 	n = 8;

  708. 	

  709. 	for (i = 0; i < count && bytes >= 2; i += k)

  710. 	{

  711. 		ato = ccfb[i].ato << 2; // 1/1024(s) -> 250us

  712. 		two = (ccfb[i].received && (uint16_t)ato > 0xFF) ? 2 : 1;

  713. 		received = ccfb[i].received;

  714. 		

  715. 		// try Run Length Chunk

  716. 		for (k = 1; i + k < count && ccfb[i + k].received == ccfb[i].received; k++)

  717. 		{

  718. 			ato = ccfb[i + k].ato << 2; // 1/1024(s) -> 250us

  719. 			two = (ccfb[i + k].received && (uint16_t)ato > 0xFF) ? 2 : two;

  720. 			received |= ccfb[i + k].received;

  721. 		}

  722. 

  723. 		if (k > 14 / two)

  724. 		{

  725. 			// Run Length Chunk

  726. 			chunk = 0x0000 | (received ? (2 == two ? 0x4000 : 0x2000) : 0x0000) | k;

  727. 		}

  728. 		else

  729. 		{

  730. 			two = 1; // re-detect

  731. 			for (k = 0; k < 14 / two && i + k < count; k++)

  732. 			{

  733. 				ato = ccfb[i + k].ato << 2; // 1/1024(s) -> 250us

  734. 				two = (ccfb[i + k].received && (uint16_t)ato > 0xFF) ? 2 : two;

  735. 			}

  736. 

  737. 			ato = (2 == two || k <= 7) ? 1 : 0; // small space/padding

  738. 			chunk = 0x8000 | (ato ? 0x4000 : 0x0000);

  739. 			for (k = 0; k < 14 / two && i + k < count; k++)

  740. 			{

  741. 				if (ccfb[i + k].received)

  742. 				{

  743. 					chunk |= ((uint16_t)(ccfb[i + k].ato << 2) > 0xFF ? 2 : 1) << (ato ? (12 - k * 2) : (13 - k));

  744. 				}

  745. 			}

  746. 		}

  747. 

  748. 		nbo_w16(ptr, chunk);

  749. 		bytes -= 2;

  750. 		ptr += 2;

  751. 		n += 2;

  752. 	}

  753. 

  754. 	// parse chunk and write delta

  755. 	for (i = 0; i < count && bytes >= 1; p += 2)

  756. 	{

  757. 		chunk = nbo_r16(p); // packet chunk

  758. 

  759. 		if (0 == (0x8000 & chunk))

  760. 		{

  761. 			// Run Length Chunk

  762. 			seq = ccfb[i].seq;

  763. 			for (k = 0; k < (chunk & 0x1FFF) && i < count; k++)

  764. 			{

  765. 				assert(seq + k == ccfb[i].seq);

  766. 				if (seq + k != ccfb[i].seq)

  767. 					continue;

  768. 

  769. 				ato = ccfb[i].ato << 2; // 1/1024(s) -> 250us

  770. 				if (chunk & 0x4000)

  771. 				{

  772. 					if (bytes < 2)

  773. 						return -1;

  774. 					nbo_w16(ptr, ato);

  775. 					bytes -= 2;

  776. 					ptr += 2;

  777. 					n += 2;

  778. 				}				

  779. 				else if (chunk & 0x2000)

  780. 				{

  781. 					if (bytes < 1)

  782. 						return -1;

  783. 					ptr[0] = (uint8_t)ato;

  784. 					bytes -= 1;

  785. 					ptr += 1;

  786. 					n += 1;

  787. 				}

  788. 

  789. 				i++;

  790. 			}

  791. 		}

  792. 		else

  793. 		{

  794. 			// Status Vector Chunk

  795. 			if (0x4000 & chunk)

  796. 			{

  797. 				// two bits

  798. 				for (k = 0; k < 7 && i < count && bytes >= 2; k++, i++)

  799. 				{

  800. 					if (!ccfb[i].received)

  801. 						continue;

  802. 

  803. 					ato = ccfb[i].ato << 2; // 1/1024(s) -> 250us

  804. 					two = (chunk >> (2 * (6 - k))) & 0x03;

  805. 					if (two == 1)

  806. 					{

  807. 						ptr[0] = (uint8_t)ato;

  808. 						bytes -= 1;

  809. 						ptr += 1;

  810. 						n += 1;

  811. 					}

  812. 					else

  813. 					{

  814. 						nbo_w16(ptr, ato);

  815. 						bytes -= 2;

  816. 						ptr += 2;

  817. 						n += 2;

  818. 					}

  819. 				}

  820. 			}

  821. 			else

  822. 			{

  823. 				// one bits

  824. 				for (k = 0; k < 14 && i < count && bytes >= 1; k++, i++)

  825. 				{

  826. 					if (!ccfb[i].received)

  827. 						continue;

  828. 

  829. 					ato = ccfb[i].ato << 2; // 1/1024(s) -> 250us

  830. 					ptr[0] = (uint8_t)ato;

  831. 					bytes -= 1;

  832. 					ptr += 1;

  833. 					n += 1;

  834. 				}

  835. 			}

  836. 		}

  837. 	}

  838. 

  839. 	// padding

  840. 	for(k = 0; k < 4 && (n % 4 != 0) && bytes > 0; k++)

  841. 	{

  842. 		ptr[0] = ((n + 1) % 4 == 0) ? (uint8_t)k + 1 : 0;

  843. 		bytes -= 1;

  844. 		ptr += 1;

  845. 		n += 1;

  846. 	}

  847. 	return n;

  848. }

  849. 

  850. // https://datatracker.ietf.org/doc/html/rfc4585#section-6.2

  851. /*

  852. *  Common Packet Format for Feedback Messages

  853. 

  854. 	0                   1                   2                   3

  855. 	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

  856.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  857.    |V=2|P|   FMT   |       PT      |          length               |

  858.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  859.    |                  SSRC of packet sender                        |

  860.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  861.    |                  SSRC of media source                         |

  862.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  863.    :            Feedback Control Information (FCI)                 :

  864.    :                                                               :

  865. */

  866. void rtcp_rtpfb_unpack(struct rtp_context* ctx, const rtcp_header_t* header, const uint8_t* ptr, size_t bytes)

  867. {

  868. 	int r;

  869. 	struct rtcp_msg_t msg;

  870. 	struct rtp_member* sender;

  871. 

  872. 	if (bytes < 8 /*sizeof(rtcp_fci_t)*/)

  873. 	{

  874. 		assert(0);

  875. 		return;

  876. 	}

  877. 

  878. 	msg.type = RTCP_RTPFB | (header->rc << 8);

  879. 	msg.ssrc = nbo_r32(ptr);

  880. 	msg.u.rtpfb.media = nbo_r32(ptr + 4);

  881. 

  882. 	sender = rtp_sender_fetch(ctx, msg.ssrc);

  883. 	if (!sender) return; // error

  884. 	//assert(sender != ctx->self);

  885. 

  886. 	switch (header->rc)

  887. 	{

  888. 	case RTCP_RTPFB_NACK:

  889. 		r = rtcp_rtpfb_nack_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  890. 		break;

  891. 

  892. 	case RTCP_RTPFB_TMMBR:

  893. 		r = rtcp_rtpfb_tmmbr_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  894. 		break;

  895. 

  896. 	case RTCP_RTPFB_TMMBN:

  897. 		r = rtcp_rtpfb_tmmbn_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  898. 		break;

  899. 

  900. 	case RTCP_RTPFB_SRREQ:

  901. 		r = rtcp_rtpfb_srreq_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  902. 		break;

  903. 

  904. 	case RTCP_RTPFB_RAMS:

  905. 		r = rtcp_rtpfb_rams_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  906. 		break;

  907. 

  908. 	case RTCP_RTPFB_TLLEI:

  909. 		r = rtcp_rtpfb_tllei_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  910. 		break;

  911. 

  912. 	case RTCP_RTPFB_ECN:

  913. 		r = rtcp_rtpfb_ecn_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  914. 		break;

  915. 

  916. 	case RTCP_RTPFB_PS:

  917. 		r = rtcp_rtpfb_ps_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  918. 		break;

  919. 

  920. 	case RTCP_RTPFB_DBI:

  921. 		r = rtcp_rtpfb_dbi_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  922. 		break;

  923. 

  924. 	case RTCP_RTPFB_CCFB:

  925. 		r = rtcp_rtpfb_ccfb_unpack(ctx, header, &msg, ptr + 4 /*1st ssrc*/, bytes - 4);

  926. 		break;

  927. 

  928. 	case RTCP_RTPFB_TCC01:

  929. 		r = rtcp_rtpfb_tcc01_unpack(ctx, header, &msg, ptr + 8, bytes - 8);

  930. 		break;

  931. 

  932. 	default:

  933. 		assert(0);

  934. 		r = 0;

  935. 		break;

  936. 	}

  937. 

  938. 	return;

  939. }

  940. 

  941. int rtcp_rtpfb_pack(struct rtp_context* ctx, uint8_t* data, int bytes, enum rtcp_rtpfb_type_t id, const rtcp_rtpfb_t* rtpfb)

  942. {

  943. 	int r;

  944. 	rtcp_header_t header;

  945. 

  946. 	(void)ctx;

  947. 	if (bytes < 4 + 4 + 4)

  948. 		return 4 + 4 + 4;

  949. 

  950. 	switch (id)

  951. 	{

  952. 	case RTCP_RTPFB_NACK:

  953. 		r = rtcp_rtpfb_nack_pack(rtpfb->u.nack.nack, rtpfb->u.nack.count, data + 12, bytes - 12);

  954. 		break;

  955. 

  956. 	case RTCP_RTPFB_TMMBR:

  957. 		r = rtcp_rtpfb_tmmbr_pack(rtpfb->u.tmmbr.tmmbr, rtpfb->u.tmmbr.count, data + 12, bytes - 12);

  958. 		break;

  959. 

  960. 	case RTCP_RTPFB_TMMBN:

  961. 		r = rtcp_rtpfb_tmmbn_pack(rtpfb->u.tmmbr.tmmbr, rtpfb->u.tmmbr.count, data + 12, bytes - 12);

  962. 		break;

  963. 

  964. 	case RTCP_RTPFB_TLLEI:

  965. 		r = rtcp_rtpfb_tllei_pack(rtpfb->u.nack.nack, rtpfb->u.nack.count, data + 12, bytes - 12);

  966. 		break;

  967. 

  968. 	case RTCP_RTPFB_ECN:

  969. 		r = rtcp_rtpfb_ecn_pack(&rtpfb->u.ecn, data + 12, bytes - 12);

  970. 		break;

  971. 

  972. 	case RTCP_RTPFB_PS:

  973. 		r = rtcp_rtpfb_ps_pack(rtpfb->u.ps.target, (uint8_t)rtpfb->u.ps.cmd, (uint8_t)rtpfb->u.ps.len, (uint16_t)rtpfb->u.ps.id, (const uint8_t*)rtpfb->u.ps.payload, data + 12, bytes - 12);

  974. 		break;

  975. 

  976. 	case RTCP_RTPFB_CCFB:

  977. 		r = rtcp_rtpfb_ccfb_pack(rtpfb->u.tcc01.ssrc, (uint16_t)rtpfb->u.tcc01.begin, rtpfb->u.tcc01.ccfb, rtpfb->u.tcc01.count, rtpfb->u.tcc01.timestamp, data + 12, bytes - 12);

  978. 		break;

  979. 

  980. 	case RTCP_RTPFB_TCC01:

  981. 		r = rtcp_rtpfb_tcc01_pack((uint16_t)rtpfb->u.tcc01.begin, rtpfb->u.tcc01.ccfb, rtpfb->u.tcc01.count, rtpfb->u.tcc01.timestamp, (uint8_t)rtpfb->u.tcc01.cc, data + 12, bytes - 12);

  982. 		break;

  983. 

  984. 	case RTCP_RTPFB_SRREQ:

  985. 	case RTCP_RTPFB_RAMS:

  986. 	case RTCP_RTPFB_DBI:

  987. 	default:

  988. 		assert(0);

  989. 		return -1;

  990. 	}

  991. 

  992. 	header.v = 2;

  993. 	header.p = 0;

  994. 	header.pt = RTCP_RTPFB;

  995. 	header.rc = id;

  996. 	header.length = (r + 8 + 3) / 4;

  997. 	nbo_write_rtcp_header(data, &header);

  998. 

  999. 	nbo_w32(data + 4, ctx->self->ssrc);

  1000. 	//nbo_w32(data + 4, rtpfb->sender);

  1001. 	nbo_w32(data + 8, rtpfb->media);

  1002. 

  1003. 	//assert(8 == (header.length + 1) * 4);

  1004. 	return header.length * 4 + 4;

  1005. }

  1006. 

  1007. #if defined(_DEBUG) || defined(DEBUG)

  1008. static void rtcp_on_rtpfb_test(void* param, const struct rtcp_msg_t* msg)

  1009. {

  1010. 	int r;

  1011. 	static uint8_t buffer[1400];

  1012. 	switch (msg->type & 0xFF)

  1013. 	{

  1014. 	case RTCP_RTPFB:

  1015. 		switch ((msg->type >> 8) & 0xFF)

  1016. 		{

  1017. 		case RTCP_RTPFB_NACK:

  1018. 			assert(13 == msg->u.rtpfb.u.nack.count);

  1019. 			assert(msg->u.rtpfb.u.nack.nack[0].pid == 631 && msg->u.rtpfb.u.nack.nack[0].blp == 0x8028);

  1020. 			assert(msg->u.rtpfb.u.nack.nack[1].pid == 648 && msg->u.rtpfb.u.nack.nack[1].blp == 0x0021);

  1021. 			assert(msg->u.rtpfb.u.nack.nack[2].pid == 666 && msg->u.rtpfb.u.nack.nack[2].blp == 0x0008);

  1022. 			assert(msg->u.rtpfb.u.nack.nack[3].pid == 690 && msg->u.rtpfb.u.nack.nack[3].blp == 0x2000);

  1023. 			assert(msg->u.rtpfb.u.nack.nack[4].pid == 734 && msg->u.rtpfb.u.nack.nack[4].blp == 0x0025);

  1024. 			assert(msg->u.rtpfb.u.nack.nack[5].pid == 757 && msg->u.rtpfb.u.nack.nack[5].blp == 0x1100);

  1025. 			assert(msg->u.rtpfb.u.nack.nack[6].pid == 777 && msg->u.rtpfb.u.nack.nack[6].blp == 0x0000);

  1026. 			assert(msg->u.rtpfb.u.nack.nack[7].pid == 826 && msg->u.rtpfb.u.nack.nack[7].blp == 0x0002);

  1027. 			assert(msg->u.rtpfb.u.nack.nack[8].pid == 865 && msg->u.rtpfb.u.nack.nack[8].blp == 0x0000);

  1028. 			assert(msg->u.rtpfb.u.nack.nack[9].pid == 882 && msg->u.rtpfb.u.nack.nack[9].blp == 0x0300);

  1029. 			assert(msg->u.rtpfb.u.nack.nack[10].pid == 907 && msg->u.rtpfb.u.nack.nack[10].blp == 0x0400);

  1030. 			assert(msg->u.rtpfb.u.nack.nack[11].pid == 931 && msg->u.rtpfb.u.nack.nack[11].blp == 0x0000);

  1031. 			assert(msg->u.rtpfb.u.nack.nack[12].pid == 963 && msg->u.rtpfb.u.nack.nack[12].blp == 0x006d);

  1032. 			r = rtcp_rtpfb_nack_pack(msg->u.rtpfb.u.nack.nack, msg->u.rtpfb.u.nack.count, buffer, sizeof(buffer));

  1033. 			assert(r > 0 && 0 == memcmp(buffer, param, r));

  1034. 			break;

  1035. 

  1036. 		case RTCP_RTPFB_TMMBR:

  1037. 			assert(1 == msg->u.rtpfb.u.tmmbr.count);

  1038. 			assert(0x23456789 == msg->u.rtpfb.u.tmmbr.tmmbr[0].ssrc && 2 == msg->u.rtpfb.u.tmmbr.tmmbr[0].exp && 78000 == msg->u.rtpfb.u.tmmbr.tmmbr[0].mantissa && 312000 == (msg->u.rtpfb.u.tmmbr.tmmbr[0].mantissa << msg->u.rtpfb.u.tmmbr.tmmbr[0].exp) && 0x1fe == msg->u.rtpfb.u.tmmbr.tmmbr[0].overhead);

  1039. 			r = rtcp_rtpfb_tmmbr_pack(msg->u.rtpfb.u.tmmbr.tmmbr, msg->u.rtpfb.u.tmmbr.count, buffer, sizeof(buffer));

  1040. 			assert(8 == r && 0 == memcmp(buffer, param, r));

  1041. 			break;

  1042. 

  1043. 		case RTCP_RTPFB_TMMBN:

  1044. 			assert(1 == msg->u.rtpfb.u.tmmbr.count);

  1045. 			assert(0x23456789 == msg->u.rtpfb.u.tmmbr.tmmbr[0].ssrc && 2 == msg->u.rtpfb.u.tmmbr.tmmbr[0].exp && 78000 == msg->u.rtpfb.u.tmmbr.tmmbr[0].mantissa && 312000 == (msg->u.rtpfb.u.tmmbr.tmmbr[0].mantissa << msg->u.rtpfb.u.tmmbr.tmmbr[0].exp) && 0x1fe == msg->u.rtpfb.u.tmmbr.tmmbr[0].overhead);

  1046. 			r = rtcp_rtpfb_tmmbr_pack(msg->u.rtpfb.u.tmmbr.tmmbr, msg->u.rtpfb.u.tmmbr.count, buffer, sizeof(buffer));

  1047. 			assert(8 == r && 0 == memcmp(buffer, param, r));

  1048. 			break;

  1049. 

  1050. 		case RTCP_RTPFB_TCC01:

  1051. 			assert(1767 == msg->u.rtpfb.u.tcc01.begin && 4114000 == msg->u.rtpfb.u.tcc01.timestamp && 101 == msg->u.rtpfb.u.tcc01.count && 42 == msg->u.rtpfb.u.tcc01.cc);

  1052. 			assert(msg->u.rtpfb.u.tcc01.ccfb[0].seq == 1767 && msg->u.rtpfb.u.tcc01.ccfb[0].received == 0);

  1053. 			assert(msg->u.rtpfb.u.tcc01.ccfb[1].seq == 1768 && msg->u.rtpfb.u.tcc01.ccfb[1].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[1].ato == 21);

  1054. 			assert(msg->u.rtpfb.u.tcc01.ccfb[2].seq == 1769 && msg->u.rtpfb.u.tcc01.ccfb[2].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[2].ato == 0);

  1055. 			assert(msg->u.rtpfb.u.tcc01.ccfb[3].seq == 1770 && msg->u.rtpfb.u.tcc01.ccfb[3].received == 0);

  1056. 			assert(msg->u.rtpfb.u.tcc01.ccfb[4].seq == 1771 && msg->u.rtpfb.u.tcc01.ccfb[4].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[4].ato == 0);

  1057. 			assert(msg->u.rtpfb.u.tcc01.ccfb[5].seq == 1772 && msg->u.rtpfb.u.tcc01.ccfb[5].received == 0);

  1058. 			assert(msg->u.rtpfb.u.tcc01.ccfb[6].seq == 1773 && msg->u.rtpfb.u.tcc01.ccfb[6].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[6].ato == 26);

  1059. 			r = rtcp_rtpfb_tcc01_pack((uint16_t)msg->u.rtpfb.u.tcc01.begin, msg->u.rtpfb.u.tcc01.ccfb, msg->u.rtpfb.u.tcc01.count, msg->u.rtpfb.u.tcc01.timestamp, (uint8_t)msg->u.rtpfb.u.tcc01.cc, buffer, sizeof(buffer));

  1060. 			assert(104 == r && 0 == memcmp(buffer, param, r));

  1061. 			break;

  1062. 

  1063. 		case 30: // test only

  1064. 			assert(5 == msg->u.rtpfb.u.tcc01.begin && 5 == msg->u.rtpfb.u.tcc01.timestamp && 7 == msg->u.rtpfb.u.tcc01.count && 0 == msg->u.rtpfb.u.tcc01.cc);

  1065. 			assert(msg->u.rtpfb.u.tcc01.ccfb[0].seq == 5 && msg->u.rtpfb.u.tcc01.ccfb[0].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[1].ato == 0);

  1066. 			assert(msg->u.rtpfb.u.tcc01.ccfb[1].seq == 6 && msg->u.rtpfb.u.tcc01.ccfb[1].received == 0);

  1067. 			assert(msg->u.rtpfb.u.tcc01.ccfb[2].seq == 7 && msg->u.rtpfb.u.tcc01.ccfb[2].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[2].ato == 128);

  1068. 			assert(msg->u.rtpfb.u.tcc01.ccfb[3].seq == 8 && msg->u.rtpfb.u.tcc01.ccfb[3].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[3].ato == 64);

  1069. 			assert(msg->u.rtpfb.u.tcc01.ccfb[4].seq == 9 && msg->u.rtpfb.u.tcc01.ccfb[4].received == 0);

  1070. 			assert(msg->u.rtpfb.u.tcc01.ccfb[5].seq == 10 && msg->u.rtpfb.u.tcc01.ccfb[5].received == 0);

  1071. 			assert(msg->u.rtpfb.u.tcc01.ccfb[6].seq == 11 && msg->u.rtpfb.u.tcc01.ccfb[6].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[6].ato == 256);

  1072. 			r = rtcp_rtpfb_tcc01_pack((uint16_t)msg->u.rtpfb.u.tcc01.begin, msg->u.rtpfb.u.tcc01.ccfb, msg->u.rtpfb.u.tcc01.count, msg->u.rtpfb.u.tcc01.timestamp, (uint8_t)msg->u.rtpfb.u.tcc01.cc, buffer, sizeof(buffer));

  1073. 			assert(20 == r && 0 == memcmp(buffer, param, r));

  1074. 			break;

  1075. 

  1076. 		case 31: // test only

  1077. 			assert(248 == msg->u.rtpfb.u.tcc01.begin && -5546573 == msg->u.rtpfb.u.tcc01.timestamp && 128 == msg->u.rtpfb.u.tcc01.count && 1 == msg->u.rtpfb.u.tcc01.cc);

  1078. 			assert(msg->u.rtpfb.u.tcc01.ccfb[0].seq == 248 && msg->u.rtpfb.u.tcc01.ccfb[0].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[0].ato == 33);

  1079. 			assert(msg->u.rtpfb.u.tcc01.ccfb[1].seq == 249 && msg->u.rtpfb.u.tcc01.ccfb[1].received == 0);

  1080. 			assert(msg->u.rtpfb.u.tcc01.ccfb[125].seq == 373 && msg->u.rtpfb.u.tcc01.ccfb[125].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[125].ato == -50);

  1081. 			assert(msg->u.rtpfb.u.tcc01.ccfb[126].seq == 374 && msg->u.rtpfb.u.tcc01.ccfb[126].received == 0);

  1082. 			assert(msg->u.rtpfb.u.tcc01.ccfb[127].seq == 375 && msg->u.rtpfb.u.tcc01.ccfb[127].received == 1 && msg->u.rtpfb.u.tcc01.ccfb[127].ato == 65);

  1083. 			r = rtcp_rtpfb_tcc01_pack((uint16_t)msg->u.rtpfb.u.tcc01.begin, msg->u.rtpfb.u.tcc01.ccfb, msg->u.rtpfb.u.tcc01.count, msg->u.rtpfb.u.tcc01.timestamp, (uint8_t)msg->u.rtpfb.u.tcc01.cc, buffer, sizeof(buffer));

  1084. 			assert(20 == r && 0 == memcmp(buffer, param, r));

  1085. 			break;

  1086. 

  1087. 		case RTCP_RTPFB_CCFB:

  1088. 			assert(0);

  1089. 			break;

  1090. 

  1091. 		default:

  1092. 			break;

  1093. 		}

  1094. 		break;

  1095. 

  1096. 	default:

  1097. 		assert(0);

  1098. 	}

  1099. }

  1100. 

  1101. static void rtcp_rtpfb_nack_test(void)

  1102. {

  1103. 	//rtcp_nack_t* nack;

  1104. 	//const uint8_t data[] = { 0x81, 0xcd, 0x00, 0x08, 0x84, 0x68, 0xc2, 0x4c, 0x84, 0x68, 0xc2, 0x4c, 0x03, 0x27, 0x7f, 0xff, 0x03, 0x38, 0xff, 0xf7, 0x03, 0x49, 0xff, 0xff, 0x03, 0x5a, 0xff, 0xff, 0x03, 0x6b, 0x7f, 0xbf, 0x03, 0x7c, 0x00, 0x0f };

  1105. 	//assert(0 == rtcp_rtpfb_nack_unpack(NULL, NULL, 0, 0, data, sizeof(data)));

  1106. 	//assert(nack[0].pid == 807 && nack[0].blp == 0x7fff);

  1107. 	//assert(nack[1].pid == 824 && nack[1].blp == 0xfff7);

  1108. 	//assert(nack[2].pid == 841 && nack[2].blp == 0xffff);

  1109. 	//assert(nack[3].pid == 858 && nack[3].blp == 0xffff);

  1110. 	//assert(nack[4].pid == 875 && nack[4].blp == 0x7fbf);

  1111. 	//assert(nack[5].pid == 892 && nack[5].blp == 0x000f);

  1112. 

  1113. 	const uint8_t data[] = { 0x02, 0x77, 0x80, 0x28, 0x02, 0x88, 0x00, 0x21, 0x02, 0x9a, 0x00, 0x08, 0x02, 0xb2, 0x20, 0x00, 0x02, 0xde, 0x00, 0x25, 0x02, 0xf5, 0x11, 0x00, 0x03, 0x09, 0x00, 0x00, 0x03, 0x3a, 0x00, 0x02, 0x03, 0x61, 0x00, 0x00, 0x03, 0x72, 0x03, 0x00, 0x03, 0x8b, 0x04, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x03, 0xc3, 0x00, 0x6d };

  1114. 	

  1115. 	struct rtcp_msg_t msg;

  1116. 	struct rtp_context rtp;

  1117. 	rtp.handler.on_rtcp = rtcp_on_rtpfb_test;

  1118. 	rtp.cbparam = (void*)data;

  1119. 

  1120. 	msg.type = (RTCP_RTPFB_NACK << 8) | RTCP_RTPFB;

  1121. 	assert(0 == rtcp_rtpfb_nack_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  1122. }

  1123. 

  1124. static void rtcp_rtpfb_tmmbr_test(void)

  1125. {

  1126. 	const uint8_t data[] = { 0x23, 0x45, 0x67, 0x89, 0x0a, 0x61, 0x61, 0xfe };

  1127. 

  1128. 	struct rtcp_msg_t msg;

  1129. 	struct rtp_context rtp;

  1130. 	rtp.handler.on_rtcp = rtcp_on_rtpfb_test;

  1131. 	rtp.cbparam = (void*)data;

  1132. 

  1133. 	msg.type = (RTCP_RTPFB_TMMBR << 8) | RTCP_RTPFB;

  1134. 	assert(0 == rtcp_rtpfb_tmmbr_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  1135. }

  1136. 

  1137. static void rtcp_rtpfb_tmmbn_test(void)

  1138. {

  1139. 	const uint8_t data[] = { 0x23, 0x45, 0x67, 0x89, 0x0a, 0x61, 0x61, 0xfe };

  1140. 

  1141. 	struct rtcp_msg_t msg;

  1142. 	struct rtp_context rtp;

  1143. 	rtp.handler.on_rtcp = rtcp_on_rtpfb_test;

  1144. 	rtp.cbparam = (void*)data;

  1145. 

  1146. 	msg.type = (RTCP_RTPFB_TMMBN << 8) | RTCP_RTPFB;

  1147. 	assert(0 == rtcp_rtpfb_tmmbn_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  1148. }

  1149. 

  1150. static void rtcp_rtpfb_tcc01_test(void)

  1151. {

  1152. 	//rtcp_ccfb_t* ccfb;

  1153. 	//const uint8_t data[] = { 0x8f, 0xcd, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x84, 0x68, 0xc2, 0x49, 0x23, 0x8b, 0x01, 0x8b, 0x3e, 0x08, 0x49, 0x09, 0xd9, 0x00, 0x00, 0x0e, 0xa0, 0x00, 0x00, 0x1c, 0xa0, 0x00, 0x00, 0xe6, 0xa0, 0x00, 0x00, 0x49, 0x20, 0x01, 0x2c, 0xff, 0xf0, 0x0c, 0x44, 0x94, 0x8c, 0x50, 0x00, 0x00 };

  1154. 	//assert(0 == rtcp_rtpfb_tcc01_unpack(NULL, NULL, 0, 0, data, sizeof(data)));

  1155. 	//assert(395 == num && ccfb[0].seq == 9099 && ccfb[0].received && ccfb[1].ecn == 0x01 && ccfb[0].ato == 11);

  1156. 	//assert(cfb[1].seq == 9100 && ccfb[1].received && ccfb[1].ecn == 0x02 && ccfb[1].ato == -4);

  1157. 

  1158. 	const uint8_t data[] = { 0x06, 0xe7, 0x00, 0x65, 0x3e, 0xc6, 0x50, 0x2a, 0x9a, 0xff, 0x20, 0x16, 0x97, 0x68, 0xbc, 0xab, 0xa7, 0xfe, 0x20, 0x12, 0xc1, 0x50, 0x54, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01 };

  1159. 	struct rtcp_msg_t msg;

  1160. 	struct rtp_context rtp;

  1161. 	rtp.handler.on_rtcp = rtcp_on_rtpfb_test;

  1162. 	rtp.cbparam = (void*)data;

  1163. 	msg.type = (RTCP_RTPFB_TCC01 << 8) | RTCP_RTPFB;

  1164. 	assert(0 == rtcp_rtpfb_tcc01_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  1165. 

  1166. 	// 11-768ms, 8-512ms, 7-448ms, 5-320ms

  1167. 	const uint8_t data2[] = { 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x05, 0x00, 0xd2, 0x82, 0x00, 0x02, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03 };

  1168. 	rtp.cbparam = (void*)data2;

  1169. 	msg.type = (30 << 8) | RTCP_RTPFB;

  1170. 	assert(0 == rtcp_rtpfb_tcc01_unpack(&rtp, NULL, &msg, data2, sizeof(data2)));

  1171. 

  1172. 	// 248-33ms, 373-(-50)ms, 375-65ms, timestamp: -5546573

  1173. 	const uint8_t data3[] = { 0x00, 0xf8, 0x00, 0x80, 0xab, 0x5d, 0xb3, 0x01, 0xa0, 0x00, 0x00, 0x6f, 0xe2, 0x00, 0x84, 0xff, 0x38, 0x01, 0x04, 0x01 };

  1174. 	rtp.cbparam = (void*)data3;

  1175. 	msg.type = (31 << 8) | RTCP_RTPFB;

  1176. 	assert(0 == rtcp_rtpfb_tcc01_unpack(&rtp, NULL, &msg, data3, sizeof(data3)));

  1177. }

  1178. 

  1179. void rtcp_rtpfb_test(void)

  1180. {

  1181. 	rtcp_rtpfb_nack_test();

  1182. 	rtcp_rtpfb_tmmbr_test();

  1183. 	rtcp_rtpfb_tmmbn_test();

  1184. 	rtcp_rtpfb_tcc01_test();

  1185. }

  1186. #endif