/* * 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 "libavcodec/bitstream.h"#include "avformat.h"#include "mpegts.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);}#endifint 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)