2 * RTP input/output format
3 * Copyright (c) 2002 Fabrice Bellard.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #include "bitstream.h"
24 #include <sys/types.h>
25 #include <sys/socket.h>
26 #include <netinet/in.h>
28 # include <arpa/inet.h>
30 # include "barpainet.h"
37 /* TODO: - add RTCP statistics reporting (should be optional).
39 - add support for h263/mpeg4 packetized output : IDEA: send a
40 buffer to 'rtp_write_packet' contains all the packets for ONE
41 frame. Each packet should have a four byte header containing
42 the length in big endian format (same trick as
43 'url_open_dyn_packet_buf')
46 /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
47 AVRtpPayloadType_t AVRtpPayloadTypes[]=
49 {0, "PCMU", CODEC_TYPE_AUDIO, CODEC_ID_PCM_MULAW, 8000, 1},
50 {1, "Reserved", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
51 {2, "Reserved", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
52 {3, "GSM", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
53 {4, "G723", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
54 {5, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
55 {6, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 16000, 1},
56 {7, "LPC", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
57 {8, "PCMA", CODEC_TYPE_AUDIO, CODEC_ID_PCM_ALAW, 8000, 1},
58 {9, "G722", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
59 {10, "L16", CODEC_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 2},
60 {11, "L16", CODEC_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 1},
61 {12, "QCELP", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
62 {13, "CN", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
63 {14, "MPA", CODEC_TYPE_AUDIO, CODEC_ID_MP2, 90000, -1},
64 {15, "G728", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
65 {16, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 11025, 1},
66 {17, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 22050, 1},
67 {18, "G729", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
68 {19, "reserved", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
69 {20, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
70 {21, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
71 {22, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
72 {23, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
73 {24, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
74 {25, "CelB", CODEC_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
75 {26, "JPEG", CODEC_TYPE_VIDEO, CODEC_ID_MJPEG, 90000, -1},
76 {27, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
77 {28, "nv", CODEC_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
78 {29, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
79 {30, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
80 {31, "H261", CODEC_TYPE_VIDEO, CODEC_ID_H261, 90000, -1},
81 {32, "MPV", CODEC_TYPE_VIDEO, CODEC_ID_MPEG1VIDEO, 90000, -1},
82 {33, "MP2T", CODEC_TYPE_DATA, CODEC_ID_MPEG2TS, 90000, -1},
83 {34, "H263", CODEC_TYPE_VIDEO, CODEC_ID_H263, 90000, -1},
84 {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
85 {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
86 {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
87 {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
88 {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
89 {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
90 {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
91 {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
92 {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
93 {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
94 {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
95 {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
96 {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
97 {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
98 {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
99 {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
100 {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
101 {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
102 {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
103 {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
104 {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
105 {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
106 {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
107 {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
108 {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
109 {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
110 {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
111 {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
112 {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
113 {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
114 {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
115 {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
116 {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
117 {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
118 {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
119 {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
120 {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
121 {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
122 {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
123 {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
124 {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
125 {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
126 {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
127 {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
128 {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
129 {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
130 {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
131 {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
132 {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
133 {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
134 {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
135 {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
136 {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
137 {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
138 {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
139 {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
140 {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
141 {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
142 {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
143 {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
144 {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
145 {96, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
146 {97, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
147 {98, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
148 {99, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
149 {100, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
150 {101, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
151 {102, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
152 {103, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
153 {104, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
154 {105, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
155 {106, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
156 {107, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
157 {108, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
158 {109, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
159 {110, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
160 {111, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
161 {112, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
162 {113, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
163 {114, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
164 {115, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
165 {116, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
166 {117, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
167 {118, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
168 {119, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
169 {120, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
170 {121, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
171 {122, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
172 {123, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
173 {124, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
174 {125, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
175 {126, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
176 {127, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
177 {-1, "", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
180 AVRtpDynamicPayloadType_t AVRtpDynamicPayloadTypes[]=
182 {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4},
183 {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_MPEG4AAC},
184 {"", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE}
187 struct RTPDemuxContext {
194 uint32_t base_timestamp;
195 uint32_t cur_timestamp;
196 int max_payload_size;
197 MpegTSContext *ts; /* only used for MP2T payloads */
201 /* rtcp sender statistics receive */
202 int64_t last_rtcp_ntp_time;
203 int64_t first_rtcp_ntp_time;
204 uint32_t last_rtcp_timestamp;
205 /* rtcp sender statistics */
206 unsigned int packet_count;
207 unsigned int octet_count;
208 unsigned int last_octet_count;
210 /* buffer for output */
211 uint8_t buf[RTP_MAX_PACKET_LENGTH];
213 /* special infos for au headers parsing */
214 rtp_payload_data_t *rtp_payload_data;
217 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
219 if (AVRtpPayloadTypes[payload_type].codec_id != CODEC_ID_NONE) {
220 codec->codec_type = AVRtpPayloadTypes[payload_type].codec_type;
221 codec->codec_id = AVRtpPayloadTypes[payload_type].codec_type;
222 if (AVRtpPayloadTypes[payload_type].audio_channels > 0)
223 codec->channels = AVRtpPayloadTypes[payload_type].audio_channels;
224 if (AVRtpPayloadTypes[payload_type].clock_rate > 0)
225 codec->sample_rate = AVRtpPayloadTypes[payload_type].clock_rate;
231 /* return < 0 if unknown payload type */
232 int rtp_get_payload_type(AVCodecContext *codec)
236 /* compute the payload type */
237 for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
238 if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
239 if (codec->codec_id == CODEC_ID_PCM_S16BE)
240 if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
242 payload_type = AVRtpPayloadTypes[i].pt;
247 static inline uint32_t decode_be32(const uint8_t *p)
249 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
252 static inline uint64_t decode_be64(const uint8_t *p)
254 return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
257 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
261 s->last_rtcp_ntp_time = decode_be64(buf + 8);
262 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
263 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
264 s->last_rtcp_timestamp = decode_be32(buf + 16);
269 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
270 * MPEG2TS streams to indicate that they should be demuxed inside the
271 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
273 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, rtp_payload_data_t *rtp_payload_data)
277 s = av_mallocz(sizeof(RTPDemuxContext));
280 s->payload_type = payload_type;
281 s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
282 s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
285 s->rtp_payload_data = rtp_payload_data;
286 if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
287 s->ts = mpegts_parse_open(s->ic);
293 switch(st->codec->codec_id) {
294 case CODEC_ID_MPEG1VIDEO:
295 case CODEC_ID_MPEG2VIDEO:
299 st->need_parsing = 1;
308 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
310 int au_headers_length, au_header_size, i;
311 GetBitContext getbitcontext;
312 rtp_payload_data_t *infos;
314 infos = s->rtp_payload_data;
319 /* decode the first 2 bytes where are stored the AUHeader sections
321 au_headers_length = BE_16(buf);
323 if (au_headers_length > RTP_MAX_PACKET_LENGTH)
326 infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
328 /* skip AU headers length section (2 bytes) */
331 init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
333 /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
334 au_header_size = infos->sizelength + infos->indexlength;
335 if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
338 infos->nb_au_headers = au_headers_length / au_header_size;
339 infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
341 /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
342 In my test, the faad decoder doesnt behave correctly when sending each AU one by one
343 but does when sending the whole as one big packet... */
344 infos->au_headers[0].size = 0;
345 infos->au_headers[0].index = 0;
346 for (i = 0; i < infos->nb_au_headers; ++i) {
347 infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
348 infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
351 infos->nb_au_headers = 1;
357 * Parse an RTP or RTCP packet directly sent as a buffer.
358 * @param s RTP parse context.
359 * @param pkt returned packet
360 * @param buf input buffer or NULL to read the next packets
361 * @param len buffer len
362 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
363 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
365 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
366 const uint8_t *buf, int len)
368 unsigned int ssrc, h;
369 int payload_type, seq, delta_timestamp, ret;
374 /* return the next packets, if any */
375 if (s->read_buf_index >= s->read_buf_size)
377 ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
378 s->read_buf_size - s->read_buf_index);
381 s->read_buf_index += ret;
382 if (s->read_buf_index < s->read_buf_size)
391 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
393 if (buf[1] >= 200 && buf[1] <= 204) {
394 rtcp_parse_packet(s, buf, len);
397 payload_type = buf[1] & 0x7f;
398 seq = (buf[2] << 8) | buf[3];
399 timestamp = decode_be32(buf + 4);
400 ssrc = decode_be32(buf + 8);
402 /* NOTE: we can handle only one payload type */
403 if (s->payload_type != payload_type)
405 #if defined(DEBUG) || 1
406 if (seq != ((s->seq + 1) & 0xffff)) {
407 av_log(s->st->codec, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
408 payload_type, seq, ((s->seq + 1) & 0xffff));
417 /* specific MPEG2TS demux support */
418 ret = mpegts_parse_packet(s->ts, pkt, buf, len);
422 s->read_buf_size = len - ret;
423 memcpy(s->buf, buf + ret, s->read_buf_size);
424 s->read_buf_index = 0;
428 switch(st->codec->codec_id) {
430 /* better than nothing: skip mpeg audio RTP header */
433 h = decode_be32(buf);
436 av_new_packet(pkt, len);
437 memcpy(pkt->data, buf, len);
439 case CODEC_ID_MPEG1VIDEO:
440 /* better than nothing: skip mpeg video RTP header */
443 h = decode_be32(buf);
453 av_new_packet(pkt, len);
454 memcpy(pkt->data, buf, len);
457 av_new_packet(pkt, len);
458 memcpy(pkt->data, buf, len);
462 switch(st->codec->codec_id) {
464 case CODEC_ID_MPEG1VIDEO:
465 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
467 /* XXX: is it really necessary to unify the timestamp base ? */
468 /* compute pts from timestamp with received ntp_time */
469 delta_timestamp = timestamp - s->last_rtcp_timestamp;
470 /* convert to 90 kHz without overflow */
471 addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
472 addend = (addend * 5625) >> 14;
473 pkt->pts = addend + delta_timestamp;
477 pkt->pts = timestamp;
479 case CODEC_ID_MPEG4AAC:
480 if (rtp_parse_mp4_au(s, buf))
483 rtp_payload_data_t *infos = s->rtp_payload_data;
486 buf += infos->au_headers_length_bytes + 2;
487 len -= infos->au_headers_length_bytes + 2;
489 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
491 av_new_packet(pkt, infos->au_headers[0].size);
492 memcpy(pkt->data, buf, infos->au_headers[0].size);
493 buf += infos->au_headers[0].size;
494 len -= infos->au_headers[0].size;
496 s->read_buf_size = len;
497 s->buf_ptr = (char *)buf;
498 pkt->stream_index = s->st->index;
501 /* no timestamp info yet */
504 pkt->stream_index = s->st->index;
509 void rtp_parse_close(RTPDemuxContext *s)
511 if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
512 mpegts_parse_close(s->ts);
519 static int rtp_write_header(AVFormatContext *s1)
521 RTPDemuxContext *s = s1->priv_data;
522 int payload_type, max_packet_size, n;
525 if (s1->nb_streams != 1)
529 payload_type = rtp_get_payload_type(st->codec);
530 if (payload_type < 0)
531 payload_type = RTP_PT_PRIVATE; /* private payload type */
532 s->payload_type = payload_type;
534 s->base_timestamp = random();
535 s->timestamp = s->base_timestamp;
539 max_packet_size = url_fget_max_packet_size(&s1->pb);
540 if (max_packet_size <= 12)
542 s->max_payload_size = max_packet_size - 12;
544 switch(st->codec->codec_id) {
547 s->buf_ptr = s->buf + 4;
548 s->cur_timestamp = 0;
550 case CODEC_ID_MPEG1VIDEO:
551 s->cur_timestamp = 0;
553 case CODEC_ID_MPEG2TS:
554 n = s->max_payload_size / TS_PACKET_SIZE;
557 s->max_payload_size = n * TS_PACKET_SIZE;
568 /* send an rtcp sender report packet */
569 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
571 RTPDemuxContext *s = s1->priv_data;
573 printf("RTCP: %02x %Lx %x\n", s->payload_type, ntp_time, s->timestamp);
575 put_byte(&s1->pb, (RTP_VERSION << 6));
576 put_byte(&s1->pb, 200);
577 put_be16(&s1->pb, 6); /* length in words - 1 */
578 put_be32(&s1->pb, s->ssrc);
579 put_be64(&s1->pb, ntp_time);
580 put_be32(&s1->pb, s->timestamp);
581 put_be32(&s1->pb, s->packet_count);
582 put_be32(&s1->pb, s->octet_count);
583 put_flush_packet(&s1->pb);
586 /* send an rtp packet. sequence number is incremented, but the caller
587 must update the timestamp itself */
588 static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
590 RTPDemuxContext *s = s1->priv_data;
593 printf("rtp_send_data size=%d\n", len);
596 /* build the RTP header */
597 put_byte(&s1->pb, (RTP_VERSION << 6));
598 put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
599 put_be16(&s1->pb, s->seq);
600 put_be32(&s1->pb, s->timestamp);
601 put_be32(&s1->pb, s->ssrc);
603 put_buffer(&s1->pb, buf1, len);
604 put_flush_packet(&s1->pb);
607 s->octet_count += len;
611 /* send an integer number of samples and compute time stamp and fill
612 the rtp send buffer before sending. */
613 static void rtp_send_samples(AVFormatContext *s1,
614 const uint8_t *buf1, int size, int sample_size)
616 RTPDemuxContext *s = s1->priv_data;
617 int len, max_packet_size, n;
619 max_packet_size = (s->max_payload_size / sample_size) * sample_size;
620 /* not needed, but who nows */
621 if ((size % sample_size) != 0)
624 len = (max_packet_size - (s->buf_ptr - s->buf));
629 memcpy(s->buf_ptr, buf1, len);
633 n = (s->buf_ptr - s->buf);
634 /* if buffer full, then send it */
635 if (n >= max_packet_size) {
636 rtp_send_data(s1, s->buf, n, 0);
638 /* update timestamp */
639 s->timestamp += n / sample_size;
644 /* NOTE: we suppose that exactly one frame is given as argument here */
646 static void rtp_send_mpegaudio(AVFormatContext *s1,
647 const uint8_t *buf1, int size)
649 RTPDemuxContext *s = s1->priv_data;
650 AVStream *st = s1->streams[0];
651 int len, count, max_packet_size;
653 max_packet_size = s->max_payload_size;
655 /* test if we must flush because not enough space */
656 len = (s->buf_ptr - s->buf);
657 if ((len + size) > max_packet_size) {
659 rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
660 s->buf_ptr = s->buf + 4;
661 /* 90 KHz time stamp */
662 s->timestamp = s->base_timestamp +
663 (s->cur_timestamp * 90000LL) / st->codec->sample_rate;
668 if (size > max_packet_size) {
669 /* big packet: fragment */
672 len = max_packet_size - 4;
675 /* build fragmented packet */
678 s->buf[2] = count >> 8;
680 memcpy(s->buf + 4, buf1, len);
681 rtp_send_data(s1, s->buf, len + 4, 0);
687 if (s->buf_ptr == s->buf + 4) {
688 /* no fragmentation possible */
694 memcpy(s->buf_ptr, buf1, size);
697 s->cur_timestamp += st->codec->frame_size;
700 /* NOTE: a single frame must be passed with sequence header if
701 needed. XXX: use slices. */
702 static void rtp_send_mpegvideo(AVFormatContext *s1,
703 const uint8_t *buf1, int size)
705 RTPDemuxContext *s = s1->priv_data;
706 AVStream *st = s1->streams[0];
707 int len, h, max_packet_size;
710 max_packet_size = s->max_payload_size;
713 /* XXX: more correct headers */
715 if (st->codec->sub_id == 2)
716 h |= 1 << 26; /* mpeg 2 indicator */
723 if (st->codec->sub_id == 2) {
731 len = max_packet_size - (q - s->buf);
735 memcpy(q, buf1, len);
738 /* 90 KHz time stamp */
739 s->timestamp = s->base_timestamp +
740 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
741 rtp_send_data(s1, s->buf, q - s->buf, (len == size));
749 static void rtp_send_raw(AVFormatContext *s1,
750 const uint8_t *buf1, int size)
752 RTPDemuxContext *s = s1->priv_data;
753 AVStream *st = s1->streams[0];
754 int len, max_packet_size;
756 max_packet_size = s->max_payload_size;
759 len = max_packet_size;
763 /* 90 KHz time stamp */
764 s->timestamp = s->base_timestamp +
765 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
766 rtp_send_data(s1, buf1, len, (len == size));
774 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
775 static void rtp_send_mpegts_raw(AVFormatContext *s1,
776 const uint8_t *buf1, int size)
778 RTPDemuxContext *s = s1->priv_data;
781 while (size >= TS_PACKET_SIZE) {
782 len = s->max_payload_size - (s->buf_ptr - s->buf);
785 memcpy(s->buf_ptr, buf1, len);
790 out_len = s->buf_ptr - s->buf;
791 if (out_len >= s->max_payload_size) {
792 rtp_send_data(s1, s->buf, out_len, 0);
798 /* write an RTP packet. 'buf1' must contain a single specific frame. */
799 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
801 RTPDemuxContext *s = s1->priv_data;
802 AVStream *st = s1->streams[0];
806 uint8_t *buf1= pkt->data;
809 printf("%d: write len=%d\n", pkt->stream_index, size);
812 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
813 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
815 if (s->first_packet || rtcp_bytes >= 28) {
816 /* compute NTP time */
817 /* XXX: 90 kHz timestamp hardcoded */
818 ntp_time = (pkt->pts << 28) / 5625;
819 rtcp_send_sr(s1, ntp_time);
820 s->last_octet_count = s->octet_count;
824 switch(st->codec->codec_id) {
825 case CODEC_ID_PCM_MULAW:
826 case CODEC_ID_PCM_ALAW:
827 case CODEC_ID_PCM_U8:
828 case CODEC_ID_PCM_S8:
829 rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
831 case CODEC_ID_PCM_U16BE:
832 case CODEC_ID_PCM_U16LE:
833 case CODEC_ID_PCM_S16BE:
834 case CODEC_ID_PCM_S16LE:
835 rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
839 rtp_send_mpegaudio(s1, buf1, size);
841 case CODEC_ID_MPEG1VIDEO:
842 rtp_send_mpegvideo(s1, buf1, size);
844 case CODEC_ID_MPEG2TS:
845 rtp_send_mpegts_raw(s1, buf1, size);
848 /* better than nothing : send the codec raw data */
849 rtp_send_raw(s1, buf1, size);
855 static int rtp_write_trailer(AVFormatContext *s1)
857 // RTPDemuxContext *s = s1->priv_data;
861 AVOutputFormat rtp_mux = {
866 sizeof(RTPDemuxContext),
876 av_register_output_format(&rtp_mux);