Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtpdec.c @ f65919af

History | View | Annotate | Download (19.4 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_vorbis.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", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
54
static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_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

    
73
    ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
74
    ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
75
}
76

    
77
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
78
{
79
    if (buf[1] != 200)
80
        return -1;
81
    s->last_rtcp_ntp_time = AV_RB64(buf + 8);
82
    s->last_rtcp_timestamp = AV_RB32(buf + 16);
83
    return 0;
84
}
85

    
86
#define RTP_SEQ_MOD (1<<16)
87

    
88
/**
89
* called on parse open packet
90
*/
91
static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
92
{
93
    memset(s, 0, sizeof(RTPStatistics));
94
    s->max_seq= base_sequence;
95
    s->probation= 1;
96
}
97

    
98
/**
99
* called whenever there is a large jump in sequence numbers, or when they get out of probation...
100
*/
101
static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
102
{
103
    s->max_seq= seq;
104
    s->cycles= 0;
105
    s->base_seq= seq -1;
106
    s->bad_seq= RTP_SEQ_MOD + 1;
107
    s->received= 0;
108
    s->expected_prior= 0;
109
    s->received_prior= 0;
110
    s->jitter= 0;
111
    s->transit= 0;
112
}
113

    
114
/**
115
* returns 1 if we should handle this packet.
116
*/
117
static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
118
{
119
    uint16_t udelta= seq - s->max_seq;
120
    const int MAX_DROPOUT= 3000;
121
    const int MAX_MISORDER = 100;
122
    const int MIN_SEQUENTIAL = 2;
123

    
124
    /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
125
    if(s->probation)
126
    {
127
        if(seq==s->max_seq + 1) {
128
            s->probation--;
129
            s->max_seq= seq;
130
            if(s->probation==0) {
131
                rtp_init_sequence(s, seq);
132
                s->received++;
133
                return 1;
134
            }
135
        } else {
136
            s->probation= MIN_SEQUENTIAL - 1;
137
            s->max_seq = seq;
138
        }
139
    } else if (udelta < MAX_DROPOUT) {
140
        // in order, with permissible gap
141
        if(seq < s->max_seq) {
142
            //sequence number wrapped; count antother 64k cycles
143
            s->cycles += RTP_SEQ_MOD;
144
        }
145
        s->max_seq= seq;
146
    } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
147
        // sequence made a large jump...
148
        if(seq==s->bad_seq) {
149
            // two sequential packets-- assume that the other side restarted without telling us; just resync.
150
            rtp_init_sequence(s, seq);
151
        } else {
152
            s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
153
            return 0;
154
        }
155
    } else {
156
        // duplicate or reordered packet...
157
    }
158
    s->received++;
159
    return 1;
160
}
161

    
162
#if 0
163
/**
164
* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
165
* difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
166
* never change.  I left this in in case someone else can see a way. (rdm)
167
*/
168
static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
169
{
170
    uint32_t transit= arrival_timestamp - sent_timestamp;
171
    int d;
172
    s->transit= transit;
173
    d= FFABS(transit - s->transit);
174
    s->jitter += d - ((s->jitter + 8)>>4);
175
}
176
#endif
177

    
178
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
179
{
180
    ByteIOContext *pb;
181
    uint8_t *buf;
182
    int len;
183
    int rtcp_bytes;
184
    RTPStatistics *stats= &s->statistics;
185
    uint32_t lost;
186
    uint32_t extended_max;
187
    uint32_t expected_interval;
188
    uint32_t received_interval;
189
    uint32_t lost_interval;
190
    uint32_t expected;
191
    uint32_t fraction;
192
    uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
193

    
194
    if (!s->rtp_ctx || (count < 1))
195
        return -1;
196

    
197
    /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
198
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
199
    s->octet_count += count;
200
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
201
        RTCP_TX_RATIO_DEN;
202
    rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
203
    if (rtcp_bytes < 28)
204
        return -1;
205
    s->last_octet_count = s->octet_count;
206

    
207
    if (url_open_dyn_buf(&pb) < 0)
208
        return -1;
209

    
210
    // Receiver Report
211
    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
212
    put_byte(pb, 201);
213
    put_be16(pb, 7); /* length in words - 1 */
214
    put_be32(pb, s->ssrc); // our own SSRC
215
    put_be32(pb, s->ssrc); // XXX: should be the server's here!
216
    // some placeholders we should really fill...
217
    // RFC 1889/p64
218
    extended_max= stats->cycles + stats->max_seq;
219
    expected= extended_max - stats->base_seq + 1;
220
    lost= expected - stats->received;
221
    lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
222
    expected_interval= expected - stats->expected_prior;
223
    stats->expected_prior= expected;
224
    received_interval= stats->received - stats->received_prior;
225
    stats->received_prior= stats->received;
226
    lost_interval= expected_interval - received_interval;
227
    if (expected_interval==0 || lost_interval<=0) fraction= 0;
228
    else fraction = (lost_interval<<8)/expected_interval;
229

    
230
    fraction= (fraction<<24) | lost;
231

    
232
    put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
233
    put_be32(pb, extended_max); /* max sequence received */
234
    put_be32(pb, stats->jitter>>4); /* jitter */
235

    
236
    if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
237
    {
238
        put_be32(pb, 0); /* last SR timestamp */
239
        put_be32(pb, 0); /* delay since last SR */
240
    } else {
241
        uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
242
        uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
243

    
244
        put_be32(pb, middle_32_bits); /* last SR timestamp */
245
        put_be32(pb, delay_since_last); /* delay since last SR */
246
    }
247

    
248
    // CNAME
249
    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
250
    put_byte(pb, 202);
251
    len = strlen(s->hostname);
252
    put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
253
    put_be32(pb, s->ssrc);
254
    put_byte(pb, 0x01);
255
    put_byte(pb, len);
256
    put_buffer(pb, s->hostname, len);
257
    // padding
258
    for (len = (6 + len) % 4; len % 4; len++) {
259
        put_byte(pb, 0);
260
    }
261

    
262
    put_flush_packet(pb);
263
    len = url_close_dyn_buf(pb, &buf);
264
    if ((len > 0) && buf) {
265
        int result;
266
        dprintf(s->ic, "sending %d bytes of RR\n", len);
267
        result= url_write(s->rtp_ctx, buf, len);
268
        dprintf(s->ic, "result from url_write: %d\n", result);
269
        av_free(buf);
270
    }
271
    return 0;
272
}
273

    
274
void rtp_send_punch_packets(URLContext* rtp_handle)
275
{
276
    ByteIOContext *pb;
277
    uint8_t *buf;
278
    int len;
279

    
280
    /* Send a small RTP packet */
281
    if (url_open_dyn_buf(&pb) < 0)
282
        return;
283

    
284
    put_byte(pb, (RTP_VERSION << 6));
285
    put_byte(pb, 0); /* Payload type */
286
    put_be16(pb, 0); /* Seq */
287
    put_be32(pb, 0); /* Timestamp */
288
    put_be32(pb, 0); /* SSRC */
289

    
290
    put_flush_packet(pb);
291
    len = url_close_dyn_buf(pb, &buf);
292
    if ((len > 0) && buf)
293
        url_write(rtp_handle, buf, len);
294
    av_free(buf);
295

    
296
    /* Send a minimal RTCP RR */
297
    if (url_open_dyn_buf(&pb) < 0)
298
        return;
299

    
300
    put_byte(pb, (RTP_VERSION << 6));
301
    put_byte(pb, 201); /* receiver report */
302
    put_be16(pb, 1); /* length in words - 1 */
303
    put_be32(pb, 0); /* our own SSRC */
304

    
305
    put_flush_packet(pb);
306
    len = url_close_dyn_buf(pb, &buf);
307
    if ((len > 0) && buf)
308
        url_write(rtp_handle, buf, len);
309
    av_free(buf);
310
}
311

    
312

    
313
/**
314
 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
315
 * MPEG2TS streams to indicate that they should be demuxed inside the
316
 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
317
 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
318
 */
319
RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data)
320
{
321
    RTPDemuxContext *s;
322

    
323
    s = av_mallocz(sizeof(RTPDemuxContext));
324
    if (!s)
325
        return NULL;
326
    s->payload_type = payload_type;
327
    s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
328
    s->ic = s1;
329
    s->st = st;
330
    s->rtp_payload_data = rtp_payload_data;
331
    rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
332
    if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
333
        s->ts = ff_mpegts_parse_open(s->ic);
334
        if (s->ts == NULL) {
335
            av_free(s);
336
            return NULL;
337
        }
338
    } else {
339
        av_set_pts_info(st, 32, 1, 90000);
340
        switch(st->codec->codec_id) {
341
        case CODEC_ID_MPEG1VIDEO:
342
        case CODEC_ID_MPEG2VIDEO:
343
        case CODEC_ID_MP2:
344
        case CODEC_ID_MP3:
345
        case CODEC_ID_MPEG4:
346
        case CODEC_ID_H263:
347
        case CODEC_ID_H264:
348
            st->need_parsing = AVSTREAM_PARSE_FULL;
349
            break;
350
        default:
351
            if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
352
                av_set_pts_info(st, 32, 1, st->codec->sample_rate);
353
            }
354
            break;
355
        }
356
    }
357
    // needed to send back RTCP RR in RTSP sessions
358
    s->rtp_ctx = rtpc;
359
    gethostname(s->hostname, sizeof(s->hostname));
360
    return s;
361
}
362

    
363
void
364
rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
365
                               RTPDynamicProtocolHandler *handler)
366
{
367
    s->dynamic_protocol_context = ctx;
368
    s->parse_packet = handler->parse_packet;
369
}
370

    
371
static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
372
{
373
    int au_headers_length, au_header_size, i;
374
    GetBitContext getbitcontext;
375
    RTPPayloadData *infos;
376

    
377
    infos = s->rtp_payload_data;
378

    
379
    if (infos == NULL)
380
        return -1;
381

    
382
    /* decode the first 2 bytes where the AUHeader sections are stored
383
       length in bits */
384
    au_headers_length = AV_RB16(buf);
385

    
386
    if (au_headers_length > RTP_MAX_PACKET_LENGTH)
387
      return -1;
388

    
389
    infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
390

    
391
    /* skip AU headers length section (2 bytes) */
392
    buf += 2;
393

    
394
    init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
395

    
396
    /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
397
    au_header_size = infos->sizelength + infos->indexlength;
398
    if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
399
        return -1;
400

    
401
    infos->nb_au_headers = au_headers_length / au_header_size;
402
    infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
403

    
404
    /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
405
       In my test, the FAAD decoder does not behave correctly when sending each AU one by one
406
       but does when sending the whole as one big packet...  */
407
    infos->au_headers[0].size = 0;
408
    infos->au_headers[0].index = 0;
409
    for (i = 0; i < infos->nb_au_headers; ++i) {
410
        infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
411
        infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
412
    }
413

    
414
    infos->nb_au_headers = 1;
415

    
416
    return 0;
417
}
418

    
419
/**
420
 * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
421
 */
422
static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
423
{
424
    if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
425
        int64_t addend;
426
        int delta_timestamp;
427

    
428
        /* compute pts from timestamp with received ntp_time */
429
        delta_timestamp = timestamp - s->last_rtcp_timestamp;
430
        /* convert to the PTS timebase */
431
        addend = av_rescale(s->last_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
432
        pkt->pts = addend + delta_timestamp;
433
    }
434
}
435

    
436
/**
437
 * Parse an RTP or RTCP packet directly sent as a buffer.
438
 * @param s RTP parse context.
439
 * @param pkt returned packet
440
 * @param buf input buffer or NULL to read the next packets
441
 * @param len buffer len
442
 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
443
 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
444
 */
445
int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
446
                     const uint8_t *buf, int len)
447
{
448
    unsigned int ssrc, h;
449
    int payload_type, seq, ret, flags = 0;
450
    AVStream *st;
451
    uint32_t timestamp;
452
    int rv= 0;
453

    
454
    if (!buf) {
455
        /* return the next packets, if any */
456
        if(s->st && s->parse_packet) {
457
            timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
458
            rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
459
                                s->st, pkt, &timestamp, NULL, 0, flags);
460
            finalize_packet(s, pkt, timestamp);
461
            return rv;
462
        } else {
463
            // TODO: Move to a dynamic packet handler (like above)
464
            if (s->read_buf_index >= s->read_buf_size)
465
                return -1;
466
            ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
467
                                      s->read_buf_size - s->read_buf_index);
468
            if (ret < 0)
469
                return -1;
470
            s->read_buf_index += ret;
471
            if (s->read_buf_index < s->read_buf_size)
472
                return 1;
473
            else
474
                return 0;
475
        }
476
    }
477

    
478
    if (len < 12)
479
        return -1;
480

    
481
    if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
482
        return -1;
483
    if (buf[1] >= 200 && buf[1] <= 204) {
484
        rtcp_parse_packet(s, buf, len);
485
        return -1;
486
    }
487
    payload_type = buf[1] & 0x7f;
488
    if (buf[1] & 0x80)
489
        flags |= RTP_FLAG_MARKER;
490
    seq  = AV_RB16(buf + 2);
491
    timestamp = AV_RB32(buf + 4);
492
    ssrc = AV_RB32(buf + 8);
493
    /* store the ssrc in the RTPDemuxContext */
494
    s->ssrc = ssrc;
495

    
496
    /* NOTE: we can handle only one payload type */
497
    if (s->payload_type != payload_type)
498
        return -1;
499

    
500
    st = s->st;
501
    // only do something with this if all the rtp checks pass...
502
    if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
503
    {
504
        av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
505
               payload_type, seq, ((s->seq + 1) & 0xffff));
506
        return -1;
507
    }
508

    
509
    s->seq = seq;
510
    len -= 12;
511
    buf += 12;
512

    
513
    if (!st) {
514
        /* specific MPEG2TS demux support */
515
        ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
516
        if (ret < 0)
517
            return -1;
518
        if (ret < len) {
519
            s->read_buf_size = len - ret;
520
            memcpy(s->buf, buf + ret, s->read_buf_size);
521
            s->read_buf_index = 0;
522
            return 1;
523
        }
524
        return 0;
525
    } else if (s->parse_packet) {
526
        rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
527
                             s->st, pkt, &timestamp, buf, len, flags);
528
    } else {
529
        // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
530
        switch(st->codec->codec_id) {
531
        case CODEC_ID_MP2:
532
        case CODEC_ID_MP3:
533
            /* better than nothing: skip mpeg audio RTP header */
534
            if (len <= 4)
535
                return -1;
536
            h = AV_RB32(buf);
537
            len -= 4;
538
            buf += 4;
539
            av_new_packet(pkt, len);
540
            memcpy(pkt->data, buf, len);
541
            break;
542
        case CODEC_ID_MPEG1VIDEO:
543
        case CODEC_ID_MPEG2VIDEO:
544
            /* better than nothing: skip mpeg video RTP header */
545
            if (len <= 4)
546
                return -1;
547
            h = AV_RB32(buf);
548
            buf += 4;
549
            len -= 4;
550
            if (h & (1 << 26)) {
551
                /* mpeg2 */
552
                if (len <= 4)
553
                    return -1;
554
                buf += 4;
555
                len -= 4;
556
            }
557
            av_new_packet(pkt, len);
558
            memcpy(pkt->data, buf, len);
559
            break;
560
            // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
561
            // timestamps.
562
            // TODO: Put this into a dynamic packet handler...
563
        case CODEC_ID_AAC:
564
            if (rtp_parse_mp4_au(s, buf))
565
                return -1;
566
            {
567
                RTPPayloadData *infos = s->rtp_payload_data;
568
                if (infos == NULL)
569
                    return -1;
570
                buf += infos->au_headers_length_bytes + 2;
571
                len -= infos->au_headers_length_bytes + 2;
572

    
573
                /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
574
                    one au_header */
575
                av_new_packet(pkt, infos->au_headers[0].size);
576
                memcpy(pkt->data, buf, infos->au_headers[0].size);
577
                buf += infos->au_headers[0].size;
578
                len -= infos->au_headers[0].size;
579
            }
580
            s->read_buf_size = len;
581
            rv= 0;
582
            break;
583
        default:
584
            av_new_packet(pkt, len);
585
            memcpy(pkt->data, buf, len);
586
            break;
587
        }
588

    
589
        pkt->stream_index = st->index;
590
    }
591

    
592
    // now perform timestamp things....
593
    finalize_packet(s, pkt, timestamp);
594

    
595
    return rv;
596
}
597

    
598
void rtp_parse_close(RTPDemuxContext *s)
599
{
600
    // TODO: fold this into the protocol specific data fields.
601
    if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
602
        ff_mpegts_parse_close(s->ts);
603
    }
604
    av_free(s);
605
}