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