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 */
51RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
52
53static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG4};
54static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC};
55
56void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
57{
58    handler->next= RTPFirstDynamicPayloadHandler;
59    RTPFirstDynamicPayloadHandler= handler;
60}
61
62void 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
78static 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*/
94static 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*/
104static 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*/
120static 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*/
171static 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
181int 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
277void 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 */
322RTPDemuxContext *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
367void
368rtp_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
375static 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 */
430static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
431{
432    if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
433        int64_t addend;
434        int delta_timestamp;
435
436        /* compute pts from timestamp with received ntp_time */
437        delta_timestamp = timestamp - s->last_rtcp_timestamp;
438        /* convert to the PTS timebase */
439        addend = av_rescale(s->last_rtcp_ntp_time - s->first_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
440        pkt->pts = s->range_start_offset + addend + delta_timestamp;
441    }
442}
443
444/**
445 * Parse an RTP or RTCP packet directly sent as a buffer.
446 * @param s RTP parse context.
447 * @param pkt returned packet
448 * @param buf input buffer or NULL to read the next packets
449 * @param len buffer len
450 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
451 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
452 */
453int 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
606void 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}
616