2 * RTP input/output format
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
23 #include "bitstream.h"
28 #include "rtp_internal.h"
34 /* TODO: - add RTCP statistics reporting (should be optional).
36 - add support for h263/mpeg4 packetized output : IDEA: send a
37 buffer to 'rtp_write_packet' contains all the packets for ONE
38 frame. Each packet should have a four byte header containing
39 the length in big endian format (same trick as
40 'url_open_dyn_packet_buf')
43 /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
44 AVRtpPayloadType_t AVRtpPayloadTypes[]=
46 {0, "PCMU", CODEC_TYPE_AUDIO, CODEC_ID_PCM_MULAW, 8000, 1},
47 {1, "Reserved", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
48 {2, "Reserved", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
49 {3, "GSM", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
50 {4, "G723", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
51 {5, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
52 {6, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 16000, 1},
53 {7, "LPC", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
54 {8, "PCMA", CODEC_TYPE_AUDIO, CODEC_ID_PCM_ALAW, 8000, 1},
55 {9, "G722", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
56 {10, "L16", CODEC_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 2},
57 {11, "L16", CODEC_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 1},
58 {12, "QCELP", CODEC_TYPE_AUDIO, CODEC_ID_QCELP, 8000, 1},
59 {13, "CN", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
60 {14, "MPA", CODEC_TYPE_AUDIO, CODEC_ID_MP2, 90000, -1},
61 {15, "G728", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
62 {16, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 11025, 1},
63 {17, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 22050, 1},
64 {18, "G729", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
65 {19, "reserved", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
66 {20, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
67 {21, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
68 {22, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
69 {23, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
70 {24, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
71 {25, "CelB", CODEC_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
72 {26, "JPEG", CODEC_TYPE_VIDEO, CODEC_ID_MJPEG, 90000, -1},
73 {27, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
74 {28, "nv", CODEC_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
75 {29, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
76 {30, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
77 {31, "H261", CODEC_TYPE_VIDEO, CODEC_ID_H261, 90000, -1},
78 {32, "MPV", CODEC_TYPE_VIDEO, CODEC_ID_MPEG1VIDEO, 90000, -1},
79 {33, "MP2T", CODEC_TYPE_DATA, CODEC_ID_MPEG2TS, 90000, -1},
80 {34, "H263", CODEC_TYPE_VIDEO, CODEC_ID_H263, 90000, -1},
81 {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
82 {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
83 {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
84 {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
85 {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
86 {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
87 {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
88 {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
89 {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
90 {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
91 {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
92 {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
93 {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
94 {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
95 {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
96 {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
97 {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
98 {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
99 {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
100 {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
101 {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
102 {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
103 {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
104 {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
105 {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
106 {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
107 {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
108 {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
109 {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
110 {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
111 {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
112 {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
113 {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
114 {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
115 {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
116 {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
117 {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
118 {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
119 {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
120 {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
121 {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
122 {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
123 {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
124 {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
125 {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
126 {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
127 {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
128 {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
129 {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
130 {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
131 {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
132 {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
133 {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
134 {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
135 {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
136 {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
137 {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
138 {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
139 {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
140 {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
141 {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
142 {96, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
143 {97, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
144 {98, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
145 {99, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
146 {100, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
147 {101, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
148 {102, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
149 {103, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
150 {104, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
151 {105, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
152 {106, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
153 {107, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
154 {108, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
155 {109, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
156 {110, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
157 {111, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
158 {112, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
159 {113, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
160 {114, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
161 {115, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
162 {116, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
163 {117, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
164 {118, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
165 {119, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
166 {120, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
167 {121, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
168 {122, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
169 {123, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
170 {124, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
171 {125, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
172 {126, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
173 {127, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
174 {-1, "", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
177 /* statistics functions */
178 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
180 static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
181 static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
183 static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
185 handler->next= RTPFirstDynamicPayloadHandler;
186 RTPFirstDynamicPayloadHandler= handler;
189 void av_register_rtp_dynamic_payload_handlers(void)
191 register_dynamic_payload_handler(&mp4v_es_handler);
192 register_dynamic_payload_handler(&mpeg4_generic_handler);
193 register_dynamic_payload_handler(&ff_h264_dynamic_handler);
196 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
198 if (AVRtpPayloadTypes[payload_type].codec_id != CODEC_ID_NONE) {
199 codec->codec_type = AVRtpPayloadTypes[payload_type].codec_type;
200 codec->codec_id = AVRtpPayloadTypes[payload_type].codec_id;
201 if (AVRtpPayloadTypes[payload_type].audio_channels > 0)
202 codec->channels = AVRtpPayloadTypes[payload_type].audio_channels;
203 if (AVRtpPayloadTypes[payload_type].clock_rate > 0)
204 codec->sample_rate = AVRtpPayloadTypes[payload_type].clock_rate;
210 int rtp_get_payload_type(AVCodecContext *codec)
214 /* compute the payload type */
215 for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
216 if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
217 if (codec->codec_id == CODEC_ID_PCM_S16BE)
218 if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
220 payload_type = AVRtpPayloadTypes[i].pt;
225 static inline uint32_t decode_be32(const uint8_t *p)
227 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
230 static inline uint64_t decode_be64(const uint8_t *p)
232 return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
235 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
239 s->last_rtcp_ntp_time = decode_be64(buf + 8);
240 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
241 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
242 s->last_rtcp_timestamp = decode_be32(buf + 16);
246 #define RTP_SEQ_MOD (1<<16)
249 * called on parse open packet
251 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
253 memset(s, 0, sizeof(RTPStatistics));
254 s->max_seq= base_sequence;
259 * called whenever there is a large jump in sequence numbers, or when they get out of probation...
261 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
266 s->bad_seq= RTP_SEQ_MOD + 1;
268 s->expected_prior= 0;
269 s->received_prior= 0;
275 * returns 1 if we should handle this packet.
277 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
279 uint16_t udelta= seq - s->max_seq;
280 const int MAX_DROPOUT= 3000;
281 const int MAX_MISORDER = 100;
282 const int MIN_SEQUENTIAL = 2;
284 /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
287 if(seq==s->max_seq + 1) {
290 if(s->probation==0) {
291 rtp_init_sequence(s, seq);
296 s->probation= MIN_SEQUENTIAL - 1;
299 } else if (udelta < MAX_DROPOUT) {
300 // in order, with permissible gap
301 if(seq < s->max_seq) {
302 //sequence number wrapped; count antother 64k cycles
303 s->cycles += RTP_SEQ_MOD;
306 } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
307 // sequence made a large jump...
308 if(seq==s->bad_seq) {
309 // two sequential packets-- assume that the other side restarted without telling us; just resync.
310 rtp_init_sequence(s, seq);
312 s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
316 // duplicate or reordered packet...
324 * This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
325 * difference between the arrival and sent timestamp. As a result, the jitter and transit statistics values
326 * never change. I left this in in case someone else can see a way. (rdm)
328 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
330 uint32_t transit= arrival_timestamp - sent_timestamp;
333 d= FFABS(transit - s->transit);
334 s->jitter += d - ((s->jitter + 8)>>4);
338 int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
344 RTPStatistics *stats= &s->statistics;
346 uint32_t extended_max;
347 uint32_t expected_interval;
348 uint32_t received_interval;
349 uint32_t lost_interval;
352 uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
354 if (!s->rtp_ctx || (count < 1))
357 /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
358 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
359 s->octet_count += count;
360 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
362 rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
365 s->last_octet_count = s->octet_count;
367 if (url_open_dyn_buf(&pb) < 0)
371 put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
373 put_be16(&pb, 7); /* length in words - 1 */
374 put_be32(&pb, s->ssrc); // our own SSRC
375 put_be32(&pb, s->ssrc); // XXX: should be the server's here!
376 // some placeholders we should really fill...
378 extended_max= stats->cycles + stats->max_seq;
379 expected= extended_max - stats->base_seq + 1;
380 lost= expected - stats->received;
381 lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
382 expected_interval= expected - stats->expected_prior;
383 stats->expected_prior= expected;
384 received_interval= stats->received - stats->received_prior;
385 stats->received_prior= stats->received;
386 lost_interval= expected_interval - received_interval;
387 if (expected_interval==0 || lost_interval<=0) fraction= 0;
388 else fraction = (lost_interval<<8)/expected_interval;
390 fraction= (fraction<<24) | lost;
392 put_be32(&pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
393 put_be32(&pb, extended_max); /* max sequence received */
394 put_be32(&pb, stats->jitter>>4); /* jitter */
396 if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
398 put_be32(&pb, 0); /* last SR timestamp */
399 put_be32(&pb, 0); /* delay since last SR */
401 uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
402 uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
404 put_be32(&pb, middle_32_bits); /* last SR timestamp */
405 put_be32(&pb, delay_since_last); /* delay since last SR */
409 put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
411 len = strlen(s->hostname);
412 put_be16(&pb, (6 + len + 3) / 4); /* length in words - 1 */
413 put_be32(&pb, s->ssrc);
416 put_buffer(&pb, s->hostname, len);
418 for (len = (6 + len) % 4; len % 4; len++) {
422 put_flush_packet(&pb);
423 len = url_close_dyn_buf(&pb, &buf);
424 if ((len > 0) && buf) {
427 printf("sending %d bytes of RR\n", len);
429 result= url_write(s->rtp_ctx, buf, len);
431 printf("result from url_write: %d\n", result);
439 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
440 * MPEG2TS streams to indicate that they should be demuxed inside the
441 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
442 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
444 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
448 s = av_mallocz(sizeof(RTPDemuxContext));
451 s->payload_type = payload_type;
452 s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
453 s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
456 s->rtp_payload_data = rtp_payload_data;
457 rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
458 if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
459 s->ts = mpegts_parse_open(s->ic);
465 switch(st->codec->codec_id) {
466 case CODEC_ID_MPEG1VIDEO:
467 case CODEC_ID_MPEG2VIDEO:
472 st->need_parsing = 1;
478 // needed to send back RTCP RR in RTSP sessions
480 gethostname(s->hostname, sizeof(s->hostname));
484 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
486 int au_headers_length, au_header_size, i;
487 GetBitContext getbitcontext;
488 rtp_payload_data_t *infos;
490 infos = s->rtp_payload_data;
495 /* decode the first 2 bytes where are stored the AUHeader sections
497 au_headers_length = AV_RB16(buf);
499 if (au_headers_length > RTP_MAX_PACKET_LENGTH)
502 infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
504 /* skip AU headers length section (2 bytes) */
507 init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
509 /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
510 au_header_size = infos->sizelength + infos->indexlength;
511 if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
514 infos->nb_au_headers = au_headers_length / au_header_size;
515 infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
517 /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
518 In my test, the faad decoder doesnt behave correctly when sending each AU one by one
519 but does when sending the whole as one big packet... */
520 infos->au_headers[0].size = 0;
521 infos->au_headers[0].index = 0;
522 for (i = 0; i < infos->nb_au_headers; ++i) {
523 infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
524 infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
527 infos->nb_au_headers = 1;
533 * This was the second switch in rtp_parse packet. Normalizes time, if required, sets stream_index, etc.
535 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
537 switch(s->st->codec->codec_id) {
539 case CODEC_ID_MPEG1VIDEO:
540 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
544 /* XXX: is it really necessary to unify the timestamp base ? */
545 /* compute pts from timestamp with received ntp_time */
546 delta_timestamp = timestamp - s->last_rtcp_timestamp;
547 /* convert to 90 kHz without overflow */
548 addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
549 addend = (addend * 5625) >> 14;
550 pkt->pts = addend + delta_timestamp;
556 pkt->pts = timestamp;
559 /* no timestamp info yet */
562 pkt->stream_index = s->st->index;
566 * Parse an RTP or RTCP packet directly sent as a buffer.
567 * @param s RTP parse context.
568 * @param pkt returned packet
569 * @param buf input buffer or NULL to read the next packets
570 * @param len buffer len
571 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
572 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
574 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
575 const uint8_t *buf, int len)
577 unsigned int ssrc, h;
578 int payload_type, seq, ret;
584 /* return the next packets, if any */
585 if(s->st && s->parse_packet) {
586 timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
587 rv= s->parse_packet(s, pkt, ×tamp, NULL, 0);
588 finalize_packet(s, pkt, timestamp);
591 // TODO: Move to a dynamic packet handler (like above)
592 if (s->read_buf_index >= s->read_buf_size)
594 ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
595 s->read_buf_size - s->read_buf_index);
598 s->read_buf_index += ret;
599 if (s->read_buf_index < s->read_buf_size)
609 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
611 if (buf[1] >= 200 && buf[1] <= 204) {
612 rtcp_parse_packet(s, buf, len);
615 payload_type = buf[1] & 0x7f;
616 seq = (buf[2] << 8) | buf[3];
617 timestamp = decode_be32(buf + 4);
618 ssrc = decode_be32(buf + 8);
619 /* store the ssrc in the RTPDemuxContext */
622 /* NOTE: we can handle only one payload type */
623 if (s->payload_type != payload_type)
627 // only do something with this if all the rtp checks pass...
628 if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
630 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
631 payload_type, seq, ((s->seq + 1) & 0xffff));
640 /* specific MPEG2TS demux support */
641 ret = mpegts_parse_packet(s->ts, pkt, buf, len);
645 s->read_buf_size = len - ret;
646 memcpy(s->buf, buf + ret, s->read_buf_size);
647 s->read_buf_index = 0;
651 // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise.
652 switch(st->codec->codec_id) {
654 /* better than nothing: skip mpeg audio RTP header */
657 h = decode_be32(buf);
660 av_new_packet(pkt, len);
661 memcpy(pkt->data, buf, len);
663 case CODEC_ID_MPEG1VIDEO:
664 /* better than nothing: skip mpeg video RTP header */
667 h = decode_be32(buf);
677 av_new_packet(pkt, len);
678 memcpy(pkt->data, buf, len);
680 // moved from below, verbatim. this is because this section handles packets, and the lower switch handles
682 // TODO: Put this into a dynamic packet handler...
684 if (rtp_parse_mp4_au(s, buf))
687 rtp_payload_data_t *infos = s->rtp_payload_data;
690 buf += infos->au_headers_length_bytes + 2;
691 len -= infos->au_headers_length_bytes + 2;
693 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
695 av_new_packet(pkt, infos->au_headers[0].size);
696 memcpy(pkt->data, buf, infos->au_headers[0].size);
697 buf += infos->au_headers[0].size;
698 len -= infos->au_headers[0].size;
700 s->read_buf_size = len;
705 if(s->parse_packet) {
706 rv= s->parse_packet(s, pkt, ×tamp, buf, len);
708 av_new_packet(pkt, len);
709 memcpy(pkt->data, buf, len);
714 // now perform timestamp things....
715 finalize_packet(s, pkt, timestamp);
720 void rtp_parse_close(RTPDemuxContext *s)
722 // TODO: fold this into the protocol specific data fields.
723 if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
724 mpegts_parse_close(s->ts);
731 static int rtp_write_header(AVFormatContext *s1)
733 RTPDemuxContext *s = s1->priv_data;
734 int payload_type, max_packet_size, n;
737 if (s1->nb_streams != 1)
741 payload_type = rtp_get_payload_type(st->codec);
742 if (payload_type < 0)
743 payload_type = RTP_PT_PRIVATE; /* private payload type */
744 s->payload_type = payload_type;
746 // following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
747 s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
748 s->timestamp = s->base_timestamp;
749 s->ssrc = 0; /* FIXME: was random(), what should this be? */
752 max_packet_size = url_fget_max_packet_size(&s1->pb);
753 if (max_packet_size <= 12)
755 s->max_payload_size = max_packet_size - 12;
757 switch(st->codec->codec_id) {
760 s->buf_ptr = s->buf + 4;
761 s->cur_timestamp = 0;
763 case CODEC_ID_MPEG1VIDEO:
764 s->cur_timestamp = 0;
766 case CODEC_ID_MPEG2TS:
767 n = s->max_payload_size / TS_PACKET_SIZE;
770 s->max_payload_size = n * TS_PACKET_SIZE;
781 /* send an rtcp sender report packet */
782 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
784 RTPDemuxContext *s = s1->priv_data;
786 printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
788 put_byte(&s1->pb, (RTP_VERSION << 6));
789 put_byte(&s1->pb, 200);
790 put_be16(&s1->pb, 6); /* length in words - 1 */
791 put_be32(&s1->pb, s->ssrc);
792 put_be64(&s1->pb, ntp_time);
793 put_be32(&s1->pb, s->timestamp);
794 put_be32(&s1->pb, s->packet_count);
795 put_be32(&s1->pb, s->octet_count);
796 put_flush_packet(&s1->pb);
799 /* send an rtp packet. sequence number is incremented, but the caller
800 must update the timestamp itself */
801 static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
803 RTPDemuxContext *s = s1->priv_data;
806 printf("rtp_send_data size=%d\n", len);
809 /* build the RTP header */
810 put_byte(&s1->pb, (RTP_VERSION << 6));
811 put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
812 put_be16(&s1->pb, s->seq);
813 put_be32(&s1->pb, s->timestamp);
814 put_be32(&s1->pb, s->ssrc);
816 put_buffer(&s1->pb, buf1, len);
817 put_flush_packet(&s1->pb);
820 s->octet_count += len;
824 /* send an integer number of samples and compute time stamp and fill
825 the rtp send buffer before sending. */
826 static void rtp_send_samples(AVFormatContext *s1,
827 const uint8_t *buf1, int size, int sample_size)
829 RTPDemuxContext *s = s1->priv_data;
830 int len, max_packet_size, n;
832 max_packet_size = (s->max_payload_size / sample_size) * sample_size;
833 /* not needed, but who nows */
834 if ((size % sample_size) != 0)
837 len = (max_packet_size - (s->buf_ptr - s->buf));
842 memcpy(s->buf_ptr, buf1, len);
846 n = (s->buf_ptr - s->buf);
847 /* if buffer full, then send it */
848 if (n >= max_packet_size) {
849 rtp_send_data(s1, s->buf, n, 0);
851 /* update timestamp */
852 s->timestamp += n / sample_size;
857 /* NOTE: we suppose that exactly one frame is given as argument here */
859 static void rtp_send_mpegaudio(AVFormatContext *s1,
860 const uint8_t *buf1, int size)
862 RTPDemuxContext *s = s1->priv_data;
863 AVStream *st = s1->streams[0];
864 int len, count, max_packet_size;
866 max_packet_size = s->max_payload_size;
868 /* test if we must flush because not enough space */
869 len = (s->buf_ptr - s->buf);
870 if ((len + size) > max_packet_size) {
872 rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
873 s->buf_ptr = s->buf + 4;
874 /* 90 KHz time stamp */
875 s->timestamp = s->base_timestamp +
876 (s->cur_timestamp * 90000LL) / st->codec->sample_rate;
881 if (size > max_packet_size) {
882 /* big packet: fragment */
885 len = max_packet_size - 4;
888 /* build fragmented packet */
891 s->buf[2] = count >> 8;
893 memcpy(s->buf + 4, buf1, len);
894 rtp_send_data(s1, s->buf, len + 4, 0);
900 if (s->buf_ptr == s->buf + 4) {
901 /* no fragmentation possible */
907 memcpy(s->buf_ptr, buf1, size);
910 s->cur_timestamp += st->codec->frame_size;
913 /* NOTE: a single frame must be passed with sequence header if
914 needed. XXX: use slices. */
915 static void rtp_send_mpegvideo(AVFormatContext *s1,
916 const uint8_t *buf1, int size)
918 RTPDemuxContext *s = s1->priv_data;
919 AVStream *st = s1->streams[0];
920 int len, h, max_packet_size;
923 max_packet_size = s->max_payload_size;
926 /* XXX: more correct headers */
928 if (st->codec->sub_id == 2)
929 h |= 1 << 26; /* mpeg 2 indicator */
936 if (st->codec->sub_id == 2) {
944 len = max_packet_size - (q - s->buf);
948 memcpy(q, buf1, len);
951 /* 90 KHz time stamp */
952 s->timestamp = s->base_timestamp +
953 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
954 rtp_send_data(s1, s->buf, q - s->buf, (len == size));
962 static void rtp_send_raw(AVFormatContext *s1,
963 const uint8_t *buf1, int size)
965 RTPDemuxContext *s = s1->priv_data;
966 AVStream *st = s1->streams[0];
967 int len, max_packet_size;
969 max_packet_size = s->max_payload_size;
972 len = max_packet_size;
976 /* 90 KHz time stamp */
977 s->timestamp = s->base_timestamp +
978 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
979 rtp_send_data(s1, buf1, len, (len == size));
987 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
988 static void rtp_send_mpegts_raw(AVFormatContext *s1,
989 const uint8_t *buf1, int size)
991 RTPDemuxContext *s = s1->priv_data;
994 while (size >= TS_PACKET_SIZE) {
995 len = s->max_payload_size - (s->buf_ptr - s->buf);
998 memcpy(s->buf_ptr, buf1, len);
1003 out_len = s->buf_ptr - s->buf;
1004 if (out_len >= s->max_payload_size) {
1005 rtp_send_data(s1, s->buf, out_len, 0);
1006 s->buf_ptr = s->buf;
1011 /* write an RTP packet. 'buf1' must contain a single specific frame. */
1012 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
1014 RTPDemuxContext *s = s1->priv_data;
1015 AVStream *st = s1->streams[0];
1018 int size= pkt->size;
1019 uint8_t *buf1= pkt->data;
1022 printf("%d: write len=%d\n", pkt->stream_index, size);
1025 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
1026 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
1028 if (s->first_packet || rtcp_bytes >= 28) {
1029 /* compute NTP time */
1030 /* XXX: 90 kHz timestamp hardcoded */
1031 ntp_time = (pkt->pts << 28) / 5625;
1032 rtcp_send_sr(s1, ntp_time);
1033 s->last_octet_count = s->octet_count;
1034 s->first_packet = 0;
1037 switch(st->codec->codec_id) {
1038 case CODEC_ID_PCM_MULAW:
1039 case CODEC_ID_PCM_ALAW:
1040 case CODEC_ID_PCM_U8:
1041 case CODEC_ID_PCM_S8:
1042 rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
1044 case CODEC_ID_PCM_U16BE:
1045 case CODEC_ID_PCM_U16LE:
1046 case CODEC_ID_PCM_S16BE:
1047 case CODEC_ID_PCM_S16LE:
1048 rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
1052 rtp_send_mpegaudio(s1, buf1, size);
1054 case CODEC_ID_MPEG1VIDEO:
1055 rtp_send_mpegvideo(s1, buf1, size);
1057 case CODEC_ID_MPEG2TS:
1058 rtp_send_mpegts_raw(s1, buf1, size);
1061 /* better than nothing : send the codec raw data */
1062 rtp_send_raw(s1, buf1, size);
1068 static int rtp_write_trailer(AVFormatContext *s1)
1070 // RTPDemuxContext *s = s1->priv_data;
1074 AVOutputFormat rtp_muxer = {
1076 "RTP output format",
1079 sizeof(RTPDemuxContext),