3 * Copyright (c) 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
22 /* needed for gethostname() */
23 #define _XOPEN_SOURCE 600
25 #include "libavcodec/get_bits.h"
35 #include "rtp_vorbis.h"
36 #include "rtpdec_amr.h"
37 #include "rtpdec_h263.h"
41 /* TODO: - add RTCP statistics reporting (should be optional).
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')
50 /* statistics functions */
51 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
53 static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
54 static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
56 void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
58 handler->next= RTPFirstDynamicPayloadHandler;
59 RTPFirstDynamicPayloadHandler= handler;
62 void av_register_rtp_dynamic_payload_handlers(void)
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);
73 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
74 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
77 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
81 s->last_rtcp_ntp_time = AV_RB64(buf + 8);
82 s->last_rtcp_timestamp = AV_RB32(buf + 16);
86 #define RTP_SEQ_MOD (1<<16)
89 * called on parse open packet
91 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
93 memset(s, 0, sizeof(RTPStatistics));
94 s->max_seq= base_sequence;
99 * called whenever there is a large jump in sequence numbers, or when they get out of probation...
101 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
106 s->bad_seq= RTP_SEQ_MOD + 1;
108 s->expected_prior= 0;
109 s->received_prior= 0;
115 * returns 1 if we should handle this packet.
117 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
119 uint16_t udelta= seq - s->max_seq;
120 const int MAX_DROPOUT= 3000;
121 const int MAX_MISORDER = 100;
122 const int MIN_SEQUENTIAL = 2;
124 /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
127 if(seq==s->max_seq + 1) {
130 if(s->probation==0) {
131 rtp_init_sequence(s, seq);
136 s->probation= MIN_SEQUENTIAL - 1;
139 } else if (udelta < MAX_DROPOUT) {
140 // in order, with permissible gap
141 if(seq < s->max_seq) {
142 //sequence number wrapped; count antother 64k cycles
143 s->cycles += RTP_SEQ_MOD;
146 } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
147 // sequence made a large jump...
148 if(seq==s->bad_seq) {
149 // two sequential packets-- assume that the other side restarted without telling us; just resync.
150 rtp_init_sequence(s, seq);
152 s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
156 // duplicate or reordered packet...
164 * This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
165 * difference between the arrival and sent timestamp. As a result, the jitter and transit statistics values
166 * never change. I left this in in case someone else can see a way. (rdm)
168 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
170 uint32_t transit= arrival_timestamp - sent_timestamp;
173 d= FFABS(transit - s->transit);
174 s->jitter += d - ((s->jitter + 8)>>4);
178 int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
184 RTPStatistics *stats= &s->statistics;
186 uint32_t extended_max;
187 uint32_t expected_interval;
188 uint32_t received_interval;
189 uint32_t lost_interval;
192 uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
194 if (!s->rtp_ctx || (count < 1))
197 /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
198 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
199 s->octet_count += count;
200 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
202 rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
205 s->last_octet_count = s->octet_count;
207 if (url_open_dyn_buf(&pb) < 0)
211 put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
213 put_be16(pb, 7); /* length in words - 1 */
214 put_be32(pb, s->ssrc); // our own SSRC
215 put_be32(pb, s->ssrc); // XXX: should be the server's here!
216 // some placeholders we should really fill...
218 extended_max= stats->cycles + stats->max_seq;
219 expected= extended_max - stats->base_seq + 1;
220 lost= expected - stats->received;
221 lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
222 expected_interval= expected - stats->expected_prior;
223 stats->expected_prior= expected;
224 received_interval= stats->received - stats->received_prior;
225 stats->received_prior= stats->received;
226 lost_interval= expected_interval - received_interval;
227 if (expected_interval==0 || lost_interval<=0) fraction= 0;
228 else fraction = (lost_interval<<8)/expected_interval;
230 fraction= (fraction<<24) | lost;
232 put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
233 put_be32(pb, extended_max); /* max sequence received */
234 put_be32(pb, stats->jitter>>4); /* jitter */
236 if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
238 put_be32(pb, 0); /* last SR timestamp */
239 put_be32(pb, 0); /* delay since last SR */
241 uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
242 uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
244 put_be32(pb, middle_32_bits); /* last SR timestamp */
245 put_be32(pb, delay_since_last); /* delay since last SR */
249 put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
251 len = strlen(s->hostname);
252 put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
253 put_be32(pb, s->ssrc);
256 put_buffer(pb, s->hostname, len);
258 for (len = (6 + len) % 4; len % 4; len++) {
262 put_flush_packet(pb);
263 len = url_close_dyn_buf(pb, &buf);
264 if ((len > 0) && buf) {
266 dprintf(s->ic, "sending %d bytes of RR\n", len);
267 result= url_write(s->rtp_ctx, buf, len);
268 dprintf(s->ic, "result from url_write: %d\n", result);
274 void rtp_send_punch_packets(URLContext* rtp_handle)
280 /* Send a small RTP packet */
281 if (url_open_dyn_buf(&pb) < 0)
284 put_byte(pb, (RTP_VERSION << 6));
285 put_byte(pb, 0); /* Payload type */
286 put_be16(pb, 0); /* Seq */
287 put_be32(pb, 0); /* Timestamp */
288 put_be32(pb, 0); /* SSRC */
290 put_flush_packet(pb);
291 len = url_close_dyn_buf(pb, &buf);
292 if ((len > 0) && buf)
293 url_write(rtp_handle, buf, len);
296 /* Send a minimal RTCP RR */
297 if (url_open_dyn_buf(&pb) < 0)
300 put_byte(pb, (RTP_VERSION << 6));
301 put_byte(pb, 201); /* receiver report */
302 put_be16(pb, 1); /* length in words - 1 */
303 put_be32(pb, 0); /* our own SSRC */
305 put_flush_packet(pb);
306 len = url_close_dyn_buf(pb, &buf);
307 if ((len > 0) && buf)
308 url_write(rtp_handle, buf, len);
314 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
315 * MPEG2TS streams to indicate that they should be demuxed inside the
316 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
317 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
319 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data)
323 s = av_mallocz(sizeof(RTPDemuxContext));
326 s->payload_type = payload_type;
327 s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
330 s->rtp_payload_data = rtp_payload_data;
331 rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
332 if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
333 s->ts = ff_mpegts_parse_open(s->ic);
339 av_set_pts_info(st, 32, 1, 90000);
340 switch(st->codec->codec_id) {
341 case CODEC_ID_MPEG1VIDEO:
342 case CODEC_ID_MPEG2VIDEO:
348 st->need_parsing = AVSTREAM_PARSE_FULL;
351 if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
352 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
357 // needed to send back RTCP RR in RTSP sessions
359 gethostname(s->hostname, sizeof(s->hostname));
364 rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
365 RTPDynamicProtocolHandler *handler)
367 s->dynamic_protocol_context = ctx;
368 s->parse_packet = handler->parse_packet;
371 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
373 int au_headers_length, au_header_size, i;
374 GetBitContext getbitcontext;
375 RTPPayloadData *infos;
377 infos = s->rtp_payload_data;
382 /* decode the first 2 bytes where the AUHeader sections are stored
384 au_headers_length = AV_RB16(buf);
386 if (au_headers_length > RTP_MAX_PACKET_LENGTH)
389 infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
391 /* skip AU headers length section (2 bytes) */
394 init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
396 /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
397 au_header_size = infos->sizelength + infos->indexlength;
398 if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
401 infos->nb_au_headers = au_headers_length / au_header_size;
402 infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
404 /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
405 In my test, the FAAD decoder does not behave correctly when sending each AU one by one
406 but does when sending the whole as one big packet... */
407 infos->au_headers[0].size = 0;
408 infos->au_headers[0].index = 0;
409 for (i = 0; i < infos->nb_au_headers; ++i) {
410 infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
411 infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
414 infos->nb_au_headers = 1;
420 * This was the second switch in rtp_parse packet. Normalizes time, if required, sets stream_index, etc.
422 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
424 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
428 /* compute pts from timestamp with received ntp_time */
429 delta_timestamp = timestamp - s->last_rtcp_timestamp;
430 /* convert to the PTS timebase */
431 addend = av_rescale(s->last_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
432 pkt->pts = addend + delta_timestamp;
437 * Parse an RTP or RTCP packet directly sent as a buffer.
438 * @param s RTP parse context.
439 * @param pkt returned packet
440 * @param buf input buffer or NULL to read the next packets
441 * @param len buffer len
442 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
443 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
445 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
446 const uint8_t *buf, int len)
448 unsigned int ssrc, h;
449 int payload_type, seq, ret, flags = 0;
455 /* return the next packets, if any */
456 if(s->st && s->parse_packet) {
457 timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
458 rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
459 s->st, pkt, ×tamp, NULL, 0, flags);
460 finalize_packet(s, pkt, timestamp);
463 // TODO: Move to a dynamic packet handler (like above)
464 if (s->read_buf_index >= s->read_buf_size)
466 ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
467 s->read_buf_size - s->read_buf_index);
470 s->read_buf_index += ret;
471 if (s->read_buf_index < s->read_buf_size)
481 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
483 if (buf[1] >= 200 && buf[1] <= 204) {
484 rtcp_parse_packet(s, buf, len);
487 payload_type = buf[1] & 0x7f;
489 flags |= RTP_FLAG_MARKER;
490 seq = AV_RB16(buf + 2);
491 timestamp = AV_RB32(buf + 4);
492 ssrc = AV_RB32(buf + 8);
493 /* store the ssrc in the RTPDemuxContext */
496 /* NOTE: we can handle only one payload type */
497 if (s->payload_type != payload_type)
501 // only do something with this if all the rtp checks pass...
502 if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
504 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
505 payload_type, seq, ((s->seq + 1) & 0xffff));
514 /* specific MPEG2TS demux support */
515 ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
519 s->read_buf_size = len - ret;
520 memcpy(s->buf, buf + ret, s->read_buf_size);
521 s->read_buf_index = 0;
525 } else if (s->parse_packet) {
526 rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
527 s->st, pkt, ×tamp, buf, len, flags);
529 // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise.
530 switch(st->codec->codec_id) {
533 /* better than nothing: skip mpeg audio RTP header */
539 av_new_packet(pkt, len);
540 memcpy(pkt->data, buf, len);
542 case CODEC_ID_MPEG1VIDEO:
543 case CODEC_ID_MPEG2VIDEO:
544 /* better than nothing: skip mpeg video RTP header */
557 av_new_packet(pkt, len);
558 memcpy(pkt->data, buf, len);
560 // moved from below, verbatim. this is because this section handles packets, and the lower switch handles
562 // TODO: Put this into a dynamic packet handler...
564 if (rtp_parse_mp4_au(s, buf))
567 RTPPayloadData *infos = s->rtp_payload_data;
570 buf += infos->au_headers_length_bytes + 2;
571 len -= infos->au_headers_length_bytes + 2;
573 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
575 av_new_packet(pkt, infos->au_headers[0].size);
576 memcpy(pkt->data, buf, infos->au_headers[0].size);
577 buf += infos->au_headers[0].size;
578 len -= infos->au_headers[0].size;
580 s->read_buf_size = len;
584 av_new_packet(pkt, len);
585 memcpy(pkt->data, buf, len);
589 pkt->stream_index = st->index;
592 // now perform timestamp things....
593 finalize_packet(s, pkt, timestamp);
598 void rtp_parse_close(RTPDemuxContext *s)
600 // TODO: fold this into the protocol specific data fields.
601 if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
602 ff_mpegts_parse_close(s->ts);