huangxiyun
/
ZLKMedia
1
0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
1 Commit
1 Branch
21MB
Branch: master
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de master
${ noResults }
ZLKMedia/3rdpart/media-server/librtp/source/rtcp-psfb.c

852 linhas
26KB
Original Link permanente Anotar Histórico 

  1. #include "rtp-internal.h"

  2. #include "rtp-util.h"

  3. #include <errno.h>

  4. 

  5. static int rtcp_psfb_pli_pack(uint8_t* ptr, uint32_t bytes);

  6. static int rtcp_psfb_sli_pack(const rtcp_sli_t* sli, int count, uint8_t* ptr, uint32_t bytes);

  7. static int rtcp_psfb_rpsi_pack(uint8_t pt, const uint8_t* payload, uint32_t bits, uint8_t* ptr, uint32_t bytes);

  8. static int rtcp_psfb_fir_pack(const rtcp_fir_t* fir, int count, uint8_t* ptr, uint32_t bytes);

  9. static int rtcp_psfb_tstr_pack(const rtcp_fir_t* fir, int count, uint8_t* ptr, uint32_t bytes);

  10. static int rtcp_psfb_tstn_pack(const rtcp_fir_t* fir, int count, uint8_t* ptr, uint32_t bytes);

  11. static int rtcp_psfb_vbcm_pack(const rtcp_vbcm_t* vbcm, uint8_t* ptr, uint32_t bytes);

  12. static int rtcp_psfb_pslei_pack(const uint32_t* ssrc, int count, uint8_t* ptr, uint32_t bytes);

  13. static int rtcp_psfb_lrr_pack(const rtcp_lrr_t* lrr, int count, uint8_t* ptr, uint32_t bytes);

  14. static int rtcp_psfb_remb_pack(const rtcp_remb_t* remb, int count, uint8_t* ptr, uint32_t bytes);

  15. 

  16. static int rtcp_psfb_pli_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_psfb_sli_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_psfb_rpsi_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_psfb_fir_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_psfb_tstr_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_psfb_tstn_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_psfb_vbcm_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_psfb_pslei_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_psfb_lrr_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_psfb_roi_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_psfb_afb_unpack(struct rtp_context* ctx, const rtcp_header_t* header, struct rtcp_msg_t* msg, const uint8_t* ptr, size_t bytes);

  27. 

  28. 

  29. // https://datatracker.ietf.org/doc/html/rfc4585#section-6.3.1

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

  31. {

  32. 	// 1. There MUST be exactly one PLI contained in the FCI field.

  33. 	// 2. PLI does not require parameters.  Therefore, the length field MUST be 2, and there MUST NOT be any Feedback Control Information.

  34. 	assert(0 == bytes);

  35. 

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

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

  38. 	return 0;

  39. }

  40. 

  41. static int rtcp_psfb_pli_pack(uint8_t* ptr, uint32_t bytes)

  42. {

  43. 	(void)ptr, (void)bytes;

  44. 	return 0;

  45. }

  46. 

  47. // https://datatracker.ietf.org/doc/html/rfc4585#section-6.3.2

  48. /*

  49. 	0                   1                   2                   3

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

  51.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  52.    |            First        |        Number           | PictureID |

  53.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  54. */

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

  56. {

  57. 	size_t i;

  58. 	rtcp_sli_t* sli, sli0[32];

  59. 

  60. 	if (bytes / 4 > sizeof(sli0) / sizeof(sli0[0]))

  61. 	{

  62. 		sli = calloc(bytes / 4, sizeof(*sli));

  63. 		if (!sli) return -ENOMEM;

  64. 	}

  65. 	else

  66. 	{

  67. 		sli = sli0;

  68. 		memset(sli, 0, sizeof(sli[0]) * (bytes / 4));

  69. 	}

  70. 

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

  72. 	{

  73. 		sli[i].first = (ptr[0] << 5) | (ptr[1] >> 3);

  74. 		sli[i].number = ((ptr[1] & 0x07) << 10) | (ptr[2] << 2) | (ptr[3] >> 6);

  75. 		sli[i].picture_id = ptr[3] & 0x3F;

  76. 

  77. 		ptr += 4;

  78. 	}

  79. 

  80. 	msg->u.psfb.u.sli.sli = sli;

  81. 	msg->u.psfb.u.sli.count = (int)i;

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

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

  84. 	if (sli && sli != sli0)

  85. 		free(sli);

  86. 	return 0;

  87. }

  88. 

  89. static int rtcp_psfb_sli_pack(const rtcp_sli_t* sli, int count, uint8_t* ptr, uint32_t bytes)

  90. {

  91. 	int i;

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

  93. 	{

  94. 		nbo_w32(ptr, ((sli->first & 0x1FFFF) << 19) | ((sli->number & 0x1FFFF) << 6) | (sli->picture_id & 0x3F));

  95. 

  96. 		bytes -= 4;

  97. 		ptr += 4;

  98. 	}

  99. 	return i * 4;

  100. }

  101. 

  102. // https://datatracker.ietf.org/doc/html/rfc4585#section-6.3.3

  103. /*

  104. 	0                   1                   2                   3

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

  106.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  107.    |      PB       |0| Payload Type|    Native RPSI bit string     |

  108.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  109.    |   defined per codec          ...                | Padding (0) |

  110.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  111. */

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

  113. {

  114. 	uint8_t pb;

  115. 	uint8_t pt;

  116. 

  117. 	if (bytes < 4)

  118. 		return -1;

  119. 

  120. 	pb = ptr[0];

  121. 	pt = ptr[1] & 0x7F;

  122. 

  123. 	msg->u.psfb.u.rpsi.pt = pt;

  124. 	msg->u.psfb.u.rpsi.len = (uint32_t)bytes * 8 - pb;

  125. 	msg->u.psfb.u.rpsi.payload = (uint8_t*)ptr + 2;

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

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

  128. 	return 0;

  129. }

  130. 

  131. static int rtcp_psfb_rpsi_pack(uint8_t pt, const uint8_t* payload, uint32_t bits, uint8_t* ptr, uint32_t bytes)

  132. {

  133. 	uint32_t len;

  134. 	len = (bits + 7) / 8;

  135. 	if (bytes < (2 + len + 3) / 4 * 4)

  136. 		return -1;

  137. 

  138. 	ptr[0] = (uint8_t)((2 + len + 3) / 4 * 4 * 8 - (2 * 8 + bits));

  139. 	ptr[1] = pt;

  140. 	memcpy(ptr + 2, payload, len);

  141. 	return (2 + len + 3) / 4 * 4;

  142. }

  143. 

  144. // https://www.rfc-editor.org/rfc/rfc5104.html#section-4.3.1

  145. /*

  146. 	0                   1                   2                   3

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

  148.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  149.    |                              SSRC                             |

  150.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  151.    | Seq nr.       |    Reserved                                   |

  152.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  153. */

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

  155. {

  156. 	size_t i;

  157. 	rtcp_fir_t *fir, fir0[32];

  158. 

  159. 	if (bytes / 8 > sizeof(fir0) / sizeof(fir0[0]))

  160. 	{

  161. 		fir = calloc(bytes / 8, sizeof(*fir));

  162. 		if (!fir) return -ENOMEM;

  163. 	}

  164. 	else

  165. 	{

  166. 		fir = fir0;

  167. 		memset(fir, 0, sizeof(fir[0]) * (bytes / 8));

  168. 	}

  169. 

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

  171. 	{

  172. 		fir[i].ssrc = nbo_r32(ptr);

  173. 		fir[i].sn = ptr[4];

  174. 		ptr += 8;

  175. 	}

  176. 	

  177. 	msg->u.psfb.u.fir.fir = fir;

  178. 	msg->u.psfb.u.fir.count = (int)i;

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

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

  181. 	if (fir && fir != fir0)

  182. 		free(fir);

  183. 	return 0;

  184. }

  185. 

  186. static int rtcp_psfb_fir_pack(const rtcp_fir_t* fir, int count, uint8_t* ptr, uint32_t bytes)

  187. {

  188. 	int i;

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

  190. 	{

  191. 		nbo_w32(ptr, fir[i].ssrc);

  192. 		nbo_w32(ptr + 4, fir[i].sn << 24);

  193. 

  194. 		bytes -= 8;

  195. 		ptr += 8;

  196. 	}

  197. 	return i * 8;

  198. }

  199. 

  200. // https://www.rfc-editor.org/rfc/rfc5104.html#section-4.3.2

  201. /*

  202. 	0                   1                   2                   3

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

  204.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  205.    |                              SSRC                             |

  206.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  207.    |  Seq nr.      |  Reserved                           | Index   |

  208.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  209. */

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

  211. {

  212. 	size_t i;

  213. 	rtcp_fir_t* fir, fir0[32];

  214. 

  215. 	if (bytes / 8 > sizeof(fir0) / sizeof(fir0[0]))

  216. 	{

  217. 		fir = calloc(bytes / 8, sizeof(*fir));

  218. 		if (!fir) return -ENOMEM;

  219. 	}

  220. 	else

  221. 	{

  222. 		fir = fir0;

  223. 		memset(fir, 0, sizeof(fir[0]) * (bytes / 8));

  224. 	}

  225. 

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

  227. 	{

  228. 		fir[i].ssrc = nbo_r32(ptr);

  229. 		fir[i].sn = ptr[4];

  230. 		fir[i].index = ptr[7] & 0x1F;

  231. 

  232. 		ptr += 8;

  233. 	}

  234. 

  235. 	msg->u.psfb.u.fir.fir = fir;

  236. 	msg->u.psfb.u.fir.count = (int)i;

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

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

  239. 	if (fir && fir != fir0)

  240. 		free(fir);

  241. 	return 0;

  242. }

  243. 

  244. static int rtcp_psfb_tstr_pack(const rtcp_fir_t* fir, int count, uint8_t* ptr, uint32_t bytes)

  245. {

  246. 	int i;

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

  248. 	{

  249. 		nbo_w32(ptr, fir[i].ssrc);

  250. 		nbo_w32(ptr + 4, (fir[i].sn << 24) | fir[i].index);

  251. 

  252. 		bytes -= 8;

  253. 		ptr += 8;

  254. 	}

  255. 	return i * 8;

  256. }

  257. 

  258. // https://www.rfc-editor.org/rfc/rfc5104.html#section-4.3.3

  259. /*

  260. 	0                   1                   2                   3

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

  262.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  263.    |                              SSRC                             |

  264.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  265.    |  Seq nr.      |  Reserved                           | Index   |

  266.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  267. */

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

  269. {

  270. 	size_t i;

  271. 	rtcp_fir_t* fir, fir0[32];

  272. 

  273. 	if (bytes / 8 > sizeof(fir0) / sizeof(fir0[0]))

  274. 	{

  275. 		fir = calloc(bytes / 8, sizeof(*fir));

  276. 		if (!fir) return -ENOMEM;

  277. 	}

  278. 	else

  279. 	{

  280. 		fir = fir0;

  281. 		memset(fir, 0, sizeof(fir[0]) * (bytes / 8));

  282. 	}

  283. 

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

  285. 	{

  286. 		fir[i].ssrc = nbo_r32(ptr);

  287. 		fir[i].sn = ptr[4];

  288. 		fir[i].index = ptr[7] & 0x1F;

  289. 

  290. 		ptr += 8;

  291. 	}

  292. 

  293. 	msg->u.psfb.u.fir.fir = fir;

  294. 	msg->u.psfb.u.fir.count = (int)i;

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

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

  297. 	if (fir && fir != fir0)

  298. 		free(fir);

  299. 	return 0;

  300. }

  301. 

  302. static int rtcp_psfb_tstn_pack(const rtcp_fir_t* fir, int count, uint8_t* ptr, uint32_t bytes)

  303. {

  304. 	return rtcp_psfb_tstr_pack(fir, count, ptr, bytes);

  305. }

  306. 

  307. // https://www.rfc-editor.org/rfc/rfc5104.html#section-4.3.4

  308. /*

  309.    0                   1                   2                   3

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

  311.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  312.    |                              SSRC                             |

  313.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  314.    | Seq nr.       |0| Payload Type| Length                        |

  315.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  316.    |                    VBCM Octet String....      |    Padding    |

  317.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  318. */

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

  320. {

  321. 	rtcp_vbcm_t vbcm;

  322. 

  323. 	while(bytes > 8)

  324. 	{

  325. 		vbcm.ssrc = nbo_r32(ptr);

  326. 		vbcm.sn = ptr[4];

  327. 		vbcm.pt = ptr[5] & 0x7F;

  328. 		vbcm.len = nbo_r16(ptr + 6);

  329. 		if (vbcm.len + 8 > bytes)

  330. 			return -1;

  331. 

  332. 		vbcm.payload = (uint8_t*)ptr + 8;

  333. 		bytes -= 8 + (vbcm.len + 3) / 4 * 4;

  334. 		ptr += 8 + (vbcm.len + 3) / 4 * 4;

  335. 

  336. 		memcpy(&msg->u.psfb.u.vbcm, &vbcm, sizeof(vbcm));

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

  338. 	}

  339. 

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

  341. 	return 0;

  342. }

  343. 

  344. static int rtcp_psfb_vbcm_pack(const rtcp_vbcm_t* vbcm, uint8_t* ptr, uint32_t bytes)

  345. {

  346. 	if (bytes < 8 + (uint32_t)(vbcm->len + 3) / 4 * 4)

  347. 		return -1;

  348. 

  349. 	nbo_w32(ptr, vbcm->ssrc);

  350. 	ptr[4] = (uint8_t)vbcm->sn;

  351. 	ptr[5] = (uint8_t)vbcm->pt;

  352. 	nbo_w16(ptr + 6, (uint16_t)vbcm->len);

  353. 	memcpy(ptr + 8, vbcm->payload, vbcm->len);

  354. 	return 8 + (vbcm->len + 3) / 4 * 4;

  355. }

  356. 

  357. // https://www.rfc-editor.org/rfc/rfc6642.html#section-5.2

  358. /*

  359.        0                   1                   2                   3

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

  361.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  362.       |                              SSRC                             |

  363.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  364. */

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

  366. {

  367. 	size_t i;

  368. 	uint32_t* v, v0[32];

  369. 

  370. 	if (bytes / 4 > sizeof(v0) / sizeof(v0[0]))

  371. 	{

  372. 		v = calloc(bytes / 4, sizeof(*v));

  373. 		if (!v) return -ENOMEM;

  374. 	}

  375. 	else

  376. 	{

  377. 		v = v0;

  378. 		memset(v, 0, sizeof(v[0]) * (bytes / 4));

  379. 	}

  380. 

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

  382. 	{

  383. 		v[i] = nbo_r32(ptr);

  384. 		ptr += 4;

  385. 	}

  386. 

  387. 	msg->u.psfb.u.pslei.ssrc = v;

  388. 	msg->u.psfb.u.pslei.count = (int)i;

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

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

  391. 	if (v && v != v0)

  392. 		free(v);

  393.     return 0;

  394. }

  395. 

  396. static int rtcp_psfb_pslei_pack(const uint32_t* ssrc, int count, uint8_t* ptr, uint32_t bytes)

  397. {

  398. 	int i;

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

  400. 	{

  401. 		nbo_w32(ptr, ssrc[i]);

  402. 

  403. 		bytes -= 4;

  404. 		ptr += 4;

  405. 	}

  406. 	return i * 4;

  407. }

  408. 

  409. // https://datatracker.ietf.org/doc/html/draft-ietf-avtext-lrr-07#section-3.1

  410. /*

  411. 	   0                   1                   2                   3

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

  413. 	  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  414. 	  |                              SSRC                             |

  415. 	  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  416. 	  | Seq nr.       |C| Payload Type| Reserved                      |

  417. 	  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  418. 	  | RES     | TTID| TLID          | RES     | CTID| CLID          |

  419. 	  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  420. */

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

  422. {

  423. 	size_t i;

  424. 	rtcp_lrr_t* lrr, lrr0[32];

  425. 

  426. 	if (bytes / 12 > sizeof(lrr0) / sizeof(lrr0[0]))

  427. 	{

  428. 		lrr = calloc(bytes / 12, sizeof(*lrr));

  429. 		if (!lrr) return -ENOMEM;

  430. 	}

  431. 	else

  432. 	{

  433. 		lrr = lrr0;

  434. 		memset(lrr, 0, sizeof(lrr[0]) * (bytes / 12));

  435. 	}

  436. 

  437. 	for (i = 0; i < bytes / 12; i++)

  438. 	{

  439. 		lrr[i].ssrc = nbo_r32(ptr);

  440. 		lrr[i].sn = ptr[4];

  441. 		lrr[i].c = (ptr[5] >> 7) & 0x01;

  442. 		lrr[i].payload = ptr[5] & 0x7F;

  443. 		lrr[i].ttid = ptr[8] & 0x07;

  444. 		lrr[i].tlid = ptr[9];

  445. 		lrr[i].ctid = ptr[10] & 0x07;

  446. 		lrr[i].clid = ptr[11];

  447. 		ptr += 12;

  448. 	}

  449. 

  450. 	msg->u.psfb.u.lrr.lrr = lrr;

  451. 	msg->u.psfb.u.lrr.count = (int)i;

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

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

  454. 	if (lrr && lrr != lrr0)

  455. 		free(lrr);

  456. 	return 0;

  457. }

  458. 

  459. static int rtcp_psfb_lrr_pack(const rtcp_lrr_t* lrr, int count, uint8_t* ptr, uint32_t bytes)

  460. {

  461. 	int i;

  462. 	for (i = 0; i < count && bytes >= 12; i++)

  463. 	{

  464. 		nbo_w32(ptr, lrr[i].ssrc);

  465. 		nbo_w32(ptr, (lrr[i].sn << 24) | ((lrr[i].c & 0x01) << 23) | ((lrr[i].payload & 0x7F) << 16));

  466. 		nbo_w32(ptr, ((lrr[i].ttid & 0x07) << 24) | ((lrr[i].tlid & 0xFF) << 16) | ((lrr[i].ctid & 0x07) << 8) | ((lrr[i].clid & 0xFF) << 0));

  467. 

  468. 		bytes -= 12;

  469. 		ptr += 12;

  470. 	}

  471. 	return i * 12;

  472. }

  473. 

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

  475. // 7.3.7	Video Region-of-Interest (ROI) Signaling

  476. /*

  477. Arbitrary ROI

  478.  0                   1                   2                   3

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

  480. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  481. | Position_X (h)| Position_X (l)| Position_Y (h)|  Position_Y(l)|

  482. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  483. |   Size_X (h)  |   Size_X (l)  |   Size_Y (h)  |    Size_Y(l)  |

  484. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  485. 

  486. Pre-defined ROI

  487.  0                   1                   2                   3

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

  489. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  490. |           all ones                            |   ROI_ID      |

  491. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  492. 

  493.  0                   1                   2                   3

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

  495. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  496. |   ID  | len=7 | Position_X (h)| Position_X (l)| Position_Y (h)|

  497. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  498. | Position_Y (l)|   Size_X (h)  |   Size_X (l)  |   Size_Y (h)  |

  499. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  500. |  Size_Y (l)   |                 zero padding                  |

  501. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  502. 

  503.  0                   1                   2                   3

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

  505. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  506. |   ID  | len=0 |     ROI_ID    |      zero padding             |

  507. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  508. */

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

  510. {

  511. 	(void)ctx, (void)header, (void)msg, (void)ptr, (void)bytes;

  512. 	return 0;

  513. }

  514. 

  515. // https://datatracker.ietf.org/doc/html/rfc4585#section-6.4

  516. // https://datatracker.ietf.org/doc/html/draft-alvestrand-rmcat-remb-03#section-2.2

  517. /*

  518. 	0                   1                   2                   3

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

  520.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  521.    |V=2|P| FMT=15  |   PT=206      |             length            |

  522.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  523.    |                  SSRC of packet sender                        |

  524.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  525.    |                  SSRC of media source                         |

  526.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  527.    |  Unique identifier 'R' 'E' 'M' 'B'                            |

  528.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  529.    |  Num SSRC     | BR Exp    |  BR Mantissa                      |

  530.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  531.    |   SSRC feedback                                               |

  532.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  533.    |  ...                                                          |

  534. */

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

  536. {

  537. 	uint32_t i, n, exp, mantissa;

  538. 	rtcp_remb_t* remb, remb0[4];

  539. 	const uint8_t id[] = { 'R', 'E', 'M', 'B' };

  540. 

  541. 	if (bytes >= 8 && 0 == memcmp(ptr, id, 4))

  542. 	{

  543. 		n = ptr[4];

  544. 		exp = (ptr[5] >> 2) & 0x3F;

  545. 		mantissa = ((ptr[5] & 0x3) << 16) | nbo_r16(ptr+6);

  546. 

  547. 		ptr += 8;

  548. 		bytes -= 8;

  549. 		if (n * 4 > bytes)

  550. 			return -1;

  551. 

  552. 		if (n > sizeof(remb0) / sizeof(remb0[0]))

  553. 		{

  554. 			remb = calloc(n, sizeof(*remb));

  555. 			if (!remb) return -ENOMEM;

  556. 		}

  557. 		else

  558. 		{

  559. 			remb = remb0;

  560. 			memset(remb, 0, sizeof(remb[0]) * n);

  561. 		}

  562. 

  563. 		for (i = 0; i < n; i++)

  564. 		{

  565. 			remb[i].exp = exp;

  566. 			remb[i].mantissa = mantissa;

  567. 			remb[i].ssrc = nbo_r32(ptr);

  568. 			ptr += 4;

  569. 		}

  570. 

  571. 		msg->u.psfb.u.afb.remb = remb;

  572. 		msg->u.psfb.u.afb.count = i;

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

  574. 		if (remb && remb != remb0)

  575. 			free(remb);

  576. 		return 0;

  577. 	}

  578. 

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

  580. 	return 0;

  581. }

  582. 

  583. static int rtcp_psfb_remb_pack(const rtcp_remb_t* remb, int count, uint8_t* ptr, uint32_t bytes)

  584. {

  585. 	int i;

  586. 	const uint8_t id[] = { 'R', 'E', 'M', 'B' };

  587. 

  588. 	if (count < 1 || count > 255 || (int)bytes < 4 + 4 + count * 4)

  589. 		return -E2BIG;

  590. 

  591. 	memcpy(ptr, id, sizeof(id));

  592. 	nbo_w32(ptr + 4, (count << 24) | (remb[0].exp << 18) | remb[0].mantissa);

  593. 

  594. 	ptr += 8;

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

  596. 	{

  597. 		nbo_w32(ptr, remb[i].ssrc);

  598. 		ptr += 4;

  599. 	}

  600. 	return 4 + 4 + count * 4;

  601. }

  602. 

  603. // https://datatracker.ietf.org/doc/html/rfc4585#section-6.3

  604. /*

  605. *  Common Packet Format for Feedback Messages

  606. 

  607. 	0                   1                   2                   3

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

  609.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

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

  611.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  612.    |                  SSRC of packet sender                        |

  613.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  614.    |                  SSRC of media source                         |

  615.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  616.    :            Feedback Control Information (FCI)                 :

  617.    :                                                               :

  618. */

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

  620. {

  621. 	int r;

  622. 	struct rtcp_msg_t msg;

  623. 	struct rtp_member* sender;

  624. 

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

  626. 	{

  627. 		assert(0);

  628. 		return;

  629. 	}

  630. 

  631. 	msg.type = RTCP_PSFB | (header->rc << 8);

  632. 	msg.ssrc = nbo_r32(ptr);

  633. 	msg.u.psfb.media = nbo_r32(ptr + 4);

  634. 

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

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

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

  638. 

  639. 	r = 0;

  640. 	switch (header->rc)

  641. 	{

  642. 	case RTCP_PSFB_PLI:

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

  644. 		break;

  645. 

  646. 	case RTCP_PSFB_SLI:

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

  648. 		break;

  649. 

  650. 	case RTCP_PSFB_RPSI:

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

  652. 		break;

  653. 

  654. 	case RTCP_PSFB_FIR:

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

  656. 		break;

  657. 

  658. 	case RTCP_PSFB_TSTR:

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

  660. 		break;

  661. 

  662. 	case RTCP_PSFB_TSTN:

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

  664. 		break;

  665. 

  666. 	case RTCP_PSFB_VBCM:

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

  668. 		break;

  669. 

  670. 	case RTCP_PSFB_PSLEI:

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

  672. 		break;

  673. 

  674. 	case RTCP_PSFB_ROI:

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

  676. 		break;

  677. 

  678. 	case RTCP_PSFB_LRR:

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

  680. 		break;

  681. 

  682. 	case RTCP_PSFB_AFB:

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

  684. 		break;

  685. 

  686. 	default:

  687. 		assert(0);

  688. 		r = 0; // ignore

  689. 		break;

  690. 	}

  691. 

  692. 	return;

  693. }

  694. 

  695. int rtcp_psfb_pack(struct rtp_context* ctx, uint8_t* data, int bytes, enum rtcp_psfb_type_t id, const rtcp_psfb_t* psfb)

  696. {

  697. 	int r;

  698. 	rtcp_header_t header;

  699. 

  700. 	(void)ctx;

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

  702. 		return 4 + 4 + 4;

  703. 

  704. 	switch (id)

  705. 	{

  706. 	case RTCP_PSFB_PLI:

  707. 		r = rtcp_psfb_pli_pack(data + 12, bytes - 12);

  708. 		break;

  709. 

  710. 	case RTCP_PSFB_SLI:

  711. 		r = rtcp_psfb_sli_pack(psfb->u.sli.sli, psfb->u.sli.count, data + 12, bytes - 12);

  712. 		break;

  713. 

  714. 	case RTCP_PSFB_RPSI:

  715. 		r = rtcp_psfb_rpsi_pack(psfb->u.rpsi.pt, psfb->u.rpsi.payload, psfb->u.rpsi.len, data + 12, bytes - 12);

  716. 		break;

  717. 

  718. 	case RTCP_PSFB_FIR:

  719. 		r = rtcp_psfb_fir_pack(psfb->u.fir.fir, psfb->u.fir.count, data + 12, bytes - 12);

  720. 		break;

  721. 

  722. 	case RTCP_PSFB_TSTR:

  723. 		r = rtcp_psfb_tstr_pack(psfb->u.fir.fir, psfb->u.fir.count, data + 12, bytes - 12);

  724. 		break;

  725. 

  726. 	case RTCP_PSFB_TSTN:

  727. 		r = rtcp_psfb_tstn_pack(psfb->u.fir.fir, psfb->u.fir.count, data + 12, bytes - 12);

  728. 		break;

  729. 

  730. 	case RTCP_PSFB_VBCM:

  731. 		r = rtcp_psfb_vbcm_pack(&psfb->u.vbcm, data + 12, bytes - 12);

  732. 		break;

  733. 

  734. 	case RTCP_PSFB_PSLEI:

  735. 		r = rtcp_psfb_pslei_pack(psfb->u.pslei.ssrc, psfb->u.pslei.count, data + 12, bytes - 12);

  736. 		break;

  737. 

  738. 	case RTCP_PSFB_LRR:

  739. 		r = rtcp_psfb_lrr_pack(psfb->u.lrr.lrr, psfb->u.lrr.count, data + 12, bytes - 12);

  740. 		break;

  741. 

  742. 	case RTCP_PSFB_REMB:

  743. 		r = rtcp_psfb_remb_pack(psfb->u.afb.remb, psfb->u.afb.count, data + 12, bytes - 12);

  744. 		break;

  745. 

  746. 	case RTCP_PSFB_ROI:

  747. 	default:

  748. 		assert(0);

  749. 		return -1;

  750. 	}

  751. 

  752. 	header.v = 2;

  753. 	header.p = 0;

  754. 	header.pt = RTCP_PSFB;

  755. 	header.rc = id;

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

  757. 	nbo_write_rtcp_header(data, &header);

  758. 

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

  760. 	//nbo_w32(data + 4, psfb->sender);

  761. 	nbo_w32(data + 8, psfb->media);

  762. 

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

  764. 	return header.length * 4 + 4;

  765. }

  766. 

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

  768. static void rtcp_on_psfb_test(void* param, const struct rtcp_msg_t* msg)

  769. {

  770. 	int r;

  771. 	static uint8_t buffer[1400];

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

  773. 	{

  774. 	case RTCP_PSFB:

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

  776. 		{

  777. 		case RTCP_PSFB_PLI:

  778. 			r = rtcp_psfb_pli_pack(buffer, sizeof(buffer));

  779. 			assert(0 == r);

  780. 			break;

  781. 

  782. 		case RTCP_PSFB_FIR:

  783. 			assert(1 == msg->u.psfb.u.fir.count);

  784. 			assert(0x23456789 == msg->u.psfb.u.fir.fir[0].ssrc && 13 == msg->u.psfb.u.fir.fir[0].sn);

  785. 			r = rtcp_psfb_fir_pack(msg->u.psfb.u.fir.fir, msg->u.psfb.u.fir.count, buffer, sizeof(buffer));

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

  787. 			break;

  788. 

  789. 		case RTCP_PSFB_REMB:

  790. 			assert(3 == msg->u.psfb.u.afb.count);

  791. 			assert(0x23456789 == msg->u.psfb.u.afb.remb[0].ssrc && 1 == msg->u.psfb.u.afb.remb[0].exp && 0x3fb93 == msg->u.psfb.u.afb.remb[0].mantissa);

  792. 			assert(0x2345678a == msg->u.psfb.u.afb.remb[1].ssrc && 1 == msg->u.psfb.u.afb.remb[1].exp && 0x3fb93 == msg->u.psfb.u.afb.remb[1].mantissa);

  793. 			assert(0x2345678b == msg->u.psfb.u.afb.remb[2].ssrc && 1 == msg->u.psfb.u.afb.remb[2].exp && 0x3fb93 == msg->u.psfb.u.afb.remb[2].mantissa);

  794. 			r = rtcp_psfb_remb_pack(msg->u.psfb.u.afb.remb, msg->u.psfb.u.afb.count, buffer, sizeof(buffer));

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

  796. 			break;

  797. 

  798. 		default:

  799. 			break;

  800. 		}

  801. 		break;

  802. 

  803. 	default:

  804. 		assert(0);

  805. 	}

  806. }

  807. 

  808. static void rtcp_rtpfb_pli_test(void)

  809. {

  810. 	struct rtcp_msg_t msg;

  811. 	struct rtp_context rtp;

  812. 	rtp.handler.on_rtcp = rtcp_on_psfb_test;

  813. 	rtp.cbparam = NULL;

  814. 

  815. 	msg.type = (RTCP_PSFB_PLI << 8) | RTCP_PSFB;

  816. 	assert(0 == rtcp_psfb_pli_unpack(&rtp, NULL, &msg, NULL, 0));

  817. }

  818. 

  819. static void rtcp_rtpfb_fir_test(void)

  820. {

  821. 	const uint8_t data[] = { 0x23, 0x45, 0x67, 0x89, 0x0d, 0x00, 0x00, 0x00 };

  822. 

  823. 	struct rtcp_msg_t msg;

  824. 	struct rtp_context rtp;

  825. 	rtp.handler.on_rtcp = rtcp_on_psfb_test;

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

  827. 

  828. 	msg.type = (RTCP_PSFB_FIR << 8) | RTCP_PSFB;

  829. 	assert(0 == rtcp_psfb_fir_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  830. }

  831. 

  832. static void rtcp_rtpfb_remb_test(void)

  833. {

  834. 	const uint8_t data[] = { 'R', 'E', 'M', 'B', 0x03, 0x07, 0xfb, 0x93, 0x23, 0x45, 0x67, 0x89, 0x23, 0x45, 0x67, 0x8a, 0x23, 0x45, 0x67, 0x8b };

  835. 

  836. 	struct rtcp_msg_t msg;

  837. 	struct rtp_context rtp;

  838. 	rtp.handler.on_rtcp = rtcp_on_psfb_test;

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

  840. 

  841. 	msg.type = (RTCP_PSFB_REMB << 8) | RTCP_PSFB;

  842. 	assert(0 == rtcp_psfb_afb_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  843. }

  844. 

  845. void rtcp_psfb_test(void)

  846. {

  847. 	rtcp_rtpfb_pli_test();

  848. 	rtcp_rtpfb_fir_test();

  849. 	rtcp_rtpfb_remb_test();

  850. }

  851. #endif