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 /* needed for gethostname() */
  23 #define _XOPEN_SOURCE 600
  24
  25 #include "libavcodec/get_bits.h"
  26 #include "avformat.h"
  27 #include "mpegts.h"
  28
  29 #include <unistd.h>
  30 #include "network.h"
  31
  32 #include "rtpdec.h"
  33 #include "rtp_asf.h"
  34 #include "rtp_h264.h"
  35 #include "rtp_vorbis.h"
  36
  37 //#define DEBUG
  38
  39 /* TODO: - add RTCP statistics reporting (should be optional).
  40
  41          - add support for h263/mpeg4 packetized output : IDEA: send a
  42          buffer to 'rtp_write_packet' contains all the packets for ONE
  43          frame. Each packet should have a four byte header containing
  44          the length in big endian format (same trick as
  45          'url_open_dyn_packet_buf')
  46 */
  47
  48 /* statistics functions */
  49 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
  50
  51 static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
  52 static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
  53
  54 void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
  55 {
  56     handler->next= RTPFirstDynamicPayloadHandler;
  57     RTPFirstDynamicPayloadHandler= handler;
  58 }
  59
  60 void av_register_rtp_dynamic_payload_handlers(void)
  61 {
  62     ff_register_dynamic_payload_handler(&mp4v_es_handler);
  63     ff_register_dynamic_payload_handler(&mpeg4_generic_handler);
  64     ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
  65     ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
  66
  67     ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
  68     ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
  69 }
  70
  71 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
  72 {
  73     if (buf[1] != 200)
  74         return -1;
  75     s->last_rtcp_ntp_time = AV_RB64(buf + 8);
  76     if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
  77         s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
  78     s->last_rtcp_timestamp = AV_RB32(buf + 16);
  79     return 0;
  80 }
  81
  82 #define RTP_SEQ_MOD (1<<16)
  83
  84 /**
  85 * called on parse open packet
  86 */
  87 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
  88 {
  89     memset(s, 0, sizeof(RTPStatistics));
  90     s->max_seq= base_sequence;
  91     s->probation= 1;
  92 }
  93
  94 /**
  95 * called whenever there is a large jump in sequence numbers, or when they get out of probation...
  96 */
  97 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
  98 {
  99     s->max_seq= seq;
 100     s->cycles= 0;
 101     s->base_seq= seq -1;
 102     s->bad_seq= RTP_SEQ_MOD + 1;
 103     s->received= 0;
 104     s->expected_prior= 0;
 105     s->received_prior= 0;
 106     s->jitter= 0;
 107     s->transit= 0;
 108 }
 109
 110 /**
 111 * returns 1 if we should handle this packet.
 112 */
 113 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
 114 {
 115     uint16_t udelta= seq - s->max_seq;
 116     const int MAX_DROPOUT= 3000;
 117     const int MAX_MISORDER = 100;
 118     const int MIN_SEQUENTIAL = 2;
 119
 120     /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
 121     if(s->probation)
 122     {
 123         if(seq==s->max_seq + 1) {
 124             s->probation--;
 125             s->max_seq= seq;
 126             if(s->probation==0) {
 127                 rtp_init_sequence(s, seq);
 128                 s->received++;
 129                 return 1;
 130             }
 131         } else {
 132             s->probation= MIN_SEQUENTIAL - 1;
 133             s->max_seq = seq;
 134         }
 135     } else if (udelta < MAX_DROPOUT) {
 136         // in order, with permissible gap
 137         if(seq < s->max_seq) {
 138             //sequence number wrapped; count antother 64k cycles
 139             s->cycles += RTP_SEQ_MOD;
 140         }
 141         s->max_seq= seq;
 142     } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
 143         // sequence made a large jump...
 144         if(seq==s->bad_seq) {
 145             // two sequential packets-- assume that the other side restarted without telling us; just resync.
 146             rtp_init_sequence(s, seq);
 147         } else {
 148             s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
 149             return 0;
 150         }
 151     } else {
 152         // duplicate or reordered packet...
 153     }
 154     s->received++;
 155     return 1;
 156 }
 157
 158 #if 0
 159 /**
 160 * This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
 161 * difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
 162 * never change.  I left this in in case someone else can see a way. (rdm)
 163 */
 164 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
 165 {
 166     uint32_t transit= arrival_timestamp - sent_timestamp;
 167     int d;
 168     s->transit= transit;
 169     d= FFABS(transit - s->transit);
 170     s->jitter += d - ((s->jitter + 8)>>4);
 171 }
 172 #endif
 173
 174 int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
 175 {
 176     ByteIOContext *pb;
 177     uint8_t *buf;
 178     int len;
 179     int rtcp_bytes;
 180     RTPStatistics *stats= &s->statistics;
 181     uint32_t lost;
 182     uint32_t extended_max;
 183     uint32_t expected_interval;
 184     uint32_t received_interval;
 185     uint32_t lost_interval;
 186     uint32_t expected;
 187     uint32_t fraction;
 188     uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
 189
 190     if (!s->rtp_ctx || (count < 1))
 191         return -1;
 192
 193     /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
 194     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
 195     s->octet_count += count;
 196     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
 197         RTCP_TX_RATIO_DEN;
 198     rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
 199     if (rtcp_bytes < 28)
 200         return -1;
 201     s->last_octet_count = s->octet_count;
 202
 203     if (url_open_dyn_buf(&pb) < 0)
 204         return -1;
 205
 206     // Receiver Report
 207     put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
 208     put_byte(pb, 201);
 209     put_be16(pb, 7); /* length in words - 1 */
 210     put_be32(pb, s->ssrc); // our own SSRC
 211     put_be32(pb, s->ssrc); // XXX: should be the server's here!
 212     // some placeholders we should really fill...
 213     // RFC 1889/p64
 214     extended_max= stats->cycles + stats->max_seq;
 215     expected= extended_max - stats->base_seq + 1;
 216     lost= expected - stats->received;
 217     lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
 218     expected_interval= expected - stats->expected_prior;
 219     stats->expected_prior= expected;
 220     received_interval= stats->received - stats->received_prior;
 221     stats->received_prior= stats->received;
 222     lost_interval= expected_interval - received_interval;
 223     if (expected_interval==0 || lost_interval<=0) fraction= 0;
 224     else fraction = (lost_interval<<8)/expected_interval;
 225
 226     fraction= (fraction<<24) | lost;
 227
 228     put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
 229     put_be32(pb, extended_max); /* max sequence received */
 230     put_be32(pb, stats->jitter>>4); /* jitter */
 231
 232     if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
 233     {
 234         put_be32(pb, 0); /* last SR timestamp */
 235         put_be32(pb, 0); /* delay since last SR */
 236     } else {
 237         uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
 238         uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
 239
 240         put_be32(pb, middle_32_bits); /* last SR timestamp */
 241         put_be32(pb, delay_since_last); /* delay since last SR */
 242     }
 243
 244     // CNAME
 245     put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
 246     put_byte(pb, 202);
 247     len = strlen(s->hostname);
 248     put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
 249     put_be32(pb, s->ssrc);
 250     put_byte(pb, 0x01);
 251     put_byte(pb, len);
 252     put_buffer(pb, s->hostname, len);
 253     // padding
 254     for (len = (6 + len) % 4; len % 4; len++) {
 255         put_byte(pb, 0);
 256     }
 257
 258     put_flush_packet(pb);
 259     len = url_close_dyn_buf(pb, &buf);
 260     if ((len > 0) && buf) {
 261         int result;
 262         dprintf(s->ic, "sending %d bytes of RR\n", len);
 263         result= url_write(s->rtp_ctx, buf, len);
 264         dprintf(s->ic, "result from url_write: %d\n", result);
 265         av_free(buf);
 266     }
 267     return 0;
 268 }
 269
 270 /**
 271  * open a new RTP parse context for stream 'st'. 'st' can be NULL for
 272  * MPEG2TS streams to indicate that they should be demuxed inside the
 273  * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
 274  * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
 275  */
 276 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data)
 277 {
 278     RTPDemuxContext *s;
 279
 280     s = av_mallocz(sizeof(RTPDemuxContext));
 281     if (!s)
 282         return NULL;
 283     s->payload_type = payload_type;
 284     s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
 285     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
 286     s->ic = s1;
 287     s->st = st;
 288     s->rtp_payload_data = rtp_payload_data;
 289     rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
 290     if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
 291         s->ts = mpegts_parse_open(s->ic);
 292         if (s->ts == NULL) {
 293             av_free(s);
 294             return NULL;
 295         }
 296     } else {
 297         av_set_pts_info(st, 32, 1, 90000);
 298         switch(st->codec->codec_id) {
 299         case CODEC_ID_MPEG1VIDEO:
 300         case CODEC_ID_MPEG2VIDEO:
 301         case CODEC_ID_MP2:
 302         case CODEC_ID_MP3:
 303         case CODEC_ID_MPEG4:
 304         case CODEC_ID_H264:
 305             st->need_parsing = AVSTREAM_PARSE_FULL;
 306             break;
 307         default:
 308             if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
 309                 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
 310             }
 311             break;
 312         }
 313     }
 314     // needed to send back RTCP RR in RTSP sessions
 315     s->rtp_ctx = rtpc;
 316     gethostname(s->hostname, sizeof(s->hostname));
 317     return s;
 318 }
 319
 320 void
 321 rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
 322                                RTPDynamicProtocolHandler *handler)
 323 {
 324     s->dynamic_protocol_context = ctx;
 325     s->parse_packet = handler->parse_packet;
 326 }
 327
 328 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
 329 {
 330     int au_headers_length, au_header_size, i;
 331     GetBitContext getbitcontext;
 332     RTPPayloadData *infos;
 333
 334     infos = s->rtp_payload_data;
 335
 336     if (infos == NULL)
 337         return -1;
 338
 339     /* decode the first 2 bytes where the AUHeader sections are stored
 340        length in bits */
 341     au_headers_length = AV_RB16(buf);
 342
 343     if (au_headers_length > RTP_MAX_PACKET_LENGTH)
 344       return -1;
 345
 346     infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
 347
 348     /* skip AU headers length section (2 bytes) */
 349     buf += 2;
 350
 351     init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
 352
 353     /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
 354     au_header_size = infos->sizelength + infos->indexlength;
 355     if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
 356         return -1;
 357
 358     infos->nb_au_headers = au_headers_length / au_header_size;
 359     infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
 360
 361     /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
 362        In my test, the FAAD decoder does not behave correctly when sending each AU one by one
 363        but does when sending the whole as one big packet...  */
 364     infos->au_headers[0].size = 0;
 365     infos->au_headers[0].index = 0;
 366     for (i = 0; i < infos->nb_au_headers; ++i) {
 367         infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
 368         infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
 369     }
 370
 371     infos->nb_au_headers = 1;
 372
 373     return 0;
 374 }
 375
 376 /**
 377  * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
 378  */
 379 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
 380 {
 381     if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
 382         int64_t addend;
 383         int delta_timestamp;
 384
 385         /* compute pts from timestamp with received ntp_time */
 386         delta_timestamp = timestamp - s->last_rtcp_timestamp;
 387         /* convert to the PTS timebase */
 388         addend = av_rescale(s->last_rtcp_ntp_time - s->first_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
 389         pkt->pts = addend + delta_timestamp;
 390     }
 391 }
 392
 393 /**
 394  * Parse an RTP or RTCP packet directly sent as a buffer.
 395  * @param s RTP parse context.
 396  * @param pkt returned packet
 397  * @param buf input buffer or NULL to read the next packets
 398  * @param len buffer len
 399  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
 400  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
 401  */
 402 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
 403                      const uint8_t *buf, int len)
 404 {
 405     unsigned int ssrc, h;
 406     int payload_type, seq, ret, flags = 0;
 407     AVStream *st;
 408     uint32_t timestamp;
 409     int rv= 0;
 410
 411     if (!buf) {
 412         /* return the next packets, if any */
 413         if(s->st && s->parse_packet) {
 414             timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
 415             rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
 416                                 s->st, pkt, &timestamp, NULL, 0, flags);
 417             finalize_packet(s, pkt, timestamp);
 418             return rv;
 419         } else {
 420             // TODO: Move to a dynamic packet handler (like above)
 421             if (s->read_buf_index >= s->read_buf_size)
 422                 return -1;
 423             ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
 424                                       s->read_buf_size - s->read_buf_index);
 425             if (ret < 0)
 426                 return -1;
 427             s->read_buf_index += ret;
 428             if (s->read_buf_index < s->read_buf_size)
 429                 return 1;
 430             else
 431                 return 0;
 432         }
 433     }
 434
 435     if (len < 12)
 436         return -1;
 437
 438     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
 439         return -1;
 440     if (buf[1] >= 200 && buf[1] <= 204) {
 441         rtcp_parse_packet(s, buf, len);
 442         return -1;
 443     }
 444     payload_type = buf[1] & 0x7f;
 445     if (buf[1] & 0x80)
 446         flags |= RTP_FLAG_MARKER;
 447     seq  = AV_RB16(buf + 2);
 448     timestamp = AV_RB32(buf + 4);
 449     ssrc = AV_RB32(buf + 8);
 450     /* store the ssrc in the RTPDemuxContext */
 451     s->ssrc = ssrc;
 452
 453     /* NOTE: we can handle only one payload type */
 454     if (s->payload_type != payload_type)
 455         return -1;
 456
 457     st = s->st;
 458     // only do something with this if all the rtp checks pass...
 459     if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
 460     {
 461         av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
 462                payload_type, seq, ((s->seq + 1) & 0xffff));
 463         return -1;
 464     }
 465
 466     s->seq = seq;
 467     len -= 12;
 468     buf += 12;
 469
 470     if (!st) {
 471         /* specific MPEG2TS demux support */
 472         ret = mpegts_parse_packet(s->ts, pkt, buf, len);
 473         if (ret < 0)
 474             return -1;
 475         if (ret < len) {
 476             s->read_buf_size = len - ret;
 477             memcpy(s->buf, buf + ret, s->read_buf_size);
 478             s->read_buf_index = 0;
 479             return 1;
 480         }
 481         return 0;
 482     } else if (s->parse_packet) {
 483         rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
 484                              s->st, pkt, &timestamp, buf, len, flags);
 485     } else {
 486         // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
 487         switch(st->codec->codec_id) {
 488         case CODEC_ID_MP2:
 489             /* better than nothing: skip mpeg audio RTP header */
 490             if (len <= 4)
 491                 return -1;
 492             h = AV_RB32(buf);
 493             len -= 4;
 494             buf += 4;
 495             av_new_packet(pkt, len);
 496             memcpy(pkt->data, buf, len);
 497             break;
 498         case CODEC_ID_MPEG1VIDEO:
 499         case CODEC_ID_MPEG2VIDEO:
 500             /* better than nothing: skip mpeg video RTP header */
 501             if (len <= 4)
 502                 return -1;
 503             h = AV_RB32(buf);
 504             buf += 4;
 505             len -= 4;
 506             if (h & (1 << 26)) {
 507                 /* mpeg2 */
 508                 if (len <= 4)
 509                     return -1;
 510                 buf += 4;
 511                 len -= 4;
 512             }
 513             av_new_packet(pkt, len);
 514             memcpy(pkt->data, buf, len);
 515             break;
 516             // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
 517             // timestamps.
 518             // TODO: Put this into a dynamic packet handler...
 519         case CODEC_ID_AAC:
 520             if (rtp_parse_mp4_au(s, buf))
 521                 return -1;
 522             {
 523                 RTPPayloadData *infos = s->rtp_payload_data;
 524                 if (infos == NULL)
 525                     return -1;
 526                 buf += infos->au_headers_length_bytes + 2;
 527                 len -= infos->au_headers_length_bytes + 2;
 528
 529                 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
 530                     one au_header */
 531                 av_new_packet(pkt, infos->au_headers[0].size);
 532                 memcpy(pkt->data, buf, infos->au_headers[0].size);
 533                 buf += infos->au_headers[0].size;
 534                 len -= infos->au_headers[0].size;
 535             }
 536             s->read_buf_size = len;
 537             rv= 0;
 538             break;
 539         default:
 540             av_new_packet(pkt, len);
 541             memcpy(pkt->data, buf, len);
 542             break;
 543         }
 544
 545         pkt->stream_index = st->index;
 546     }
 547
 548     // now perform timestamp things....
 549     finalize_packet(s, pkt, timestamp);
 550
 551     return rv;
 552 }
 553
 554 void rtp_parse_close(RTPDemuxContext *s)
 555 {
 556     // TODO: fold this into the protocol specific data fields.
 557     if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
 558         mpegts_parse_close(s->ts);
 559     }
 560     av_free(s);
 561 }