RTP depacketization of Theora
[ffmpeg.git] / libavformat / rtpdec.c
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 #include "rtpdec_theora.h"
39
40 //#define DEBUG
41
42 /* TODO: - add RTCP statistics reporting (should be optional).
43
44          - add support for h263/mpeg4 packetized output : IDEA: send a
45          buffer to 'rtp_write_packet' contains all the packets for ONE
46          frame. Each packet should have a four byte header containing
47          the length in big endian format (same trick as
48          'url_open_dyn_packet_buf')
49 */
50
51 /* statistics functions */
52 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
53
54 static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
55 static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
56
57 void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
58 {
59     handler->next= RTPFirstDynamicPayloadHandler;
60     RTPFirstDynamicPayloadHandler= handler;
61 }
62
63 void av_register_rtp_dynamic_payload_handlers(void)
64 {
65     ff_register_dynamic_payload_handler(&mp4v_es_handler);
66     ff_register_dynamic_payload_handler(&mpeg4_generic_handler);
67     ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler);
68     ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler);
69     ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler);
70     ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler);
71     ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
72     ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
73     ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
74
75     ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
76     ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
77 }
78
79 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
80 {
81     if (buf[1] != 200)
82         return -1;
83     s->last_rtcp_ntp_time = AV_RB64(buf + 8);
84     s->last_rtcp_timestamp = AV_RB32(buf + 16);
85     return 0;
86 }
87
88 #define RTP_SEQ_MOD (1<<16)
89
90 /**
91 * called on parse open packet
92 */
93 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
94 {
95     memset(s, 0, sizeof(RTPStatistics));
96     s->max_seq= base_sequence;
97     s->probation= 1;
98 }
99
100 /**
101 * called whenever there is a large jump in sequence numbers, or when they get out of probation...
102 */
103 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
104 {
105     s->max_seq= seq;
106     s->cycles= 0;
107     s->base_seq= seq -1;
108     s->bad_seq= RTP_SEQ_MOD + 1;
109     s->received= 0;
110     s->expected_prior= 0;
111     s->received_prior= 0;
112     s->jitter= 0;
113     s->transit= 0;
114 }
115
116 /**
117 * returns 1 if we should handle this packet.
118 */
119 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
120 {
121     uint16_t udelta= seq - s->max_seq;
122     const int MAX_DROPOUT= 3000;
123     const int MAX_MISORDER = 100;
124     const int MIN_SEQUENTIAL = 2;
125
126     /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
127     if(s->probation)
128     {
129         if(seq==s->max_seq + 1) {
130             s->probation--;
131             s->max_seq= seq;
132             if(s->probation==0) {
133                 rtp_init_sequence(s, seq);
134                 s->received++;
135                 return 1;
136             }
137         } else {
138             s->probation= MIN_SEQUENTIAL - 1;
139             s->max_seq = seq;
140         }
141     } else if (udelta < MAX_DROPOUT) {
142         // in order, with permissible gap
143         if(seq < s->max_seq) {
144             //sequence number wrapped; count antother 64k cycles
145             s->cycles += RTP_SEQ_MOD;
146         }
147         s->max_seq= seq;
148     } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
149         // sequence made a large jump...
150         if(seq==s->bad_seq) {
151             // two sequential packets-- assume that the other side restarted without telling us; just resync.
152             rtp_init_sequence(s, seq);
153         } else {
154             s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
155             return 0;
156         }
157     } else {
158         // duplicate or reordered packet...
159     }
160     s->received++;
161     return 1;
162 }
163
164 #if 0
165 /**
166 * This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
167 * difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
168 * never change.  I left this in in case someone else can see a way. (rdm)
169 */
170 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
171 {
172     uint32_t transit= arrival_timestamp - sent_timestamp;
173     int d;
174     s->transit= transit;
175     d= FFABS(transit - s->transit);
176     s->jitter += d - ((s->jitter + 8)>>4);
177 }
178 #endif
179
180 int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
181 {
182     ByteIOContext *pb;
183     uint8_t *buf;
184     int len;
185     int rtcp_bytes;
186     RTPStatistics *stats= &s->statistics;
187     uint32_t lost;
188     uint32_t extended_max;
189     uint32_t expected_interval;
190     uint32_t received_interval;
191     uint32_t lost_interval;
192     uint32_t expected;
193     uint32_t fraction;
194     uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
195
196     if (!s->rtp_ctx || (count < 1))
197         return -1;
198
199     /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
200     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
201     s->octet_count += count;
202     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
203         RTCP_TX_RATIO_DEN;
204     rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
205     if (rtcp_bytes < 28)
206         return -1;
207     s->last_octet_count = s->octet_count;
208
209     if (url_open_dyn_buf(&pb) < 0)
210         return -1;
211
212     // Receiver Report
213     put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
214     put_byte(pb, 201);
215     put_be16(pb, 7); /* length in words - 1 */
216     put_be32(pb, s->ssrc); // our own SSRC
217     put_be32(pb, s->ssrc); // XXX: should be the server's here!
218     // some placeholders we should really fill...
219     // RFC 1889/p64
220     extended_max= stats->cycles + stats->max_seq;
221     expected= extended_max - stats->base_seq + 1;
222     lost= expected - stats->received;
223     lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
224     expected_interval= expected - stats->expected_prior;
225     stats->expected_prior= expected;
226     received_interval= stats->received - stats->received_prior;
227     stats->received_prior= stats->received;
228     lost_interval= expected_interval - received_interval;
229     if (expected_interval==0 || lost_interval<=0) fraction= 0;
230     else fraction = (lost_interval<<8)/expected_interval;
231
232     fraction= (fraction<<24) | lost;
233
234     put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
235     put_be32(pb, extended_max); /* max sequence received */
236     put_be32(pb, stats->jitter>>4); /* jitter */
237
238     if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
239     {
240         put_be32(pb, 0); /* last SR timestamp */
241         put_be32(pb, 0); /* delay since last SR */
242     } else {
243         uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
244         uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
245
246         put_be32(pb, middle_32_bits); /* last SR timestamp */
247         put_be32(pb, delay_since_last); /* delay since last SR */
248     }
249
250     // CNAME
251     put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
252     put_byte(pb, 202);
253     len = strlen(s->hostname);
254     put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
255     put_be32(pb, s->ssrc);
256     put_byte(pb, 0x01);
257     put_byte(pb, len);
258     put_buffer(pb, s->hostname, len);
259     // padding
260     for (len = (6 + len) % 4; len % 4; len++) {
261         put_byte(pb, 0);
262     }
263
264     put_flush_packet(pb);
265     len = url_close_dyn_buf(pb, &buf);
266     if ((len > 0) && buf) {
267         int result;
268         dprintf(s->ic, "sending %d bytes of RR\n", len);
269         result= url_write(s->rtp_ctx, buf, len);
270         dprintf(s->ic, "result from url_write: %d\n", result);
271         av_free(buf);
272     }
273     return 0;
274 }
275
276 void rtp_send_punch_packets(URLContext* rtp_handle)
277 {
278     ByteIOContext *pb;
279     uint8_t *buf;
280     int len;
281
282     /* Send a small RTP packet */
283     if (url_open_dyn_buf(&pb) < 0)
284         return;
285
286     put_byte(pb, (RTP_VERSION << 6));
287     put_byte(pb, 0); /* Payload type */
288     put_be16(pb, 0); /* Seq */
289     put_be32(pb, 0); /* Timestamp */
290     put_be32(pb, 0); /* SSRC */
291
292     put_flush_packet(pb);
293     len = url_close_dyn_buf(pb, &buf);
294     if ((len > 0) && buf)
295         url_write(rtp_handle, buf, len);
296     av_free(buf);
297
298     /* Send a minimal RTCP RR */
299     if (url_open_dyn_buf(&pb) < 0)
300         return;
301
302     put_byte(pb, (RTP_VERSION << 6));
303     put_byte(pb, 201); /* receiver report */
304     put_be16(pb, 1); /* length in words - 1 */
305     put_be32(pb, 0); /* our own SSRC */
306
307     put_flush_packet(pb);
308     len = url_close_dyn_buf(pb, &buf);
309     if ((len > 0) && buf)
310         url_write(rtp_handle, buf, len);
311     av_free(buf);
312 }
313
314
315 /**
316  * open a new RTP parse context for stream 'st'. 'st' can be NULL for
317  * MPEG2TS streams to indicate that they should be demuxed inside the
318  * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
319  * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
320  */
321 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data)
322 {
323     RTPDemuxContext *s;
324
325     s = av_mallocz(sizeof(RTPDemuxContext));
326     if (!s)
327         return NULL;
328     s->payload_type = payload_type;
329     s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
330     s->ic = s1;
331     s->st = st;
332     s->rtp_payload_data = rtp_payload_data;
333     rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
334     if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
335         s->ts = ff_mpegts_parse_open(s->ic);
336         if (s->ts == NULL) {
337             av_free(s);
338             return NULL;
339         }
340     } else {
341         av_set_pts_info(st, 32, 1, 90000);
342         switch(st->codec->codec_id) {
343         case CODEC_ID_MPEG1VIDEO:
344         case CODEC_ID_MPEG2VIDEO:
345         case CODEC_ID_MP2:
346         case CODEC_ID_MP3:
347         case CODEC_ID_MPEG4:
348         case CODEC_ID_H263:
349         case CODEC_ID_H264:
350             st->need_parsing = AVSTREAM_PARSE_FULL;
351             break;
352         default:
353             if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
354                 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
355             }
356             break;
357         }
358     }
359     // needed to send back RTCP RR in RTSP sessions
360     s->rtp_ctx = rtpc;
361     gethostname(s->hostname, sizeof(s->hostname));
362     return s;
363 }
364
365 void
366 rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
367                                RTPDynamicProtocolHandler *handler)
368 {
369     s->dynamic_protocol_context = ctx;
370     s->parse_packet = handler->parse_packet;
371 }
372
373 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
374 {
375     int au_headers_length, au_header_size, i;
376     GetBitContext getbitcontext;
377     RTPPayloadData *infos;
378
379     infos = s->rtp_payload_data;
380
381     if (infos == NULL)
382         return -1;
383
384     /* decode the first 2 bytes where the AUHeader sections are stored
385        length in bits */
386     au_headers_length = AV_RB16(buf);
387
388     if (au_headers_length > RTP_MAX_PACKET_LENGTH)
389       return -1;
390
391     infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
392
393     /* skip AU headers length section (2 bytes) */
394     buf += 2;
395
396     init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
397
398     /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
399     au_header_size = infos->sizelength + infos->indexlength;
400     if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
401         return -1;
402
403     infos->nb_au_headers = au_headers_length / au_header_size;
404     infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
405
406     /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
407        In my test, the FAAD decoder does not behave correctly when sending each AU one by one
408        but does when sending the whole as one big packet...  */
409     infos->au_headers[0].size = 0;
410     infos->au_headers[0].index = 0;
411     for (i = 0; i < infos->nb_au_headers; ++i) {
412         infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
413         infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
414     }
415
416     infos->nb_au_headers = 1;
417
418     return 0;
419 }
420
421 /**
422  * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
423  */
424 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
425 {
426     if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
427         int64_t addend;
428         int delta_timestamp;
429
430         /* compute pts from timestamp with received ntp_time */
431         delta_timestamp = timestamp - s->last_rtcp_timestamp;
432         /* convert to the PTS timebase */
433         addend = av_rescale(s->last_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
434         pkt->pts = addend + delta_timestamp;
435     }
436 }
437
438 /**
439  * Parse an RTP or RTCP packet directly sent as a buffer.
440  * @param s RTP parse context.
441  * @param pkt returned packet
442  * @param buf input buffer or NULL to read the next packets
443  * @param len buffer len
444  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
445  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
446  */
447 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
448                      const uint8_t *buf, int len)
449 {
450     unsigned int ssrc, h;
451     int payload_type, seq, ret, flags = 0;
452     AVStream *st;
453     uint32_t timestamp;
454     int rv= 0;
455
456     if (!buf) {
457         /* return the next packets, if any */
458         if(s->st && s->parse_packet) {
459             timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
460             rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
461                                 s->st, pkt, &timestamp, NULL, 0, flags);
462             finalize_packet(s, pkt, timestamp);
463             return rv;
464         } else {
465             // TODO: Move to a dynamic packet handler (like above)
466             if (s->read_buf_index >= s->read_buf_size)
467                 return -1;
468             ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
469                                       s->read_buf_size - s->read_buf_index);
470             if (ret < 0)
471                 return -1;
472             s->read_buf_index += ret;
473             if (s->read_buf_index < s->read_buf_size)
474                 return 1;
475             else
476                 return 0;
477         }
478     }
479
480     if (len < 12)
481         return -1;
482
483     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
484         return -1;
485     if (buf[1] >= 200 && buf[1] <= 204) {
486         rtcp_parse_packet(s, buf, len);
487         return -1;
488     }
489     payload_type = buf[1] & 0x7f;
490     if (buf[1] & 0x80)
491         flags |= RTP_FLAG_MARKER;
492     seq  = AV_RB16(buf + 2);
493     timestamp = AV_RB32(buf + 4);
494     ssrc = AV_RB32(buf + 8);
495     /* store the ssrc in the RTPDemuxContext */
496     s->ssrc = ssrc;
497
498     /* NOTE: we can handle only one payload type */
499     if (s->payload_type != payload_type)
500         return -1;
501
502     st = s->st;
503     // only do something with this if all the rtp checks pass...
504     if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
505     {
506         av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
507                payload_type, seq, ((s->seq + 1) & 0xffff));
508         return -1;
509     }
510
511     s->seq = seq;
512     len -= 12;
513     buf += 12;
514
515     if (!st) {
516         /* specific MPEG2TS demux support */
517         ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
518         if (ret < 0)
519             return -1;
520         if (ret < len) {
521             s->read_buf_size = len - ret;
522             memcpy(s->buf, buf + ret, s->read_buf_size);
523             s->read_buf_index = 0;
524             return 1;
525         }
526         return 0;
527     } else if (s->parse_packet) {
528         rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
529                              s->st, pkt, &timestamp, buf, len, flags);
530     } else {
531         // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
532         switch(st->codec->codec_id) {
533         case CODEC_ID_MP2:
534         case CODEC_ID_MP3:
535             /* better than nothing: skip mpeg audio RTP header */
536             if (len <= 4)
537                 return -1;
538             h = AV_RB32(buf);
539             len -= 4;
540             buf += 4;
541             av_new_packet(pkt, len);
542             memcpy(pkt->data, buf, len);
543             break;
544         case CODEC_ID_MPEG1VIDEO:
545         case CODEC_ID_MPEG2VIDEO:
546             /* better than nothing: skip mpeg video RTP header */
547             if (len <= 4)
548                 return -1;
549             h = AV_RB32(buf);
550             buf += 4;
551             len -= 4;
552             if (h & (1 << 26)) {
553                 /* mpeg2 */
554                 if (len <= 4)
555                     return -1;
556                 buf += 4;
557                 len -= 4;
558             }
559             av_new_packet(pkt, len);
560             memcpy(pkt->data, buf, len);
561             break;
562             // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
563             // timestamps.
564             // TODO: Put this into a dynamic packet handler...
565         case CODEC_ID_AAC:
566             if (rtp_parse_mp4_au(s, buf))
567                 return -1;
568             {
569                 RTPPayloadData *infos = s->rtp_payload_data;
570                 if (infos == NULL)
571                     return -1;
572                 buf += infos->au_headers_length_bytes + 2;
573                 len -= infos->au_headers_length_bytes + 2;
574
575                 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
576                     one au_header */
577                 av_new_packet(pkt, infos->au_headers[0].size);
578                 memcpy(pkt->data, buf, infos->au_headers[0].size);
579                 buf += infos->au_headers[0].size;
580                 len -= infos->au_headers[0].size;
581             }
582             s->read_buf_size = len;
583             rv= 0;
584             break;
585         default:
586             av_new_packet(pkt, len);
587             memcpy(pkt->data, buf, len);
588             break;
589         }
590
591         pkt->stream_index = st->index;
592     }
593
594     // now perform timestamp things....
595     finalize_packet(s, pkt, timestamp);
596
597     return rv;
598 }
599
600 void rtp_parse_close(RTPDemuxContext *s)
601 {
602     // TODO: fold this into the protocol specific data fields.
603     if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
604         ff_mpegts_parse_close(s->ts);
605     }
606     av_free(s);
607 }