Split the RTP demuxing functions out of rtp.c, to simplify the RTP muxer's dependencies

Originally committed as revision 11406 to svn://svn.ffmpeg.org/ffmpeg/trunk

3 files changed, 556 insertions, 526 deletions

diff --git a/libavformat/Makefile b/libavformat/Makefile
index 36fbaed235..7664087bbe 100644
--- a/libavformat/Makefile
+++ b/libavformat/Makefile
@@ -121,9 +121,9 @@ OBJS-$(CONFIG_RM_DEMUXER)                += rmdec.o
 OBJS-$(CONFIG_RM_MUXER)                  += rmenc.o
 OBJS-$(CONFIG_ROQ_DEMUXER)               += idroq.o
 OBJS-$(CONFIG_ROQ_MUXER)                 += raw.o
-OBJS-$(CONFIG_RTP_MUXER)                 += rtp.o rtp_h264.o rtsp.o rtp_mpv.o rtp_aac.o
+OBJS-$(CONFIG_RTP_MUXER)                 += rtp.o rtp_mpv.o rtp_aac.o
 OBJS-$(CONFIG_RTSP_DEMUXER)              += rtsp.o
-OBJS-$(CONFIG_SDP_DEMUXER)               += rtsp.o rtp.o rtp_h264.o rtp_mpv.o rtp_aac.o
+OBJS-$(CONFIG_SDP_DEMUXER)               += rtsp.o rtp.o rtpdec.o rtp_h264.o rtp_mpv.o rtp_aac.o
 OBJS-$(CONFIG_SEGAFILM_DEMUXER)          += segafilm.o
 OBJS-$(CONFIG_SHORTEN_DEMUXER)           += raw.o
 OBJS-$(CONFIG_SIFF_DEMUXER)              += siff.o
diff --git a/libavformat/rtp.c b/libavformat/rtp.c
index f21b162a89..7841ef641f 100644
--- a/libavformat/rtp.c
+++ b/libavformat/rtp.c
@@ -26,7 +26,6 @@
 #include "network.h"
 
 #include "rtp_internal.h"
-#include "rtp_h264.h"
 #include "rtp_mpv.h"
 #include "rtp_aac.h"
 
@@ -34,15 +33,6 @@
 
 #define RTCP_SR_SIZE 28
 
-/* TODO: - add RTCP statistics reporting (should be optional).
-
-         - add support for h263/mpeg4 packetized output : IDEA: send a
-         buffer to 'rtp_write_packet' contains all the packets for ONE
-         frame. Each packet should have a four byte header containing
-         the length in big endian format (same trick as
-         'url_open_dyn_packet_buf')
-*/
-
 /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
 AVRtpPayloadType_t AVRtpPayloadTypes[]=
 {
@@ -178,25 +168,6 @@ AVRtpPayloadType_t AVRtpPayloadTypes[]=
   {-1, "",           CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
 };
 
-/* statistics functions */
-RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
-
-static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
-static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
-
-static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
-{
-    handler->next= RTPFirstDynamicPayloadHandler;
-    RTPFirstDynamicPayloadHandler= handler;
-}
-
-void av_register_rtp_dynamic_payload_handlers(void)
-{
-    register_dynamic_payload_handler(&mp4v_es_handler);
-    register_dynamic_payload_handler(&mpeg4_generic_handler);
-    register_dynamic_payload_handler(&ff_h264_dynamic_handler);
-}
-
 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
 {
     int i = 0;
@@ -255,501 +226,6 @@ enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type)
     return CODEC_ID_NONE;
 }
 
-static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
-{
-    if (buf[1] != 200)
-        return -1;
-    s->last_rtcp_ntp_time = AV_RB64(buf + 8);
-    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
-        s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
-    s->last_rtcp_timestamp = AV_RB32(buf + 16);
-    return 0;
-}
-
-#define RTP_SEQ_MOD (1<<16)
-
-/**
-* called on parse open packet
-*/
-static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
-{
-    memset(s, 0, sizeof(RTPStatistics));
-    s->max_seq= base_sequence;
-    s->probation= 1;
-}
-
-/**
-* called whenever there is a large jump in sequence numbers, or when they get out of probation...
-*/
-static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
-{
-    s->max_seq= seq;
-    s->cycles= 0;
-    s->base_seq= seq -1;
-    s->bad_seq= RTP_SEQ_MOD + 1;
-    s->received= 0;
-    s->expected_prior= 0;
-    s->received_prior= 0;
-    s->jitter= 0;
-    s->transit= 0;
-}
-
-/**
-* returns 1 if we should handle this packet.
-*/
-static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
-{
-    uint16_t udelta= seq - s->max_seq;
-    const int MAX_DROPOUT= 3000;
-    const int MAX_MISORDER = 100;
-    const int MIN_SEQUENTIAL = 2;
-
-    /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
-    if(s->probation)
-    {
-        if(seq==s->max_seq + 1) {
-            s->probation--;
-            s->max_seq= seq;
-            if(s->probation==0) {
-                rtp_init_sequence(s, seq);
-                s->received++;
-                return 1;
-            }
-        } else {
-            s->probation= MIN_SEQUENTIAL - 1;
-            s->max_seq = seq;
-        }
-    } else if (udelta < MAX_DROPOUT) {
-        // in order, with permissible gap
-        if(seq < s->max_seq) {
-            //sequence number wrapped; count antother 64k cycles
-            s->cycles += RTP_SEQ_MOD;
-        }
-        s->max_seq= seq;
-    } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
-        // sequence made a large jump...
-        if(seq==s->bad_seq) {
-            // two sequential packets-- assume that the other side restarted without telling us; just resync.
-            rtp_init_sequence(s, seq);
-        } else {
-            s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
-            return 0;
-        }
-    } else {
-        // duplicate or reordered packet...
-    }
-    s->received++;
-    return 1;
-}
-
-#if 0
-/**
-* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
-* difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
-* never change.  I left this in in case someone else can see a way. (rdm)
-*/
-static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
-{
-    uint32_t transit= arrival_timestamp - sent_timestamp;
-    int d;
-    s->transit= transit;
-    d= FFABS(transit - s->transit);
-    s->jitter += d - ((s->jitter + 8)>>4);
-}
-#endif
-
-int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
-{
-    ByteIOContext *pb;
-    uint8_t *buf;
-    int len;
-    int rtcp_bytes;
-    RTPStatistics *stats= &s->statistics;
-    uint32_t lost;
-    uint32_t extended_max;
-    uint32_t expected_interval;
-    uint32_t received_interval;
-    uint32_t lost_interval;
-    uint32_t expected;
-    uint32_t fraction;
-    uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
-
-    if (!s->rtp_ctx || (count < 1))
-        return -1;
-
-    /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
-    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
-    s->octet_count += count;
-    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
-        RTCP_TX_RATIO_DEN;
-    rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
-    if (rtcp_bytes < 28)
-        return -1;
-    s->last_octet_count = s->octet_count;
-
-    if (url_open_dyn_buf(&pb) < 0)
-        return -1;
-
-    // Receiver Report
-    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
-    put_byte(pb, 201);
-    put_be16(pb, 7); /* length in words - 1 */
-    put_be32(pb, s->ssrc); // our own SSRC
-    put_be32(pb, s->ssrc); // XXX: should be the server's here!
-    // some placeholders we should really fill...
-    // RFC 1889/p64
-    extended_max= stats->cycles + stats->max_seq;
-    expected= extended_max - stats->base_seq + 1;
-    lost= expected - stats->received;
-    lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
-    expected_interval= expected - stats->expected_prior;
-    stats->expected_prior= expected;
-    received_interval= stats->received - stats->received_prior;
-    stats->received_prior= stats->received;
-    lost_interval= expected_interval - received_interval;
-    if (expected_interval==0 || lost_interval<=0) fraction= 0;
-    else fraction = (lost_interval<<8)/expected_interval;
-
-    fraction= (fraction<<24) | lost;
-
-    put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
-    put_be32(pb, extended_max); /* max sequence received */
-    put_be32(pb, stats->jitter>>4); /* jitter */
-
-    if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
-    {
-        put_be32(pb, 0); /* last SR timestamp */
-        put_be32(pb, 0); /* delay since last SR */
-    } else {
-        uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
-        uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
-
-        put_be32(pb, middle_32_bits); /* last SR timestamp */
-        put_be32(pb, delay_since_last); /* delay since last SR */
-    }
-
-    // CNAME
-    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
-    put_byte(pb, 202);
-    len = strlen(s->hostname);
-    put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
-    put_be32(pb, s->ssrc);
-    put_byte(pb, 0x01);
-    put_byte(pb, len);
-    put_buffer(pb, s->hostname, len);
-    // padding
-    for (len = (6 + len) % 4; len % 4; len++) {
-        put_byte(pb, 0);
-    }
-
-    put_flush_packet(pb);
-    len = url_close_dyn_buf(pb, &buf);
-    if ((len > 0) && buf) {
-        int result;
-#if defined(DEBUG)
-        printf("sending %d bytes of RR\n", len);
-#endif
-        result= url_write(s->rtp_ctx, buf, len);
-#if defined(DEBUG)
-        printf("result from url_write: %d\n", result);
-#endif
-        av_free(buf);
-    }
-    return 0;
-}
-
-/**
- * open a new RTP parse context for stream 'st'. 'st' can be NULL for
- * MPEG2TS streams to indicate that they should be demuxed inside the
- * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
- * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
- */
-RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
-{
-    RTPDemuxContext *s;
-
-    s = av_mallocz(sizeof(RTPDemuxContext));
-    if (!s)
-        return NULL;
-    s->payload_type = payload_type;
-    s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
-    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
-    s->ic = s1;
-    s->st = st;
-    s->rtp_payload_data = rtp_payload_data;
-    rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
-    if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
-        s->ts = mpegts_parse_open(s->ic);
-        if (s->ts == NULL) {
-            av_free(s);
-            return NULL;
-        }
-    } else {
-        switch(st->codec->codec_id) {
-        case CODEC_ID_MPEG1VIDEO:
-        case CODEC_ID_MPEG2VIDEO:
-        case CODEC_ID_MP2:
-        case CODEC_ID_MP3:
-        case CODEC_ID_MPEG4:
-        case CODEC_ID_H264:
-            st->need_parsing = AVSTREAM_PARSE_FULL;
-            break;
-        default:
-            break;
-        }
-    }
-    // needed to send back RTCP RR in RTSP sessions
-    s->rtp_ctx = rtpc;
-    gethostname(s->hostname, sizeof(s->hostname));
-    return s;
-}
-
-static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
-{
-    int au_headers_length, au_header_size, i;
-    GetBitContext getbitcontext;
-    rtp_payload_data_t *infos;
-
-    infos = s->rtp_payload_data;
-
-    if (infos == NULL)
-        return -1;
-
-    /* decode the first 2 bytes where are stored the AUHeader sections
-       length in bits */
-    au_headers_length = AV_RB16(buf);
-
-    if (au_headers_length > RTP_MAX_PACKET_LENGTH)
-      return -1;
-
-    infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
-
-    /* skip AU headers length section (2 bytes) */
-    buf += 2;
-
-    init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
-
-    /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
-    au_header_size = infos->sizelength + infos->indexlength;
-    if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
-        return -1;
-
-    infos->nb_au_headers = au_headers_length / au_header_size;
-    infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
-
-    /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
-       In my test, the FAAD decoder does not behave correctly when sending each AU one by one
-       but does when sending the whole as one big packet...  */
-    infos->au_headers[0].size = 0;
-    infos->au_headers[0].index = 0;
-    for (i = 0; i < infos->nb_au_headers; ++i) {
-        infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
-        infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
-    }
-
-    infos->nb_au_headers = 1;
-
-    return 0;
-}
-
-/**
- * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
- */
-static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
-{
-    switch(s->st->codec->codec_id) {
-        case CODEC_ID_MP2:
-        case CODEC_ID_MPEG1VIDEO:
-        case CODEC_ID_MPEG2VIDEO:
-            if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
-                int64_t addend;
-
-                int delta_timestamp;
-                /* XXX: is it really necessary to unify the timestamp base ? */
-                /* compute pts from timestamp with received ntp_time */
-                delta_timestamp = timestamp - s->last_rtcp_timestamp;
-                /* convert to 90 kHz without overflow */
-                addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
-                addend = (addend * 5625) >> 14;
-                pkt->pts = addend + delta_timestamp;
-            }
-            break;
-        case CODEC_ID_AAC:
-        case CODEC_ID_H264:
-        case CODEC_ID_MPEG4:
-            pkt->pts = timestamp;
-            break;
-        default:
-            /* no timestamp info yet */
-            break;
-    }
-    pkt->stream_index = s->st->index;
-}
-
-/**
- * Parse an RTP or RTCP packet directly sent as a buffer.
- * @param s RTP parse context.
- * @param pkt returned packet
- * @param buf input buffer or NULL to read the next packets
- * @param len buffer len
- * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
- * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
- */
-int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
-                     const uint8_t *buf, int len)
-{
-    unsigned int ssrc, h;
-    int payload_type, seq, ret;
-    AVStream *st;
-    uint32_t timestamp;
-    int rv= 0;
-
-    if (!buf) {
-        /* return the next packets, if any */
-        if(s->st && s->parse_packet) {
-            timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
-            rv= s->parse_packet(s, pkt, &timestamp, NULL, 0);
-            finalize_packet(s, pkt, timestamp);
-            return rv;
-        } else {
-            // TODO: Move to a dynamic packet handler (like above)
-            if (s->read_buf_index >= s->read_buf_size)
-                return -1;
-            ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
-                                      s->read_buf_size - s->read_buf_index);
-            if (ret < 0)
-                return -1;
-            s->read_buf_index += ret;
-            if (s->read_buf_index < s->read_buf_size)
-                return 1;
-            else
-                return 0;
-        }
-    }
-
-    if (len < 12)
-        return -1;
-
-    if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
-        return -1;
-    if (buf[1] >= 200 && buf[1] <= 204) {
-        rtcp_parse_packet(s, buf, len);
-        return -1;
-    }
-    payload_type = buf[1] & 0x7f;
-    seq  = AV_RB16(buf + 2);
-    timestamp = AV_RB32(buf + 4);
-    ssrc = AV_RB32(buf + 8);
-    /* store the ssrc in the RTPDemuxContext */
-    s->ssrc = ssrc;
-
-    /* NOTE: we can handle only one payload type */
-    if (s->payload_type != payload_type)
-        return -1;
-
-    st = s->st;
-    // only do something with this if all the rtp checks pass...
-    if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
-    {
-        av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
-               payload_type, seq, ((s->seq + 1) & 0xffff));
-        return -1;
-    }
-
-    s->seq = seq;
-    len -= 12;
-    buf += 12;
-
-    if (!st) {
-        /* specific MPEG2TS demux support */
-        ret = mpegts_parse_packet(s->ts, pkt, buf, len);
-        if (ret < 0)
-            return -1;
-        if (ret < len) {
-            s->read_buf_size = len - ret;
-            memcpy(s->buf, buf + ret, s->read_buf_size);
-            s->read_buf_index = 0;
-            return 1;
-        }
-    } else {
-        // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
-        switch(st->codec->codec_id) {
-        case CODEC_ID_MP2:
-            /* better than nothing: skip mpeg audio RTP header */
-            if (len <= 4)
-                return -1;
-            h = AV_RB32(buf);
-            len -= 4;
-            buf += 4;
-            av_new_packet(pkt, len);
-            memcpy(pkt->data, buf, len);
-            break;
-        case CODEC_ID_MPEG1VIDEO:
-        case CODEC_ID_MPEG2VIDEO:
-            /* better than nothing: skip mpeg video RTP header */
-            if (len <= 4)
-                return -1;
-            h = AV_RB32(buf);
-            buf += 4;
-            len -= 4;
-            if (h & (1 << 26)) {
-                /* mpeg2 */
-                if (len <= 4)
-                    return -1;
-                buf += 4;
-                len -= 4;
-            }
-            av_new_packet(pkt, len);
-            memcpy(pkt->data, buf, len);
-            break;
-            // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
-            // timestamps.
-            // TODO: Put this into a dynamic packet handler...
-        case CODEC_ID_AAC:
-            if (rtp_parse_mp4_au(s, buf))
-                return -1;
-            {
-                rtp_payload_data_t *infos = s->rtp_payload_data;
-                if (infos == NULL)
-                    return -1;
-                buf += infos->au_headers_length_bytes + 2;
-                len -= infos->au_headers_length_bytes + 2;
-
-                /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
-                    one au_header */
-                av_new_packet(pkt, infos->au_headers[0].size);
-                memcpy(pkt->data, buf, infos->au_headers[0].size);
-                buf += infos->au_headers[0].size;
-                len -= infos->au_headers[0].size;
-            }
-            s->read_buf_size = len;
-            rv= 0;
-            break;
-        default:
-            if(s->parse_packet) {
-                rv= s->parse_packet(s, pkt, &timestamp, buf, len);
-            } else {
-                av_new_packet(pkt, len);
-                memcpy(pkt->data, buf, len);
-            }
-            break;
-        }
-
-        // now perform timestamp things....
-        finalize_packet(s, pkt, timestamp);
-    }
-    return rv;
-}
-
-void rtp_parse_close(RTPDemuxContext *s)
-{
-    // TODO: fold this into the protocol specific data fields.
-    if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
-        mpegts_parse_close(s->ts);
-    }
-    av_free(s);
-}
-
 /* rtp output */
 
 static int rtp_write_header(AVFormatContext *s1)
diff --git a/libavformat/rtpdec.c b/libavformat/rtpdec.c
new file mode 100644
index 0000000000..f5e2d6dd6f
--- /dev/null
+++ b/libavformat/rtpdec.c
@@ -0,0 +1,554 @@
+/*
+ * RTP input format
+ * Copyright (c) 2002 Fabrice Bellard.
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include "avformat.h"
+#include "mpegts.h"
+#include "bitstream.h"
+
+#include <unistd.h>
+#include "network.h"
+
+#include "rtp_internal.h"
+#include "rtp_h264.h"
+
+//#define DEBUG
+
+/* TODO: - add RTCP statistics reporting (should be optional).
+
+         - add support for h263/mpeg4 packetized output : IDEA: send a
+         buffer to 'rtp_write_packet' contains all the packets for ONE
+         frame. Each packet should have a four byte header containing
+         the length in big endian format (same trick as
+         'url_open_dyn_packet_buf')
+*/
+
+/* statistics functions */
+RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
+
+static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
+static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
+
+static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
+{
+    handler->next= RTPFirstDynamicPayloadHandler;
+    RTPFirstDynamicPayloadHandler= handler;
+}
+
+void av_register_rtp_dynamic_payload_handlers(void)
+{
+    register_dynamic_payload_handler(&mp4v_es_handler);
+    register_dynamic_payload_handler(&mpeg4_generic_handler);
+    register_dynamic_payload_handler(&ff_h264_dynamic_handler);
+}
+
+static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
+{
+    if (buf[1] != 200)
+        return -1;
+    s->last_rtcp_ntp_time = AV_RB64(buf + 8);
+    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
+        s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
+    s->last_rtcp_timestamp = AV_RB32(buf + 16);
+    return 0;
+}
+
+#define RTP_SEQ_MOD (1<<16)
+
+/**
+* called on parse open packet
+*/
+static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
+{
+    memset(s, 0, sizeof(RTPStatistics));
+    s->max_seq= base_sequence;
+    s->probation= 1;
+}
+
+/**
+* called whenever there is a large jump in sequence numbers, or when they get out of probation...
+*/
+static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
+{
+    s->max_seq= seq;
+    s->cycles= 0;
+    s->base_seq= seq -1;
+    s->bad_seq= RTP_SEQ_MOD + 1;
+    s->received= 0;
+    s->expected_prior= 0;
+    s->received_prior= 0;
+    s->jitter= 0;
+    s->transit= 0;
+}
+
+/**
+* returns 1 if we should handle this packet.
+*/
+static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
+{
+    uint16_t udelta= seq - s->max_seq;
+    const int MAX_DROPOUT= 3000;
+    const int MAX_MISORDER = 100;
+    const int MIN_SEQUENTIAL = 2;
+
+    /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
+    if(s->probation)
+    {
+        if(seq==s->max_seq + 1) {
+            s->probation--;
+            s->max_seq= seq;
+            if(s->probation==0) {
+                rtp_init_sequence(s, seq);
+                s->received++;
+                return 1;
+            }
+        } else {
+            s->probation= MIN_SEQUENTIAL - 1;
+            s->max_seq = seq;
+        }
+    } else if (udelta < MAX_DROPOUT) {
+        // in order, with permissible gap
+        if(seq < s->max_seq) {
+            //sequence number wrapped; count antother 64k cycles
+            s->cycles += RTP_SEQ_MOD;
+        }
+        s->max_seq= seq;
+    } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
+        // sequence made a large jump...
+        if(seq==s->bad_seq) {
+            // two sequential packets-- assume that the other side restarted without telling us; just resync.
+            rtp_init_sequence(s, seq);
+        } else {
+            s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
+            return 0;
+        }
+    } else {
+        // duplicate or reordered packet...
+    }
+    s->received++;
+    return 1;
+}
+
+#if 0
+/**
+* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
+* difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
+* never change.  I left this in in case someone else can see a way. (rdm)
+*/
+static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
+{
+    uint32_t transit= arrival_timestamp - sent_timestamp;
+    int d;
+    s->transit= transit;
+    d= FFABS(transit - s->transit);
+    s->jitter += d - ((s->jitter + 8)>>4);
+}
+#endif
+
+int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
+{
+    ByteIOContext *pb;
+    uint8_t *buf;
+    int len;
+    int rtcp_bytes;
+    RTPStatistics *stats= &s->statistics;
+    uint32_t lost;
+    uint32_t extended_max;
+    uint32_t expected_interval;
+    uint32_t received_interval;
+    uint32_t lost_interval;
+    uint32_t expected;
+    uint32_t fraction;
+    uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
+
+    if (!s->rtp_ctx || (count < 1))
+        return -1;
+
+    /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
+    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
+    s->octet_count += count;
+    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
+        RTCP_TX_RATIO_DEN;
+    rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
+    if (rtcp_bytes < 28)
+        return -1;
+    s->last_octet_count = s->octet_count;
+
+    if (url_open_dyn_buf(&pb) < 0)
+        return -1;
+
+    // Receiver Report
+    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
+    put_byte(pb, 201);
+    put_be16(pb, 7); /* length in words - 1 */
+    put_be32(pb, s->ssrc); // our own SSRC
+    put_be32(pb, s->ssrc); // XXX: should be the server's here!
+    // some placeholders we should really fill...
+    // RFC 1889/p64
+    extended_max= stats->cycles + stats->max_seq;
+    expected= extended_max - stats->base_seq + 1;
+    lost= expected - stats->received;
+    lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
+    expected_interval= expected - stats->expected_prior;
+    stats->expected_prior= expected;
+    received_interval= stats->received - stats->received_prior;
+    stats->received_prior= stats->received;
+    lost_interval= expected_interval - received_interval;
+    if (expected_interval==0 || lost_interval<=0) fraction= 0;
+    else fraction = (lost_interval<<8)/expected_interval;
+
+    fraction= (fraction<<24) | lost;
+
+    put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
+    put_be32(pb, extended_max); /* max sequence received */
+    put_be32(pb, stats->jitter>>4); /* jitter */
+
+    if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
+    {
+        put_be32(pb, 0); /* last SR timestamp */
+        put_be32(pb, 0); /* delay since last SR */
+    } else {
+        uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
+        uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
+
+        put_be32(pb, middle_32_bits); /* last SR timestamp */
+        put_be32(pb, delay_since_last); /* delay since last SR */
+    }
+
+    // CNAME
+    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
+    put_byte(pb, 202);
+    len = strlen(s->hostname);
+    put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
+    put_be32(pb, s->ssrc);
+    put_byte(pb, 0x01);
+    put_byte(pb, len);
+    put_buffer(pb, s->hostname, len);
+    // padding
+    for (len = (6 + len) % 4; len % 4; len++) {
+        put_byte(pb, 0);
+    }
+
+    put_flush_packet(pb);
+    len = url_close_dyn_buf(pb, &buf);
+    if ((len > 0) && buf) {
+        int result;
+#if defined(DEBUG)
+        printf("sending %d bytes of RR\n", len);
+#endif
+        result= url_write(s->rtp_ctx, buf, len);
+#if defined(DEBUG)
+        printf("result from url_write: %d\n", result);
+#endif
+        av_free(buf);
+    }
+    return 0;
+}
+
+/**
+ * open a new RTP parse context for stream 'st'. 'st' can be NULL for
+ * MPEG2TS streams to indicate that they should be demuxed inside the
+ * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
+ * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
+ */
+RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
+{
+    RTPDemuxContext *s;
+
+    s = av_mallocz(sizeof(RTPDemuxContext));
+    if (!s)
+        return NULL;
+    s->payload_type = payload_type;
+    s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
+    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
+    s->ic = s1;
+    s->st = st;
+    s->rtp_payload_data = rtp_payload_data;
+    rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
+    if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
+        s->ts = mpegts_parse_open(s->ic);
+        if (s->ts == NULL) {
+            av_free(s);
+            return NULL;
+        }
+    } else {
+        switch(st->codec->codec_id) {
+        case CODEC_ID_MPEG1VIDEO:
+        case CODEC_ID_MPEG2VIDEO:
+        case CODEC_ID_MP2:
+        case CODEC_ID_MP3:
+        case CODEC_ID_MPEG4:
+        case CODEC_ID_H264:
+            st->need_parsing = AVSTREAM_PARSE_FULL;
+            break;
+        default:
+            break;
+        }
+    }
+    // needed to send back RTCP RR in RTSP sessions
+    s->rtp_ctx = rtpc;
+    gethostname(s->hostname, sizeof(s->hostname));
+    return s;
+}
+
+static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
+{
+    int au_headers_length, au_header_size, i;
+    GetBitContext getbitcontext;
+    rtp_payload_data_t *infos;
+
+    infos = s->rtp_payload_data;
+
+    if (infos == NULL)
+        return -1;
+
+    /* decode the first 2 bytes where are stored the AUHeader sections
+       length in bits */
+    au_headers_length = AV_RB16(buf);
+
+    if (au_headers_length > RTP_MAX_PACKET_LENGTH)
+      return -1;
+
+    infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
+
+    /* skip AU headers length section (2 bytes) */
+    buf += 2;
+
+    init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
+
+    /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
+    au_header_size = infos->sizelength + infos->indexlength;
+    if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
+        return -1;
+
+    infos->nb_au_headers = au_headers_length / au_header_size;
+    infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
+
+    /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
+       In my test, the FAAD decoder does not behave correctly when sending each AU one by one
+       but does when sending the whole as one big packet...  */
+    infos->au_headers[0].size = 0;
+    infos->au_headers[0].index = 0;
+    for (i = 0; i < infos->nb_au_headers; ++i) {
+        infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
+        infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
+    }
+
+    infos->nb_au_headers = 1;
+
+    return 0;
+}
+
+/**
+ * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
+ */
+static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
+{
+    switch(s->st->codec->codec_id) {
+        case CODEC_ID_MP2:
+        case CODEC_ID_MPEG1VIDEO:
+        case CODEC_ID_MPEG2VIDEO:
+            if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
+                int64_t addend;
+
+                int delta_timestamp;
+                /* XXX: is it really necessary to unify the timestamp base ? */
+                /* compute pts from timestamp with received ntp_time */
+                delta_timestamp = timestamp - s->last_rtcp_timestamp;
+                /* convert to 90 kHz without overflow */
+                addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
+                addend = (addend * 5625) >> 14;
+                pkt->pts = addend + delta_timestamp;
+            }
+            break;
+        case CODEC_ID_AAC:
+        case CODEC_ID_H264:
+        case CODEC_ID_MPEG4:
+            pkt->pts = timestamp;
+            break;
+        default:
+            /* no timestamp info yet */
+            break;
+    }
+    pkt->stream_index = s->st->index;
+}
+
+/**
+ * Parse an RTP or RTCP packet directly sent as a buffer.
+ * @param s RTP parse context.
+ * @param pkt returned packet
+ * @param buf input buffer or NULL to read the next packets
+ * @param len buffer len
+ * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
+ * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
+ */
+int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
+                     const uint8_t *buf, int len)
+{
+    unsigned int ssrc, h;
+    int payload_type, seq, ret;
+    AVStream *st;
+    uint32_t timestamp;
+    int rv= 0;
+
+    if (!buf) {
+        /* return the next packets, if any */
+        if(s->st && s->parse_packet) {
+            timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
+            rv= s->parse_packet(s, pkt, &timestamp, NULL, 0);
+            finalize_packet(s, pkt, timestamp);
+            return rv;
+        } else {
+            // TODO: Move to a dynamic packet handler (like above)
+            if (s->read_buf_index >= s->read_buf_size)
+                return -1;
+            ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
+                                      s->read_buf_size - s->read_buf_index);
+            if (ret < 0)
+                return -1;
+            s->read_buf_index += ret;
+            if (s->read_buf_index < s->read_buf_size)
+                return 1;
+            else
+                return 0;
+        }
+    }
+
+    if (len < 12)
+        return -1;
+
+    if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
+        return -1;
+    if (buf[1] >= 200 && buf[1] <= 204) {
+        rtcp_parse_packet(s, buf, len);
+        return -1;
+    }
+    payload_type = buf[1] & 0x7f;
+    seq  = AV_RB16(buf + 2);
+    timestamp = AV_RB32(buf + 4);
+    ssrc = AV_RB32(buf + 8);
+    /* store the ssrc in the RTPDemuxContext */
+    s->ssrc = ssrc;
+
+    /* NOTE: we can handle only one payload type */
+    if (s->payload_type != payload_type)
+        return -1;
+
+    st = s->st;
+    // only do something with this if all the rtp checks pass...
+    if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
+    {
+        av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
+               payload_type, seq, ((s->seq + 1) & 0xffff));
+        return -1;
+    }
+
+    s->seq = seq;
+    len -= 12;
+    buf += 12;
+
+    if (!st) {
+        /* specific MPEG2TS demux support */
+        ret = mpegts_parse_packet(s->ts, pkt, buf, len);
+        if (ret < 0)
+            return -1;
+        if (ret < len) {
+            s->read_buf_size = len - ret;
+            memcpy(s->buf, buf + ret, s->read_buf_size);
+            s->read_buf_index = 0;
+            return 1;
+        }
+    } else {
+        // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
+        switch(st->codec->codec_id) {
+        case CODEC_ID_MP2:
+            /* better than nothing: skip mpeg audio RTP header */
+            if (len <= 4)
+                return -1;
+            h = AV_RB32(buf);
+            len -= 4;
+            buf += 4;
+            av_new_packet(pkt, len);
+            memcpy(pkt->data, buf, len);
+            break;
+        case CODEC_ID_MPEG1VIDEO:
+        case CODEC_ID_MPEG2VIDEO:
+            /* better than nothing: skip mpeg video RTP header */
+            if (len <= 4)
+                return -1;
+            h = AV_RB32(buf);
+            buf += 4;
+            len -= 4;
+            if (h & (1 << 26)) {
+                /* mpeg2 */
+                if (len <= 4)
+                    return -1;
+                buf += 4;
+                len -= 4;
+            }
+            av_new_packet(pkt, len);
+            memcpy(pkt->data, buf, len);
+            break;
+            // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
+            // timestamps.
+            // TODO: Put this into a dynamic packet handler...
+        case CODEC_ID_AAC:
+            if (rtp_parse_mp4_au(s, buf))
+                return -1;
+            {
+                rtp_payload_data_t *infos = s->rtp_payload_data;
+                if (infos == NULL)
+                    return -1;
+                buf += infos->au_headers_length_bytes + 2;
+                len -= infos->au_headers_length_bytes + 2;
+
+                /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
+                    one au_header */
+                av_new_packet(pkt, infos->au_headers[0].size);
+                memcpy(pkt->data, buf, infos->au_headers[0].size);
+                buf += infos->au_headers[0].size;
+                len -= infos->au_headers[0].size;
+            }
+            s->read_buf_size = len;
+            rv= 0;
+            break;
+        default:
+            if(s->parse_packet) {
+                rv= s->parse_packet(s, pkt, &timestamp, buf, len);
+            } else {
+                av_new_packet(pkt, len);
+                memcpy(pkt->data, buf, len);
+            }
+            break;
+        }
+
+        // now perform timestamp things....
+        finalize_packet(s, pkt, timestamp);
+    }
+    return rv;
+}
+
+void rtp_parse_close(RTPDemuxContext *s)
+{
+    // TODO: fold this into the protocol specific data fields.
+    if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
+        mpegts_parse_close(s->ts);
+    }
+    av_free(s);
+}