LCOV - code coverage report
Current view: top level - libavformat - rtpdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 468 0.0 %
Date: 2018-05-20 11:54:08 Functions: 0 27 0.0 %

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

Generated by: LCOV version 1.13