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