Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtpdec.c @ 2cab6b48

History | View | Annotate | Download (19.9 KB)

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 = 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
}