libavformat/rtpdec.c

   1 /*
   2  * RTP input format
   3  * Copyright (c) 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/mathematics.h"
  23 #include "libavutil/avstring.h"
  24 #include "libavutil/intreadwrite.h"
  25 #include "libavutil/mem.h"
  26 #include "libavutil/time.h"
  27
  28 #include "libavcodec/bytestream.h"
  29
  30 #include "avformat.h"
  31 #include "network.h"
  32 #include "srtp.h"
  33 #include "url.h"
  34 #include "rtpdec.h"
  35 #include "rtpdec_formats.h"
  36 #include "internal.h"
  37
  38 #define MIN_FEEDBACK_INTERVAL 200000 /* 200 ms in us */
  39
  40 static const RTPDynamicProtocolHandler l24_dynamic_handler = {
  41     .enc_name   = "L24",
  42     .codec_type = AVMEDIA_TYPE_AUDIO,
  43     .codec_id   = AV_CODEC_ID_PCM_S24BE,
  44 };
  45
  46 static const RTPDynamicProtocolHandler gsm_dynamic_handler = {
  47     .enc_name   = "GSM",
  48     .codec_type = AVMEDIA_TYPE_AUDIO,
  49     .codec_id   = AV_CODEC_ID_GSM,
  50 };
  51
  52 static const RTPDynamicProtocolHandler realmedia_mp3_dynamic_handler = {
  53     .enc_name   = "X-MP3-draft-00",
  54     .codec_type = AVMEDIA_TYPE_AUDIO,
  55     .codec_id   = AV_CODEC_ID_MP3ADU,
  56 };
  57
  58 static const RTPDynamicProtocolHandler speex_dynamic_handler = {
  59     .enc_name   = "speex",
  60     .codec_type = AVMEDIA_TYPE_AUDIO,
  61     .codec_id   = AV_CODEC_ID_SPEEX,
  62 };
  63
  64 static const RTPDynamicProtocolHandler t140_dynamic_handler = { /* RFC 4103 */
  65     .enc_name   = "t140",
  66     .codec_type = AVMEDIA_TYPE_SUBTITLE,
  67     .codec_id   = AV_CODEC_ID_TEXT,
  68 };
  69
  70 extern const RTPDynamicProtocolHandler ff_rdt_video_handler;
  71 extern const RTPDynamicProtocolHandler ff_rdt_audio_handler;
  72 extern const RTPDynamicProtocolHandler ff_rdt_live_video_handler;
  73 extern const RTPDynamicProtocolHandler ff_rdt_live_audio_handler;
  74
  75 static const RTPDynamicProtocolHandler *const rtp_dynamic_protocol_handler_list[] = {
  76     /* rtp */
  77     &ff_ac3_dynamic_handler,
  78     &ff_amr_nb_dynamic_handler,
  79     &ff_amr_wb_dynamic_handler,
  80     &ff_av1_dynamic_handler,
  81     &ff_dv_dynamic_handler,
  82     &ff_g726_16_dynamic_handler,
  83     &ff_g726_24_dynamic_handler,
  84     &ff_g726_32_dynamic_handler,
  85     &ff_g726_40_dynamic_handler,
  86     &ff_g726le_16_dynamic_handler,
  87     &ff_g726le_24_dynamic_handler,
  88     &ff_g726le_32_dynamic_handler,
  89     &ff_g726le_40_dynamic_handler,
  90     &ff_h261_dynamic_handler,
  91     &ff_h263_1998_dynamic_handler,
  92     &ff_h263_2000_dynamic_handler,
  93     &ff_h263_rfc2190_dynamic_handler,
  94     &ff_h264_dynamic_handler,
  95     &ff_hevc_dynamic_handler,
  96     &ff_ilbc_dynamic_handler,
  97     &ff_jpeg_dynamic_handler,
  98     &ff_mp4a_latm_dynamic_handler,
  99     &ff_mp4v_es_dynamic_handler,
 100     &ff_mpeg_audio_dynamic_handler,
 101     &ff_mpeg_audio_robust_dynamic_handler,
 102     &ff_mpeg_video_dynamic_handler,
 103     &ff_mpeg4_generic_dynamic_handler,
 104     &ff_mpegts_dynamic_handler,
 105     &ff_ms_rtp_asf_pfa_handler,
 106     &ff_ms_rtp_asf_pfv_handler,
 107     &ff_qcelp_dynamic_handler,
 108     &ff_qdm2_dynamic_handler,
 109     &ff_qt_rtp_aud_handler,
 110     &ff_qt_rtp_vid_handler,
 111     &ff_quicktime_rtp_aud_handler,
 112     &ff_quicktime_rtp_vid_handler,
 113     &ff_rfc4175_rtp_handler,
 114     &ff_svq3_dynamic_handler,
 115     &ff_theora_dynamic_handler,
 116     &ff_vc2hq_dynamic_handler,
 117     &ff_vorbis_dynamic_handler,
 118     &ff_vp8_dynamic_handler,
 119     &ff_vp9_dynamic_handler,
 120     &gsm_dynamic_handler,
 121     &l24_dynamic_handler,
 122     &ff_opus_dynamic_handler,
 123     &realmedia_mp3_dynamic_handler,
 124     &speex_dynamic_handler,
 125     &t140_dynamic_handler,
 126     /* rdt */
 127     &ff_rdt_video_handler,
 128     &ff_rdt_audio_handler,
 129     &ff_rdt_live_video_handler,
 130     &ff_rdt_live_audio_handler,
 131     NULL,
 132 };
 133
 134 /**
 135  * Iterate over all registered rtp dynamic protocol handlers.
 136  *
 137  * @param opaque a pointer where libavformat will store the iteration state.
 138  *               Must point to NULL to start the iteration.
 139  *
 140  * @return the next registered rtp dynamic protocol handler
 141  *         or NULL when the iteration is finished
 142  */
 143 static const RTPDynamicProtocolHandler *rtp_handler_iterate(void **opaque)
 144 {
 145     uintptr_t i = (uintptr_t)*opaque;
 146     const RTPDynamicProtocolHandler *r = rtp_dynamic_protocol_handler_list[i];
 147
 148     if (r)
 149         *opaque = (void*)(i + 1);
 150
 151     return r;
 152 }
 153
 154 const RTPDynamicProtocolHandler *ff_rtp_handler_find_by_name(const char *name,
 155                                                        enum AVMediaType codec_type)
 156 {
 157     void *i = 0;
 158     const RTPDynamicProtocolHandler *handler;
 159     while (handler = rtp_handler_iterate(&i)) {
 160         if (handler->enc_name &&
 161             !av_strcasecmp(name, handler->enc_name) &&
 162             codec_type == handler->codec_type)
 163             return handler;
 164     }
 165     return NULL;
 166 }
 167
 168 const RTPDynamicProtocolHandler *ff_rtp_handler_find_by_id(int id,
 169                                                      enum AVMediaType codec_type)
 170 {
 171     void *i = 0;
 172     const RTPDynamicProtocolHandler *handler;
 173     while (handler = rtp_handler_iterate(&i)) {
 174         if (handler->static_payload_id && handler->static_payload_id == id &&
 175             codec_type == handler->codec_type)
 176             return handler;
 177     }
 178     return NULL;
 179 }
 180
 181 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf,
 182                              int len)
 183 {
 184     int payload_len;
 185     while (len >= 4) {
 186         payload_len = FFMIN(len, (AV_RB16(buf + 2) + 1) * 4);
 187
 188         switch (buf[1]) {
 189         case RTCP_SR:
 190             if (payload_len < 28) {
 191                 av_log(s->ic, AV_LOG_ERROR, "Invalid RTCP SR packet length\n");
 192                 return AVERROR_INVALIDDATA;
 193             }
 194
 195             s->last_sr.ssrc = AV_RB32(buf + 4);
 196             s->last_sr.ntp_timestamp = AV_RB64(buf + 8);
 197             s->last_sr.rtp_timestamp = AV_RB32(buf + 16);
 198             s->last_sr.sender_nb_packets = AV_RB32(buf + 20);
 199             s->last_sr.sender_nb_bytes = AV_RB32(buf + 24);
 200
 201             s->pending_sr = 1;
 202             s->last_rtcp_reception_time = av_gettime_relative();
 203
 204             if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
 205                 s->first_rtcp_ntp_time = s->last_sr.ntp_timestamp;
 206                 if (!s->base_timestamp)
 207                     s->base_timestamp = s->last_sr.rtp_timestamp;
 208                 s->rtcp_ts_offset = (int32_t)(s->last_sr.rtp_timestamp - s->base_timestamp);
 209             }
 210
 211             break;
 212         case RTCP_BYE:
 213             return -RTCP_BYE;
 214         }
 215
 216         buf += payload_len;
 217         len -= payload_len;
 218     }
 219     return -1;
 220 }
 221
 222 #define RTP_SEQ_MOD (1 << 16)
 223
 224 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence)
 225 {
 226     memset(s, 0, sizeof(RTPStatistics));
 227     s->max_seq   = base_sequence;
 228     s->probation = 1;
 229 }
 230
 231 /*
 232  * Called whenever there is a large jump in sequence numbers,
 233  * or when they get out of probation...
 234  */
 235 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
 236 {
 237     s->max_seq        = seq;
 238     s->cycles         = 0;
 239     s->base_seq       = seq - 1;
 240     s->bad_seq        = RTP_SEQ_MOD + 1;
 241     s->received       = 0;
 242     s->expected_prior = 0;
 243     s->received_prior = 0;
 244     s->jitter         = 0;
 245     s->transit        = 0;
 246 }
 247
 248 /* Returns 1 if we should handle this packet. */
 249 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
 250 {
 251     uint16_t udelta = seq - s->max_seq;
 252     const int MAX_DROPOUT    = 3000;
 253     const int MAX_MISORDER   = 100;
 254     const int MIN_SEQUENTIAL = 2;
 255
 256     /* source not valid until MIN_SEQUENTIAL packets with sequence
 257      * seq. numbers have been received */
 258     if (s->probation) {
 259         if (seq == s->max_seq + 1) {
 260             s->probation--;
 261             s->max_seq = seq;
 262             if (s->probation == 0) {
 263                 rtp_init_sequence(s, seq);
 264                 s->received++;
 265                 return 1;
 266             }
 267         } else {
 268             s->probation = MIN_SEQUENTIAL - 1;
 269             s->max_seq   = seq;
 270         }
 271     } else if (udelta < MAX_DROPOUT) {
 272         // in order, with permissible gap
 273         if (seq < s->max_seq) {
 274             // sequence number wrapped; count another 64k cycles
 275             s->cycles += RTP_SEQ_MOD;
 276         }
 277         s->max_seq = seq;
 278     } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
 279         // sequence made a large jump...
 280         if (seq == s->bad_seq) {
 281             /* two sequential packets -- assume that the other side
 282              * restarted without telling us; just resync. */
 283             rtp_init_sequence(s, seq);
 284         } else {
 285             s->bad_seq = (seq + 1) & (RTP_SEQ_MOD - 1);
 286             return 0;
 287         }
 288     } else {
 289         // duplicate or reordered packet...
 290     }
 291     s->received++;
 292     return 1;
 293 }
 294
 295 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp,
 296                                uint32_t arrival_timestamp)
 297 {
 298     // Most of this is pretty straight from RFC 3550 appendix A.8
 299     uint32_t transit = arrival_timestamp - sent_timestamp;
 300     uint32_t prev_transit = s->transit;
 301     int32_t d = transit - prev_transit;
 302     // Doing the FFABS() call directly on the "transit - prev_transit"
 303     // expression doesn't work, since it's an unsigned expression. Doing the
 304     // transit calculation in unsigned is desired though, since it most
 305     // probably will need to wrap around.
 306     d = FFABS(d);
 307     s->transit = transit;
 308     if (!prev_transit)
 309         return;
 310     s->jitter += d - (int32_t) ((s->jitter + 8) >> 4);
 311 }
 312
 313 int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, URLContext *fd,
 314                                   AVIOContext *avio, int count)
 315 {
 316     AVIOContext *pb;
 317     uint8_t *buf;
 318     int len;
 319     int rtcp_bytes;
 320     RTPStatistics *stats = &s->statistics;
 321     uint32_t lost;
 322     uint32_t extended_max;
 323     uint32_t expected_interval;
 324     uint32_t received_interval;
 325     int32_t  lost_interval;
 326     uint32_t expected;
 327     uint32_t fraction;
 328
 329     if ((!fd && !avio) || (count < 1))
 330         return -1;
 331
 332     /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
 333     /* XXX: MPEG pts hardcoded. RTCP send every 0.5 seconds */
 334     s->octet_count += count;
 335     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
 336         RTCP_TX_RATIO_DEN;
 337     rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
 338     if (rtcp_bytes < 28)
 339         return -1;
 340     s->last_octet_count = s->octet_count;
 341
 342     if (!fd)
 343         pb = avio;
 344     else if (avio_open_dyn_buf(&pb) < 0)
 345         return -1;
 346
 347     // Receiver Report
 348     avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
 349     avio_w8(pb, RTCP_RR);
 350     avio_wb16(pb, 7); /* length in words - 1 */
 351     // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
 352     avio_wb32(pb, s->ssrc + 1);
 353     avio_wb32(pb, s->ssrc); // server SSRC
 354     // some placeholders we should really fill...
 355     // RFC 1889/p64
 356     extended_max          = stats->cycles + stats->max_seq;
 357     expected              = extended_max - stats->base_seq;
 358     lost                  = expected - stats->received;
 359     lost                  = FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
 360     expected_interval     = expected - stats->expected_prior;
 361     stats->expected_prior = expected;
 362     received_interval     = stats->received - stats->received_prior;
 363     stats->received_prior = stats->received;
 364     lost_interval         = expected_interval - received_interval;
 365     if (expected_interval == 0 || lost_interval <= 0)
 366         fraction = 0;
 367     else
 368         fraction = (lost_interval << 8) / expected_interval;
 369
 370     fraction = (fraction << 24) | lost;
 371
 372     avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
 373     avio_wb32(pb, extended_max); /* max sequence received */
 374     avio_wb32(pb, stats->jitter >> 4); /* jitter */
 375
 376     if (s->last_sr.ntp_timestamp == AV_NOPTS_VALUE) {
 377         avio_wb32(pb, 0); /* last SR timestamp */
 378         avio_wb32(pb, 0); /* delay since last SR */
 379     } else {
 380         uint32_t middle_32_bits   = s->last_sr.ntp_timestamp >> 16; // this is valid, right? do we need to handle 64 bit values special?
 381         uint32_t delay_since_last = av_rescale(av_gettime_relative() - s->last_rtcp_reception_time,
 382                                                65536, AV_TIME_BASE);
 383
 384         avio_wb32(pb, middle_32_bits); /* last SR timestamp */
 385         avio_wb32(pb, delay_since_last); /* delay since last SR */
 386     }
 387
 388     // CNAME
 389     avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
 390     avio_w8(pb, RTCP_SDES);
 391     len = strlen(s->hostname);
 392     avio_wb16(pb, (7 + len + 3) / 4); /* length in words - 1 */
 393     avio_wb32(pb, s->ssrc + 1);
 394     avio_w8(pb, 0x01);
 395     avio_w8(pb, len);
 396     avio_write(pb, s->hostname, len);
 397     avio_w8(pb, 0); /* END */
 398     // padding
 399     for (len = (7 + len) % 4; len % 4; len++)
 400         avio_w8(pb, 0);
 401
 402     avio_flush(pb);
 403     if (!fd)
 404         return 0;
 405     len = avio_close_dyn_buf(pb, &buf);
 406     if ((len > 0) && buf) {
 407         av_unused int result;
 408         av_log(s->ic, AV_LOG_TRACE, "sending %d bytes of RR\n", len);
 409         result = ffurl_write(fd, buf, len);
 410         av_log(s->ic, AV_LOG_TRACE, "result from ffurl_write: %d\n", result);
 411         av_free(buf);
 412     }
 413     return 0;
 414 }
 415
 416 void ff_rtp_send_punch_packets(URLContext *rtp_handle)
 417 {
 418     uint8_t buf[RTP_MIN_PACKET_LENGTH], *ptr = buf;
 419
 420     /* Send a small RTP packet */
 421
 422     bytestream_put_byte(&ptr, (RTP_VERSION << 6));
 423     bytestream_put_byte(&ptr, 0); /* Payload type */
 424     bytestream_put_be16(&ptr, 0); /* Seq */
 425     bytestream_put_be32(&ptr, 0); /* Timestamp */
 426     bytestream_put_be32(&ptr, 0); /* SSRC */
 427
 428     ffurl_write(rtp_handle, buf, ptr - buf);
 429
 430     /* Send a minimal RTCP RR */
 431     ptr = buf;
 432     bytestream_put_byte(&ptr, (RTP_VERSION << 6));
 433     bytestream_put_byte(&ptr, RTCP_RR); /* receiver report */
 434     bytestream_put_be16(&ptr, 1); /* length in words - 1 */
 435     bytestream_put_be32(&ptr, 0); /* our own SSRC */
 436
 437     ffurl_write(rtp_handle, buf, ptr - buf);
 438 }
 439
 440 static int find_missing_packets(RTPDemuxContext *s, uint16_t *first_missing,
 441                                 uint16_t *missing_mask)
 442 {
 443     int i;
 444     uint16_t next_seq = s->seq + 1;
 445     RTPPacket *pkt = s->queue;
 446
 447     if (!pkt || pkt->seq == next_seq)
 448         return 0;
 449
 450     *missing_mask = 0;
 451     for (i = 1; i <= 16; i++) {
 452         uint16_t missing_seq = next_seq + i;
 453         while (pkt) {
 454             int16_t diff = pkt->seq - missing_seq;
 455             if (diff >= 0)
 456                 break;
 457             pkt = pkt->next;
 458         }
 459         if (!pkt)
 460             break;
 461         if (pkt->seq == missing_seq)
 462             continue;
 463         *missing_mask |= 1 << (i - 1);
 464     }
 465
 466     *first_missing = next_seq;
 467     return 1;
 468 }
 469
 470 int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd,
 471                               AVIOContext *avio)
 472 {
 473     int len, need_keyframe, missing_packets;
 474     AVIOContext *pb;
 475     uint8_t *buf;
 476     int64_t now;
 477     uint16_t first_missing = 0, missing_mask = 0;
 478
 479     if (!fd && !avio)
 480         return -1;
 481
 482     need_keyframe = s->handler && s->handler->need_keyframe &&
 483                     s->handler->need_keyframe(s->dynamic_protocol_context);
 484     missing_packets = find_missing_packets(s, &first_missing, &missing_mask);
 485
 486     if (!need_keyframe && !missing_packets)
 487         return 0;
 488
 489     /* Send new feedback if enough time has elapsed since the last
 490      * feedback packet. */
 491
 492     now = av_gettime_relative();
 493     if (s->last_feedback_time &&
 494         (now - s->last_feedback_time) < MIN_FEEDBACK_INTERVAL)
 495         return 0;
 496     s->last_feedback_time = now;
 497
 498     if (!fd)
 499         pb = avio;
 500     else if (avio_open_dyn_buf(&pb) < 0)
 501         return -1;
 502
 503     if (need_keyframe) {
 504         avio_w8(pb, (RTP_VERSION << 6) | 1); /* PLI */
 505         avio_w8(pb, RTCP_PSFB);
 506         avio_wb16(pb, 2); /* length in words - 1 */
 507         // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
 508         avio_wb32(pb, s->ssrc + 1);
 509         avio_wb32(pb, s->ssrc); // server SSRC
 510     }
 511
 512     if (missing_packets) {
 513         avio_w8(pb, (RTP_VERSION << 6) | 1); /* NACK */
 514         avio_w8(pb, RTCP_RTPFB);
 515         avio_wb16(pb, 3); /* length in words - 1 */
 516         avio_wb32(pb, s->ssrc + 1);
 517         avio_wb32(pb, s->ssrc); // server SSRC
 518
 519         avio_wb16(pb, first_missing);
 520         avio_wb16(pb, missing_mask);
 521     }
 522
 523     avio_flush(pb);
 524     if (!fd)
 525         return 0;
 526     len = avio_close_dyn_buf(pb, &buf);
 527     if (len > 0 && buf) {
 528         ffurl_write(fd, buf, len);
 529         av_free(buf);
 530     }
 531     return 0;
 532 }
 533
 534 /**
 535  * open a new RTP parse context for stream 'st'. 'st' can be NULL for
 536  * MPEG-2 TS streams.
 537  */
 538 RTPDemuxContext *ff_rtp_parse_open(AVFormatContext *s1, AVStream *st,
 539                                    int payload_type, int queue_size)
 540 {
 541     RTPDemuxContext *s;
 542
 543     s = av_mallocz(sizeof(RTPDemuxContext));
 544     if (!s)
 545         return NULL;
 546     s->payload_type        = payload_type;
 547     s->last_sr.ntp_timestamp  = AV_NOPTS_VALUE;
 548     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
 549     s->ic                  = s1;
 550     s->st                  = st;
 551     s->queue_size          = queue_size;
 552
 553     av_log(s->ic, AV_LOG_VERBOSE, "setting jitter buffer size to %d\n",
 554            s->queue_size);
 555
 556     rtp_init_statistics(&s->statistics, 0);
 557     if (st) {
 558         switch (st->codecpar->codec_id) {
 559         case AV_CODEC_ID_ADPCM_G722:
 560             /* According to RFC 3551, the stream clock rate is 8000
 561              * even if the sample rate is 16000. */
 562             if (st->codecpar->sample_rate == 8000)
 563                 st->codecpar->sample_rate = 16000;
 564             break;
 565         case AV_CODEC_ID_PCM_MULAW: {
 566             AVCodecParameters *par = st->codecpar;
 567             par->bits_per_coded_sample = av_get_bits_per_sample(par->codec_id);
 568             par->block_align           = par->ch_layout.nb_channels * par->bits_per_coded_sample / 8;
 569             par->bit_rate              = par->block_align * 8LL * par->sample_rate;
 570             break;
 571         }
 572         default:
 573             break;
 574         }
 575     }
 576     // needed to send back RTCP RR in RTSP sessions
 577     gethostname(s->hostname, sizeof(s->hostname));
 578     return s;
 579 }
 580
 581 void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
 582                                        const RTPDynamicProtocolHandler *handler)
 583 {
 584     s->dynamic_protocol_context = ctx;
 585     s->handler                  = handler;
 586 }
 587
 588 void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite,
 589                              const char *params)
 590 {
 591     if (!ff_srtp_set_crypto(&s->srtp, suite, params))
 592         s->srtp_enabled = 1;
 593 }
 594
 595 static int rtp_set_prft(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp) {
 596     int64_t rtcp_time, delta_time;
 597     int32_t delta_timestamp;
 598
 599     AVProducerReferenceTime *prft =
 600         (AVProducerReferenceTime *) av_packet_new_side_data(
 601             pkt, AV_PKT_DATA_PRFT, sizeof(AVProducerReferenceTime));
 602     if (!prft)
 603         return AVERROR(ENOMEM);
 604
 605     rtcp_time = ff_parse_ntp_time(s->last_sr.ntp_timestamp) - NTP_OFFSET_US;
 606     /* Cast to int32_t to handle timestamp wraparound correctly */
 607     delta_timestamp = (int32_t)(timestamp - s->last_sr.rtp_timestamp);
 608     delta_time = av_rescale_q(delta_timestamp, s->st->time_base, AV_TIME_BASE_Q);
 609
 610     prft->wallclock = rtcp_time + delta_time;
 611     prft->flags = 24;
 612     return 0;
 613 }
 614
 615 static int rtp_add_sr_sidedata(RTPDemuxContext *s, AVPacket *pkt) {
 616     AVRTCPSenderReport *sr =
 617         (AVRTCPSenderReport *) av_packet_new_side_data(
 618             pkt, AV_PKT_DATA_RTCP_SR, sizeof(AVRTCPSenderReport));
 619     if (!sr)
 620         return AVERROR(ENOMEM);
 621
 622     memcpy(sr, &s->last_sr, sizeof(AVRTCPSenderReport));
 623     s->pending_sr = 0;
 624     return 0;
 625 }
 626
 627 /**
 628  * This was the second switch in rtp_parse packet.
 629  * Normalizes time, if required, sets stream_index, etc.
 630  */
 631 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
 632 {
 633     if (s->pending_sr) {
 634         int ret = rtp_add_sr_sidedata(s, pkt);
 635         if (ret < 0)
 636             av_log(s->ic, AV_LOG_WARNING, "rtpdec: failed to add SR sidedata\n");
 637     }
 638
 639     if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE)
 640         return; /* Timestamp already set by depacketizer */
 641     if (timestamp == RTP_NOTS_VALUE)
 642         return;
 643
 644     if (s->last_sr.ntp_timestamp != AV_NOPTS_VALUE) {
 645         if (rtp_set_prft(s, pkt, timestamp) < 0) {
 646             av_log(s->ic, AV_LOG_WARNING, "rtpdec: failed to set prft");
 647         }
 648     }
 649
 650     if (s->last_sr.ntp_timestamp != AV_NOPTS_VALUE && s->ic->nb_streams > 1) {
 651         int64_t addend;
 652         int32_t delta_timestamp;
 653
 654         /* compute pts from timestamp with received ntp_time */
 655         /* Cast to int32_t to handle timestamp wraparound correctly */
 656         delta_timestamp = (int32_t)(timestamp - s->last_sr.rtp_timestamp);
 657         /* convert to the PTS timebase */
 658         addend = av_rescale(s->last_sr.ntp_timestamp - s->first_rtcp_ntp_time,
 659                             s->st->time_base.den,
 660                             (uint64_t) s->st->time_base.num << 32);
 661         pkt->pts = s->range_start_offset + s->rtcp_ts_offset + addend +
 662                    delta_timestamp;
 663         return;
 664     }
 665
 666     if (!s->base_timestamp)
 667         s->base_timestamp = timestamp;
 668     /* assume that the difference is INT32_MIN < x < INT32_MAX,
 669      * but allow the first timestamp to exceed INT32_MAX */
 670     if (!s->timestamp)
 671         s->unwrapped_timestamp += timestamp;
 672     else
 673         s->unwrapped_timestamp += (int32_t)(timestamp - s->timestamp);
 674     s->timestamp = timestamp;
 675     pkt->pts     = s->unwrapped_timestamp + s->range_start_offset -
 676                    s->base_timestamp;
 677 }
 678
 679 static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt,
 680                                      const uint8_t *buf, int len)
 681 {
 682     unsigned int ssrc;
 683     int payload_type, seq, flags = 0;
 684     int ext, csrc;
 685     AVStream *st;
 686     uint32_t timestamp;
 687     int rv = 0;
 688
 689     csrc         = buf[0] & 0x0f;
 690     ext          = buf[0] & 0x10;
 691     payload_type = buf[1] & 0x7f;
 692     if (buf[1] & 0x80)
 693         flags |= RTP_FLAG_MARKER;
 694     seq       = AV_RB16(buf + 2);
 695     timestamp = AV_RB32(buf + 4);
 696     ssrc      = AV_RB32(buf + 8);
 697     /* store the ssrc in the RTPDemuxContext */
 698     s->ssrc = ssrc;
 699
 700     /* NOTE: we can handle only one payload type */
 701     if (s->payload_type != payload_type)
 702         return -1;
 703
 704     st = s->st;
 705     // only do something with this if all the rtp checks pass...
 706     if (!rtp_valid_packet_in_sequence(&s->statistics, seq)) {
 707         av_log(s->ic, AV_LOG_ERROR,
 708                "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
 709                payload_type, seq, ((s->seq + 1) & 0xffff));
 710         return -1;
 711     }
 712
 713     if (buf[0] & 0x20) {
 714         int padding = buf[len - 1];
 715         if (len >= 12 + padding)
 716             len -= padding;
 717     }
 718
 719     s->seq = seq;
 720     len   -= 12;
 721     buf   += 12;
 722
 723     len   -= 4 * csrc;
 724     buf   += 4 * csrc;
 725     if (len < 0)
 726         return AVERROR_INVALIDDATA;
 727
 728     /* RFC 3550 Section 5.3.1 RTP Header Extension handling */
 729     if (ext) {
 730         if (len < 4)
 731             return -1;
 732         /* calculate the header extension length (stored as number
 733          * of 32-bit words) */
 734         ext = (AV_RB16(buf + 2) + 1) << 2;
 735
 736         if (len < ext)
 737             return -1;
 738         // skip past RTP header extension
 739         len -= ext;
 740         buf += ext;
 741     }
 742
 743     if (s->handler && s->handler->parse_packet) {
 744         rv = s->handler->parse_packet(s->ic, s->dynamic_protocol_context,
 745                                       s->st, pkt, &timestamp, buf, len, seq,
 746                                       flags);
 747     } else if (st) {
 748         if ((rv = av_new_packet(pkt, len)) < 0)
 749             return rv;
 750         memcpy(pkt->data, buf, len);
 751         pkt->stream_index = st->index;
 752     } else {
 753         return AVERROR(EINVAL);
 754     }
 755
 756     // now perform timestamp things....
 757     finalize_packet(s, pkt, timestamp);
 758
 759     return rv;
 760 }
 761
 762 void ff_rtp_reset_packet_queue(RTPDemuxContext *s)
 763 {
 764     while (s->queue) {
 765         RTPPacket *next = s->queue->next;
 766         av_freep(&s->queue->buf);
 767         av_freep(&s->queue);
 768         s->queue = next;
 769     }
 770     s->seq       = 0;
 771     s->queue_len = 0;
 772     s->prev_ret  = 0;
 773 }
 774
 775 static int enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len)
 776 {
 777     uint16_t seq   = AV_RB16(buf + 2);
 778     RTPPacket **cur = &s->queue, *packet;
 779
 780     /* Find the correct place in the queue to insert the packet */
 781     while (*cur) {
 782         int16_t diff = seq - (*cur)->seq;
 783         if (diff < 0)
 784             break;
 785         cur = &(*cur)->next;
 786     }
 787
 788     packet = av_mallocz(sizeof(*packet));
 789     if (!packet)
 790         return AVERROR(ENOMEM);
 791     packet->recvtime = av_gettime_relative();
 792     packet->seq      = seq;
 793     packet->len      = len;
 794     packet->buf      = buf;
 795     packet->next     = *cur;
 796     *cur = packet;
 797     s->queue_len++;
 798
 799     return 0;
 800 }
 801
 802 static int has_next_packet(RTPDemuxContext *s)
 803 {
 804     return s->queue && s->queue->seq == (uint16_t) (s->seq + 1);
 805 }
 806
 807 int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
 808 {
 809     return s->queue ? s->queue->recvtime : 0;
 810 }
 811
 812 static int rtp_parse_queued_packet(RTPDemuxContext *s, AVPacket *pkt)
 813 {
 814     int rv;
 815     RTPPacket *next;
 816
 817     if (s->queue_len <= 0)
 818         return -1;
 819
 820     if (!has_next_packet(s)) {
 821         int pkt_missed  = s->queue->seq - s->seq - 1;
 822
 823         if (pkt_missed < 0)
 824             pkt_missed += UINT16_MAX;
 825         av_log(s->ic, AV_LOG_WARNING,
 826                "RTP: missed %d packets\n", pkt_missed);
 827     }
 828
 829     /* Parse the first packet in the queue, and dequeue it */
 830     rv   = rtp_parse_packet_internal(s, pkt, s->queue->buf, s->queue->len);
 831     next = s->queue->next;
 832     av_freep(&s->queue->buf);
 833     av_freep(&s->queue);
 834     s->queue = next;
 835     s->queue_len--;
 836     return rv;
 837 }
 838
 839 static int rtp_parse_one_packet(RTPDemuxContext *s, AVPacket *pkt,
 840                                 uint8_t **bufptr, int len)
 841 {
 842     uint8_t *buf = bufptr ? *bufptr : NULL;
 843     int flags = 0;
 844     uint32_t timestamp;
 845     int rv = 0;
 846
 847     if (!buf) {
 848         /* If parsing of the previous packet actually returned 0 or an error,
 849          * there's nothing more to be parsed from that packet, but we may have
 850          * indicated that we can return the next enqueued packet. */
 851         if (s->prev_ret <= 0)
 852             return rtp_parse_queued_packet(s, pkt);
 853         /* return the next packets, if any */
 854         if (s->handler && s->handler->parse_packet) {
 855             /* timestamp should be overwritten by parse_packet, if not,
 856              * the packet is left with pts == AV_NOPTS_VALUE */
 857             timestamp = RTP_NOTS_VALUE;
 858             rv        = s->handler->parse_packet(s->ic, s->dynamic_protocol_context,
 859                                                  s->st, pkt, &timestamp, NULL, 0, 0,
 860                                                  flags);
 861             finalize_packet(s, pkt, timestamp);
 862             return rv;
 863         }
 864     }
 865
 866     if (len < 12)
 867         return -1;
 868
 869     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
 870         return -1;
 871     if (RTP_PT_IS_RTCP(buf[1])) {
 872         return rtcp_parse_packet(s, buf, len);
 873     }
 874
 875     if (s->st) {
 876         int64_t received = av_gettime_relative();
 877         uint32_t arrival_ts = av_rescale_q(received, AV_TIME_BASE_Q,
 878                                            s->st->time_base);
 879         timestamp = AV_RB32(buf + 4);
 880         // Calculate the jitter immediately, before queueing the packet
 881         // into the reordering queue.
 882         rtcp_update_jitter(&s->statistics, timestamp, arrival_ts);
 883     }
 884
 885     if ((s->seq == 0 && !s->queue) || s->queue_size <= 1) {
 886         /* First packet, or no reordering */
 887         return rtp_parse_packet_internal(s, pkt, buf, len);
 888     } else {
 889         uint16_t seq = AV_RB16(buf + 2);
 890         int16_t diff = seq - s->seq;
 891         if (diff < 0) {
 892             /* Packet older than the previously emitted one, drop */
 893             av_log(s->ic, AV_LOG_WARNING,
 894                    "RTP: dropping old packet received too late\n");
 895             return -1;
 896         } else if (diff <= 1) {
 897             /* Correct packet */
 898             rv = rtp_parse_packet_internal(s, pkt, buf, len);
 899             return rv;
 900         } else {
 901             /* Still missing some packet, enqueue this one. */
 902             rv = enqueue_packet(s, buf, len);
 903             if (rv < 0)
 904                 return rv;
 905             *bufptr = NULL;
 906             /* Return the first enqueued packet if the queue is full,
 907              * even if we're missing something */
 908             if (s->queue_len >= s->queue_size) {
 909                 av_log(s->ic, AV_LOG_WARNING, "jitter buffer full\n");
 910                 return rtp_parse_queued_packet(s, pkt);
 911             }
 912             return -1;
 913         }
 914     }
 915 }
 916
 917 /**
 918  * Parse an RTP or RTCP packet directly sent as a buffer.
 919  * @param s RTP parse context.
 920  * @param pkt returned packet
 921  * @param bufptr pointer to the input buffer or NULL to read the next packets
 922  * @param len buffer len
 923  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
 924  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
 925  */
 926 int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
 927                         uint8_t **bufptr, int len)
 928 {
 929     int rv;
 930     if (s->srtp_enabled && bufptr && ff_srtp_decrypt(&s->srtp, *bufptr, &len) < 0)
 931         return -1;
 932     rv = rtp_parse_one_packet(s, pkt, bufptr, len);
 933     s->prev_ret = rv;
 934     while (rv < 0 && has_next_packet(s))
 935         rv = rtp_parse_queued_packet(s, pkt);
 936     return rv ? rv : has_next_packet(s);
 937 }
 938
 939 void ff_rtp_parse_close(RTPDemuxContext *s)
 940 {
 941     ff_rtp_reset_packet_queue(s);
 942     ff_srtp_free(&s->srtp);
 943     av_free(s);
 944 }
 945
 946 int ff_parse_fmtp(AVFormatContext *s,
 947                   AVStream *stream, PayloadContext *data, const char *p,
 948                   int (*parse_fmtp)(AVFormatContext *s,
 949                                     AVStream *stream,
 950                                     PayloadContext *data,
 951                                     const char *attr, const char *value))
 952 {
 953     char attr[256];
 954     char *value;
 955     int res;
 956     int value_size = strlen(p) + 1;
 957
 958     if (!(value = av_malloc(value_size))) {
 959         av_log(s, AV_LOG_ERROR, "Failed to allocate data for FMTP.\n");
 960         return AVERROR(ENOMEM);
 961     }
 962
 963     // remove protocol identifier
 964     while (*p && *p == ' ')
 965         p++;                     // strip spaces
 966     while (*p && *p != ' ')
 967         p++;                     // eat protocol identifier
 968     while (*p && *p == ' ')
 969         p++;                     // strip trailing spaces
 970
 971     while (ff_rtsp_next_attr_and_value(&p,
 972                                        attr, sizeof(attr),
 973                                        value, value_size)) {
 974         res = parse_fmtp(s, stream, data, attr, value);
 975         if (res < 0 && res != AVERROR_PATCHWELCOME) {
 976             av_free(value);
 977             return res;
 978         }
 979     }
 980     av_free(value);
 981     return 0;
 982 }
 983
 984 int ff_rtp_finalize_packet(AVPacket *pkt, AVIOContext **dyn_buf, int stream_idx)
 985 {
 986     int ret;
 987     av_packet_unref(pkt);
 988
 989     pkt->size         = avio_close_dyn_buf(*dyn_buf, &pkt->data);
 990     pkt->stream_index = stream_idx;
 991     *dyn_buf = NULL;
 992     if ((ret = av_packet_from_data(pkt, pkt->data, pkt->size)) < 0) {
 993         av_freep(&pkt->data);
 994         return ret;
 995     }
 996     return pkt->size;
 997 }