huangxiyun
/
ZLKMedia
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
1 Revize
1 Větev
21MB
Strom: 339c93e477
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „339c93e477“
${ noResults }
ZLKMedia/3rdpart/media-server/librtp/source/rtcp-xr.c

769 řádky
26KB
Surový Blame Historie 

  1. #include "rtp-internal.h"

  2. #include "rtp-util.h"

  3. #include <errno.h>

  4. 

  5. // https://www.iana.org/assignments/rtcp-xr-block-types/rtcp-xr-block-types.xhtml

  6. /*

  7.     BT 	    Name 	                                        Reference

  8.     1	    Loss RLE Report Block	                        [RFC3611]

  9.     2	    Duplicate RLE Report Block	                    [RFC3611]

  10.     3	    Packet Receipt Times Report Block	            [RFC3611]

  11.     4	    Receiver Reference Time Report Block	        [RFC3611]

  12.     5	    DLRR Report Block	                            [RFC3611]

  13.     6	    Statistics Summary Report Block	                [RFC3611]

  14.     7	    VoIP Metrics Report Block	                    [RFC3611]

  15.     8	    RTCP XR	                                        [RFC5093]

  16.     9	    Texas Instruments Extended VoIP Quality Block	[http://focus.ti.com/general/docs/bcg/bcgdoccenter.tsp?templateId=6116&navigationId=12078#42][David_Lide]

  17.     10	    Post-repair Loss RLE Report Block	            [RFC5725]

  18.     11	    Multicast Acquisition Report Block	            [RFC6332]

  19.     12	    IDMS Report Block	                            [RFC7272]

  20.     13	    ECN Summary Report	                            [RFC6679]

  21.     14	    Measurement Information Block	                [RFC6776]

  22.     15	    Packet Delay Variation Metrics Block	        [RFC6798]

  23.     16	    Delay Metrics Block	                            [RFC6843]

  24.     17	    Burst/Gap Loss Summary Statistics Block	        [RFC7004]

  25.     18	    Burst/Gap Discard Summary Statistics Block	    [RFC7004]

  26.     19	    Frame Impairment Statistics Summary	            [RFC7004]

  27.     20	    Burst/Gap Loss Metrics Block	                [RFC6958]

  28.     21	    Burst/Gap Discard Metrics Block	                [RFC7003][RFC Errata 3735]

  29.     22	    MPEG2 Transport Stream PSI-Independent Decodability Statistics Metrics Block	[RFC6990]

  30.     23	    De-Jitter Buffer Metrics Block	                [RFC7005]

  31.     24	    Discard Count Metrics Block	                    [RFC7002]

  32.     25	    DRLE (Discard RLE Report)	                    [RFC7097]

  33.     26	    BDR (Bytes Discarded Report)	                [RFC7243]

  34.     27	    RFISD (RTP Flows Initial Synchronization Delay)	[RFC7244]

  35.     28	    RFSO (RTP Flows Synchronization Offset Metrics Block)	[RFC7244]

  36.     29	    MOS Metrics Block	                            [RFC7266]

  37.     30	    LCB (Loss Concealment Metrics Block)	        [RFC7294, Section 4.1]

  38.     31	    CSB (Concealed Seconds Metrics Block)	        [RFC7294, Section 4.1]

  39.     32	    MPEG2 Transport Stream PSI Decodability Statistics Metrics Block	[RFC7380]

  40.     33	    Post-Repair Loss Count Metrics Report Block	    [RFC7509]

  41.     34	    Video Loss Concealment Metric Report Block	    [RFC7867]

  42.     35	    Independent Burst/Gap Discard Metrics Block	    [RFC8015]

  43.     36-254  Unassigned

  44.     255	    Reserved for future extensions	                [RFC3611]

  45. */

  46. 

  47. /*

  48. Parameter 	Reference

  49. pkt-loss-rle	[RFC3611]

  50. pkt-dup-rle	[RFC3611]

  51. pkt-rcpt-times	[RFC3611]

  52. stat-summary	[RFC3611]

  53. voip-metrics	[RFC3611]

  54. rcvr-rtt	[RFC3611]

  55. post-repair-loss-rle	[RFC5725]

  56. grp-sync	[http://www.etsi.org/deliver/etsi_ts/183000_183099/183063/][ETSI 183 063][Miguel_Angel_Reina_Ortega]

  57. multicast-acq	[RFC6332]

  58. ecn-sum	[RFC6679]

  59. pkt-dly-var	[RFC6798]

  60. delay	[RFC6843]

  61. burst-gap-loss-stat	[RFC7004]

  62. burst-gap-discard-stat	[RFC7004]

  63. frame-impairment-stat	[RFC7004]

  64. burst-gap-loss	[RFC6958]

  65. burst-gap-discard	[RFC7003]

  66. ts-psi-indep-decodability	[RFC6990]

  67. de-jitter-buffer	[RFC7005]

  68. pkt-discard-count	[RFC7002]

  69. discard-rle	[RFC7097]

  70. discard-bytes	[RFC7243]

  71. rtp-flow-init-syn-delay	[RFC7244]

  72. rtp-flow-syn-offset	[RFC7244]

  73. mos-metric	[RFC7266]

  74. loss-conceal	[RFC7294]

  75. conc-sec	[RFC7294]

  76. ts-psi-decodability	[RFC7380]

  77. post-repair-loss-count	[RFC7509]

  78. video-loss-concealment	[RFC7867]

  79. ind-burst-gap-discard	[RFC8015]

  80. */

  81. 

  82. static int rtcp_xr_rrt_pack(uint64_t ntp, uint8_t* ptr, uint32_t bytes);

  83. static int rtcp_xr_dlrr_pack(const rtcp_dlrr_t* dlrr, int count, uint8_t* ptr, uint32_t bytes);

  84. static int rtcp_xr_ecn_pack(const rtcp_ecn_t* ecn, uint8_t* ptr, uint32_t bytes);

  85. 

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

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

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

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

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

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

  92. 

  93. 

  94. // https://www.rfc-editor.org/rfc/rfc3611.html#section-4.1

  95. /*

  96.     0                   1                   2                   3

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

  98.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  99.    |     BT=1      | rsvd. |   T   |         block length          |

  100.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  101.    |                        SSRC of source                         |

  102.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  103.    |          begin_seq            |             end_seq           |

  104.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  105.    |          chunk 1              |             chunk 2           |

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

  107.    :                              ...                              :

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

  109.    |          chunk n-1            |             chunk n           |

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

  111. */

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

  113. {

  114.     uint32_t i, j;

  115.     uint32_t source;

  116.     uint32_t len, num;

  117.     uint16_t seq, end;

  118.     uint32_t chunk;

  119.     uint8_t* v, v0[32];

  120. 

  121.     len = nbo_r16(ptr + 2);

  122. 

  123.     if (bytes < 8 || (len + 1) * 4 > bytes)

  124.         return -1;

  125. 

  126.     len *= 4; // to bytes

  127.     if (len < 8)

  128.         return 0;

  129. 

  130.     source = nbo_r32(ptr + 4);

  131.     seq = nbo_r16(ptr + 8);

  132.     end = nbo_r16(ptr + 10);

  133.     num = end - seq;

  134. 

  135.     if ((num + 7) / 8 > sizeof(v0))

  136.     {

  137.         v = calloc((num + 7) / 8, sizeof(*v));

  138.         if (!v) return -ENOMEM;

  139.     }

  140.     else

  141.     {

  142.         v = v0;

  143.         memset(v, 0, (num + 7) / 8 * sizeof(v[0]));

  144.     }

  145. 

  146.     ptr += 8;

  147.     len -= 8;

  148.     for(i = 0; len > 2; ptr += 2, len -= 2)

  149.     {

  150.         chunk = nbo_r16(ptr);

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

  152.         {

  153.             // Run Length Chunk

  154.             for (j = 0; j < (chunk & 0x3FFF) && i < num; j++, i++)

  155.             {

  156.                 if(0x4000 & chunk)

  157.                     v[i/8] |= 1 << (7-(i%8));

  158.             }

  159.         }

  160.         else

  161.         {

  162.             // Bit Vector Chunk

  163.             for (j = 0; j < 15 && i < num; j++, i++)

  164.             {

  165.                 if (chunk & (1 << (14 - j)))

  166.                     v[i / 8] |= 1 << (7 - (i % 8));

  167.             }

  168.         }

  169.     }

  170. 

  171.     msg->u.xr.u.rle.source = source;

  172.     msg->u.xr.u.rle.begin = seq;

  173.     msg->u.xr.u.rle.end = end;

  174.     msg->u.xr.u.rle.chunk = v;

  175.     msg->u.xr.u.rle.count = num;

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

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

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

  179.         free(v);

  180.     return 0;

  181. }

  182. 

  183. // https://www.rfc-editor.org/rfc/rfc3611.html#section-4.2

  184. /*

  185.     0                   1                   2                   3

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

  187.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  188.    |     BT=2      | rsvd. |   T   |         block length          |

  189.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  190.    |                        SSRC of source                         |

  191.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  192.    |          begin_seq            |             end_seq           |

  193.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  194.    |          chunk 1              |             chunk 2           |

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

  196.    :                              ...                              :

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

  198.    |          chunk n-1            |             chunk n           |

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

  200. */

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

  202. {

  203.     uint32_t i, j;

  204.     uint32_t source;

  205.     uint32_t len, num;

  206.     uint16_t seq, end;

  207.     uint32_t chunk;

  208.     uint8_t* v, v0[32];

  209. 

  210.     len = nbo_r16(ptr + 2);

  211. 

  212.     if (bytes < 8 || (len + 1) * 4 > bytes)

  213.         return -1;

  214. 

  215.     len *= 4; // to bytes

  216.     if (len < 8)

  217.         return 0;

  218. 

  219.     source = nbo_r32(ptr + 4);

  220.     seq = nbo_r16(ptr + 8);

  221.     end = nbo_r16(ptr + 10);

  222.     num = end - seq;

  223. 

  224.     if ((num + 7) / 8 > sizeof(v0))

  225.     {

  226.         v = calloc((num + 7) / 8, sizeof(*v));

  227.         if (!v) return -ENOMEM;

  228.     }

  229.     else

  230.     {

  231.         v = v0;

  232.         memset(v, 0, (num + 7) / 8 * sizeof(v[0]));

  233.     }

  234. 

  235.     ptr += 8;

  236.     len -= 8;

  237.     for (i = 0; len > 2; ptr += 2, len -= 2)

  238.     {

  239.         chunk = nbo_r16(ptr);

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

  241.         {

  242.             // Run Length Chunk

  243.             for (j = 0; j < (chunk & 0x3FFF) && i < num; j++, i++)

  244.             {

  245.                 if (0x4000 & chunk)

  246.                     v[i / 8] |= 1 << (7 - (i % 8));

  247.             }

  248.         }

  249.         else

  250.         {

  251.             // Bit Vector Chunk

  252.             for (j = 0; j < 15 && i < num; j++, i++)

  253.             {

  254.                 if (chunk & (1 << (14 - j)))

  255.                     v[i / 8] |= 1 << (7 - (i % 8));

  256.             }

  257.         }

  258.     }

  259. 

  260.     msg->u.xr.u.rle.source = source;

  261.     msg->u.xr.u.rle.begin = seq;

  262.     msg->u.xr.u.rle.end = end;

  263.     msg->u.xr.u.rle.chunk = v;

  264.     msg->u.xr.u.rle.count = num;

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

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

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

  268.         free(v);

  269.     return 0;

  270. }

  271. 

  272. 

  273. // https://www.rfc-editor.org/rfc/rfc3611.html#section-4.3

  274. /*

  275.     0                   1                   2                   3

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

  277.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  278.    |     BT=3      | rsvd. |   T   |         block length          |

  279.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  280.    |                        SSRC of source                         |

  281.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  282.    |          begin_seq            |             end_seq           |

  283.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  284.    |       Receipt time of packet begin_seq                        |

  285.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  286.    |       Receipt time of packet (begin_seq + 1) mod 65536        |

  287.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  288.    :                              ...                              :

  289.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  290.    |       Receipt time of packet (end_seq - 1) mod 65536          |

  291.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  292. */

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

  294. {

  295.     uint32_t i;

  296.     uint32_t source;

  297.     uint32_t len, num;

  298.     uint16_t seq, end;

  299.     uint32_t* timestamp, timestamp0[32];

  300. 

  301.     len = nbo_r16(ptr + 2);

  302. 

  303.     if (bytes < 8 || (len + 1) * 4 > bytes)

  304.         return -1;

  305. 

  306.     len *= 4; // to bytes

  307.     if (len < 8)

  308.         return 0;

  309. 

  310.     source = nbo_r32(ptr + 4);

  311.     seq = nbo_r16(ptr + 8);

  312.     end = nbo_r16(ptr + 10);

  313.     num = end - seq;

  314. 

  315.     if (num > sizeof(timestamp0)/sizeof(timestamp0[0]))

  316.     {

  317.         timestamp = calloc(num, sizeof(*timestamp));

  318.         if (!timestamp) return -ENOMEM;

  319.     }

  320.     else

  321.     {

  322.         timestamp = timestamp0;

  323.         memset(timestamp, 0, num * sizeof(timestamp[0]));

  324.     }

  325. 

  326.     ptr += 8;

  327.     len -= 8;

  328.     for (i = 0; len > 4; ptr += 4, len -= 4)

  329.     {

  330.         timestamp[i] = nbo_r32(ptr);

  331.     }

  332. 

  333.     msg->u.xr.u.prt.source = source;

  334.     msg->u.xr.u.prt.begin = seq;

  335.     msg->u.xr.u.prt.end = end;

  336.     msg->u.xr.u.prt.timestamp = timestamp;

  337.     msg->u.xr.u.prt.count = num;

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

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

  340.     if (timestamp && timestamp != timestamp0)

  341.         free(timestamp);

  342.     return 0;

  343. }

  344. 

  345. 

  346. // https://www.rfc-editor.org/rfc/rfc3611.html#section-4.4

  347. /*

  348.     0                   1                   2                   3

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

  350.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  351.    |     BT=4      |   reserved    |       block length = 2        |

  352.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  353.    |              NTP timestamp, most significant word             |

  354.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  355.    |             NTP timestamp, least significant word             |

  356.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  357. */

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

  359. {

  360.     uint32_t len;

  361.     uint64_t ntp;

  362. 

  363.     len = nbo_r16(ptr + 2);

  364. 

  365.     if (bytes < 12 || (len + 1) * 4 > bytes)

  366.         return -1;

  367. 

  368.     ntp = nbo_r32(ptr + 4);

  369.     ntp = (ntp << 32) | nbo_r32(ptr + 8);

  370. 

  371.     msg->u.xr.u.rrt = ntp;

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

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

  374.     return 0;

  375. }

  376. 

  377. static int rtcp_xr_rrt_pack(uint64_t ntp, uint8_t* ptr, uint32_t bytes)

  378. {

  379.     if (bytes < 12)

  380.         return -1;

  381. 

  382.     nbo_w32(ptr, (RTCP_XR_RRT << 24) | 2);

  383.     nbo_w32(ptr + 4, (uint32_t)(ntp >> 32));

  384.     nbo_w32(ptr + 8, (uint32_t)ntp);

  385.     return 12;

  386. }

  387. 

  388. // https://www.rfc-editor.org/rfc/rfc3611.html#section-4.5

  389. /*

  390.   0                   1                   2                   3

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

  392.  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  393.  |     BT=5      |   reserved    |         block length          |

  394.  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+

  395.  |                 SSRC_1 (SSRC of first receiver)               | sub-

  396.  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block

  397.  |                         last RR (LRR)                         |   1

  398.  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  399.  |                   delay since last RR (DLRR)                  |

  400.  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+

  401.  |                 SSRC_2 (SSRC of second receiver)              | sub-

  402.  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block

  403.  :                               ...                             :   2

  404.  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+

  405. */

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

  407. {

  408.     uint32_t i;

  409.     uint32_t len, num;

  410.     rtcp_dlrr_t* dlrr, dlrr0[32];

  411. 

  412.     len = nbo_r16(ptr + 2);

  413.     if (bytes < 8 || (len + 1) * 4 > bytes)

  414.         return -1;

  415. 

  416.     num = len / 3;

  417.     if (num > sizeof(dlrr0))

  418.     {

  419.         dlrr = calloc(num, sizeof(*dlrr));

  420.         if (!dlrr) return -ENOMEM;

  421.     }

  422.     else

  423.     {

  424.         dlrr = dlrr0;

  425.         memset(dlrr, 0, num * sizeof(dlrr[0]));

  426.     }

  427. 

  428.     ptr += 4;

  429.     for (i = 0; i < num; i++, ptr += 12)

  430.     {

  431.         dlrr[i].ssrc = nbo_r32(ptr + 0);

  432.         dlrr[i].lrr = nbo_r32(ptr + 4);

  433.         dlrr[i].dlrr = nbo_r32(ptr + 8);

  434.     }

  435. 

  436.     msg->u.xr.u.dlrr.dlrr = dlrr;

  437.     msg->u.xr.u.dlrr.count = num;

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

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

  440.     if (dlrr && dlrr != dlrr0)

  441.         free(dlrr);

  442.     return 0;

  443. }

  444. 

  445. static int rtcp_xr_dlrr_pack(const rtcp_dlrr_t* dlrr, int count, uint8_t* ptr, uint32_t bytes)

  446. {

  447.     int i;

  448.     if ((int)bytes < 4 + count * 12)

  449.         return - 1;

  450. 

  451.     nbo_w32(ptr, (RTCP_XR_DLRR << 24) | (count * 3));

  452.     bytes -= 4;

  453.     ptr += 4;

  454. 

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

  456.     {

  457.         nbo_w32(ptr, dlrr[i].ssrc);

  458.         nbo_w32(ptr + 4, dlrr[i].lrr);

  459.         nbo_w32(ptr + 8, dlrr[i].dlrr);

  460. 

  461.         bytes -= 12;

  462.         ptr += 12;

  463.     }

  464.     return 4 + i * 12;

  465. }

  466. 

  467. // https://www.rfc-editor.org/rfc/rfc7097.html#section-5

  468. // rtcp-xr: discard-rle

  469. /*

  470.        0               1               2               3

  471.        0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7

  472.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  473.       |     BT=25     |rsvd |E|   T   |         block length          |

  474.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  475.       |                        SSRC of source                         |

  476.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  477.       |          begin_seq            |             end_seq           |

  478.       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  479.       |          chunk 1              |             chunk 2           |

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

  481.       :                              ...                              :

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

  483.       |          chunk n-1            |             chunk n           |

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

  485. */

  486. 

  487. 

  488. // https://datatracker.ietf.org/doc/html/rfc7243#section-5

  489. // rtcp-xr: discard-bytes

  490. /*

  491.     0               1               2               3

  492.     0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7

  493.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  494.    |     BT=26     | I |E|Reserved |       Block length=2          |

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

  496.    |                        SSRC of source                         |

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

  498.    |             Number of RTP payload bytes discarded             |

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

  500. */

  501. 

  502. // https://www.rfc-editor.org/rfc/rfc6679.html#section-5.2

  503. /*

  504.     0                   1                   2                   3

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

  506.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  507.    |     BT=13     | Reserved      |         Block Length          |

  508.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  509.    | SSRC of Media Sender                                          |

  510.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  511.    | ECT (0) Counter                                               |

  512.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  513.    | ECT (1) Counter                                               |

  514.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

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

  516.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  517.    | Lost Packets Counter          | Duplication Counter           |

  518.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  519. 

  520.                    Figure 4: RTCP XR ECN Summary Report

  521. */

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

  523. {

  524.     uint32_t len;

  525.     rtcp_ecn_t ecn;

  526.     

  527.     len = nbo_r16(ptr + 2);

  528.     if (bytes < 24 || (len + 1) * 4 > bytes)

  529.         return -1;

  530.     

  531.     ecn.ext_highest_seq = nbo_r32(ptr); // ssrc

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

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

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

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

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

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

  538. 

  539.     memcpy(&msg->u.xr.u.ecn, &ecn, sizeof(msg->u.xr.u.ecn));

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

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

  542.     return 0;

  543. }

  544. 

  545. static int rtcp_xr_ecn_pack(const rtcp_ecn_t* ecn, uint8_t* ptr, uint32_t bytes)

  546. {

  547.     if (bytes < 24)

  548.         return -1;

  549. 

  550.     nbo_w32(ptr, (RTCP_XR_ECN << 24) | 5);

  551.     nbo_w32(ptr + 4, ecn->ext_highest_seq);

  552.     nbo_w32(ptr + 8, ecn->ect[0]);

  553.     nbo_w32(ptr + 12, ecn->ect[1]);

  554.     nbo_w16(ptr + 16, ecn->ect_ce_counter);

  555.     nbo_w16(ptr + 18, ecn->not_ect_counter);

  556.     nbo_w16(ptr + 20, ecn->lost_packets_counter);

  557.     nbo_w16(ptr + 22, ecn->duplication_counter);

  558.     return 24;

  559. }

  560. 

  561. /*

  562.     0                   1                   2                   3

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

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

  565.    |V=2|P|reserved |   PT=XR=207   |             length            |

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

  567.    |                              SSRC                             |

  568.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  569.    :                         report blocks                         :

  570.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  571. 

  572. 

  573.     0                   1                   2                   3

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

  575.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  576.    |      BT       | type-specific |         block length          |

  577.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  578.    :             type-specific block contents                      :

  579.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  580. */

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

  582. {

  583.     int r;

  584.     struct rtcp_msg_t msg;

  585.     struct rtp_member* sender;

  586. 

  587.     if (bytes < 8 /*sizeof(rtcp_xr_t)*/)

  588.     {

  589.         assert(0);

  590.         return;

  591.     }

  592. 

  593.     msg.ssrc = nbo_r32(ptr);

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

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

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

  597. 

  598.     r = 0;

  599.     ptr += 4;

  600.     bytes -= 4;

  601.     while (bytes >= 4)

  602.     {

  603.         msg.type = RTCP_XR | (ptr[0] << 8);

  604. 

  605.         switch (ptr[0])

  606.         {

  607.         case RTCP_XR_LRLE:

  608.             r = rtcp_xr_lrle_unpack(ctx, header, &msg, ptr, bytes);

  609.             break;

  610. 

  611.         case RTCP_XR_DRLE:

  612.             r = rtcp_xr_drle_unpack(ctx, header, &msg, ptr, bytes);

  613.             break;

  614. 

  615.         case RTCP_XR_PRT:

  616.             r = rtcp_xr_prt_unpack(ctx, header, &msg, ptr, bytes);

  617.             break;

  618. 

  619.         case RTCP_XR_RRT:

  620.             r = rtcp_xr_rrt_unpack(ctx, header, &msg, ptr, bytes);

  621.             break;

  622. 

  623.         case RTCP_XR_DLRR:

  624.             r = rtcp_xr_dlrr_unpack(ctx, header, &msg, ptr, bytes);

  625.             break;

  626. 

  627.         case RTCP_XR_ECN:

  628.             r = rtcp_xr_ecn_unpack(ctx, header, &msg, ptr, bytes);

  629.             break;

  630. 

  631.         default:

  632.             //assert(0);

  633.             r = 0; // ignore

  634.             break;

  635.         }

  636.     }

  637. 

  638.     return;

  639. }

  640. 

  641. int rtcp_xr_pack(struct rtp_context* ctx, uint8_t* data, int bytes, enum rtcp_xr_type_t id, const rtcp_xr_t* xr)

  642. {

  643.     int r;

  644.     rtcp_header_t header;

  645. 

  646.     (void)ctx;

  647.     if (bytes < 4 + 4)

  648.         return 4 + 4;

  649. 

  650.     switch (id)

  651.     {

  652.     case RTCP_XR_RRT:

  653.         r = rtcp_xr_rrt_pack(xr->u.rrt, data + 8, bytes - 8);

  654.         break;

  655. 

  656.     case RTCP_XR_DLRR:

  657.         r = rtcp_xr_dlrr_pack(xr->u.dlrr.dlrr, xr->u.dlrr.count, data + 8, bytes - 8);

  658.         break;

  659. 

  660.     case RTCP_XR_ECN:

  661.         r = rtcp_xr_ecn_pack(&xr->u.ecn, data + 8, bytes - 8);

  662.         break;

  663. 

  664.     case RTCP_XR_LRLE:

  665.     case RTCP_XR_DRLE:

  666.     case RTCP_XR_PRT:

  667.     default:

  668.         assert(0);

  669.         return -1;

  670.     }

  671. 

  672.     header.v = 2;

  673.     header.p = 0;

  674.     header.pt = RTCP_XR;

  675.     header.rc = id;

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

  677.     nbo_write_rtcp_header(data, &header);

  678. 

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

  680.     //nbo_w32(data + 4, xr->sender);

  681. 

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

  683.     return header.length * 4 + 4;

  684. }

  685. 

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

  687. static void rtcp_on_xr_test(void* param, const struct rtcp_msg_t* msg)

  688. {

  689.     int r;

  690.     static uint8_t buffer[1400];

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

  692.     {

  693.     case RTCP_XR:

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

  695.         {

  696.         case RTCP_XR_RRT:

  697.             assert(0x1234567823456789 == msg->u.xr.u.rrt);

  698.             r = rtcp_xr_rrt_pack(msg->u.xr.u.rrt, buffer, sizeof(buffer));

  699.             assert(12 == r && 0 == memcmp(buffer, param, r));

  700.             break;

  701. 

  702.         case RTCP_XR_DLRR:

  703.             assert(1 == msg->u.xr.u.dlrr.count);

  704.             assert(0x12345678 == msg->u.xr.u.dlrr.dlrr[0].ssrc && 0x23344556 == msg->u.xr.u.dlrr.dlrr[0].lrr && 0x33343536 == msg->u.xr.u.dlrr.dlrr[0].dlrr);

  705.             r = rtcp_xr_dlrr_pack(msg->u.xr.u.dlrr.dlrr, msg->u.xr.u.dlrr.count, buffer, sizeof(buffer));

  706.             assert(16 == r && 0 == memcmp(buffer, param, r));

  707.             break;

  708. 

  709.         case RTCP_XR_ECN:

  710.             r = rtcp_xr_ecn_pack(&msg->u.xr.u.ecn, buffer, sizeof(buffer));

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

  712. 

  713.         default:

  714.             break;

  715.         }

  716.         break;

  717. 

  718.     default:

  719.         assert(0);

  720.     }

  721. }

  722. 

  723. static void rtcp_rtpfb_rrt_test(void)

  724. {

  725.     const uint8_t data[] = { 0x04, 0x00, 0x00, 0x02, 0x12, 0x34, 0x56, 0x78, 0x23, 0x45, 0x67, 0x89 };

  726. 

  727.     struct rtcp_msg_t msg;

  728.     struct rtp_context rtp;

  729.     rtp.handler.on_rtcp = rtcp_on_xr_test;

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

  731. 

  732.     msg.type = (RTCP_XR_RRT << 8) | RTCP_XR;

  733.     assert(0 == rtcp_xr_rrt_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  734. }

  735. 

  736. static void rtcp_rtpfb_dlrr_test(void)

  737. {

  738.     const uint8_t data[] = { 0x05, 0x00, 0x00, 0x03, 0x12, 0x34, 0x56, 0x78, 0x23, 0x34, 0x45, 0x56, 0x33, 0x34, 0x35, 0x36 };

  739. 

  740.     struct rtcp_msg_t msg;

  741.     struct rtp_context rtp;

  742.     rtp.handler.on_rtcp = rtcp_on_xr_test;

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

  744. 

  745.     msg.type = (RTCP_XR_DLRR << 8) | RTCP_XR;

  746.     assert(0 == rtcp_xr_dlrr_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  747. }

  748. 

  749. static void rtcp_rtpfb_ecn_test(void)

  750. {

  751.     const uint8_t data[] = { 0x00 };

  752. 

  753.     struct rtcp_msg_t msg;

  754.     struct rtp_context rtp;

  755.     rtp.handler.on_rtcp = rtcp_on_xr_test;

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

  757. 

  758.     msg.type = (RTCP_XR_ECN << 8) | RTCP_XR;

  759.     assert(0 == rtcp_xr_ecn_unpack(&rtp, NULL, &msg, data, sizeof(data)));

  760. }

  761. 

  762. void rtcp_xr_test(void)

  763. {

  764.     rtcp_rtpfb_rrt_test();

  765.     rtcp_rtpfb_dlrr_test();

  766.     //rtcp_rtpfb_ecn_test();

  767. }

  768. #endif