changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext...
[libav.git] / libavformat / rtp.c
CommitLineData
e309128f
FB
1/*
2 * RTP input/output format
3 * Copyright (c) 2002 Fabrice Bellard.
4 *
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.
9 *
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.
14 *
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19#include "avformat.h"
8b1ab7bf 20#include "mpegts.h"
d1ccf0e0 21#include "bitstream.h"
e309128f
FB
22
23#include <unistd.h>
24#include <sys/types.h>
b8a78f41 25#include <sys/socket.h>
e309128f 26#include <netinet/in.h>
9ddd71fc
FR
27#ifndef __BEOS__
28# include <arpa/inet.h>
29#else
30# include "barpainet.h"
31#endif
e309128f
FB
32#include <netdb.h>
33
34//#define DEBUG
35
36
37/* TODO: - add RTCP statistics reporting (should be optional).
38
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')
44*/
45
d1ccf0e0
RD
46/* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
47AVRtpPayloadType_t AVRtpPayloadTypes[]=
48{
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}
178};
179
180AVRtpDynamicPayloadType_t AVRtpDynamicPayloadTypes[]=
181{
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}
185};
e309128f 186
8b1ab7bf
FB
187struct RTPDemuxContext {
188 AVFormatContext *ic;
189 AVStream *st;
e309128f 190 int payload_type;
0c1a9eda
ZK
191 uint32_t ssrc;
192 uint16_t seq;
193 uint32_t timestamp;
194 uint32_t base_timestamp;
195 uint32_t cur_timestamp;
e309128f 196 int max_payload_size;
d1ccf0e0 197 MpegTSContext *ts; /* only used for MP2T payloads */
8b1ab7bf
FB
198 int read_buf_index;
199 int read_buf_size;
200
e309128f 201 /* rtcp sender statistics receive */
0c1a9eda 202 int64_t last_rtcp_ntp_time;
e5526b2c 203 int64_t first_rtcp_ntp_time;
0c1a9eda 204 uint32_t last_rtcp_timestamp;
e309128f
FB
205 /* rtcp sender statistics */
206 unsigned int packet_count;
207 unsigned int octet_count;
208 unsigned int last_octet_count;
209 int first_packet;
210 /* buffer for output */
0c1a9eda
ZK
211 uint8_t buf[RTP_MAX_PACKET_LENGTH];
212 uint8_t *buf_ptr;
d1ccf0e0
RD
213 /* special infos for au headers parsing */
214 rtp_payload_data_t *rtp_payload_data;
8b1ab7bf 215};
e309128f
FB
216
217int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
218{
d1ccf0e0
RD
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;
226 return 0;
e309128f 227 }
d1ccf0e0 228 return -1;
e309128f
FB
229}
230
231/* return < 0 if unknown payload type */
232int rtp_get_payload_type(AVCodecContext *codec)
233{
d1ccf0e0 234 int i, payload_type;
e309128f
FB
235
236 /* compute the payload type */
d1ccf0e0
RD
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)
241 continue;
242 payload_type = AVRtpPayloadTypes[i].pt;
e309128f 243 }
e309128f
FB
244 return payload_type;
245}
246
0c1a9eda 247static inline uint32_t decode_be32(const uint8_t *p)
e309128f
FB
248{
249 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
250}
251
e5526b2c 252static inline uint64_t decode_be64(const uint8_t *p)
e309128f 253{
0c1a9eda 254 return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
e309128f
FB
255}
256
8b1ab7bf 257static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
e309128f 258{
e309128f
FB
259 if (buf[1] != 200)
260 return -1;
261 s->last_rtcp_ntp_time = decode_be64(buf + 8);
e5526b2c
FB
262 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
263 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
e309128f
FB
264 s->last_rtcp_timestamp = decode_be32(buf + 16);
265 return 0;
266}
267
268/**
8b1ab7bf
FB
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)
272 */
d1ccf0e0 273RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, rtp_payload_data_t *rtp_payload_data)
8b1ab7bf
FB
274{
275 RTPDemuxContext *s;
276
277 s = av_mallocz(sizeof(RTPDemuxContext));
278 if (!s)
279 return NULL;
280 s->payload_type = payload_type;
281 s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
282 s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
283 s->ic = s1;
284 s->st = st;
d1ccf0e0
RD
285 s->rtp_payload_data = rtp_payload_data;
286 if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
8b1ab7bf
FB
287 s->ts = mpegts_parse_open(s->ic);
288 if (s->ts == NULL) {
289 av_free(s);
290 return NULL;
291 }
ccd39ae6 292 } else {
01f4895c 293 switch(st->codec->codec_id) {
ccd39ae6
FB
294 case CODEC_ID_MPEG1VIDEO:
295 case CODEC_ID_MPEG2VIDEO:
296 case CODEC_ID_MP2:
297 case CODEC_ID_MP3:
298 case CODEC_ID_MPEG4:
299 st->need_parsing = 1;
300 break;
301 default:
302 break;
303 }
8b1ab7bf
FB
304 }
305 return s;
306}
307
d1ccf0e0
RD
308static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
309{
d1ccf0e0
RD
310 int au_headers_length, au_header_size, i;
311 GetBitContext getbitcontext;
312 rtp_payload_data_t *infos;
313
314 infos = s->rtp_payload_data;
315
316 if (infos == NULL)
317 return -1;
318
d1ccf0e0
RD
319 /* decode the first 2 bytes where are stored the AUHeader sections
320 length in bits */
321 au_headers_length = BE_16(buf);
322
323 if (au_headers_length > RTP_MAX_PACKET_LENGTH)
324 return -1;
325
326 infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
327
328 /* skip AU headers length section (2 bytes) */
329 buf += 2;
330
331 init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
332
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))
336 return -1;
337
338 infos->nb_au_headers = au_headers_length / au_header_size;
339 infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
340
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);
349 }
350
351 infos->nb_au_headers = 1;
352
353 return 0;
354}
355
8b1ab7bf
FB
356/**
357 * Parse an RTP or RTCP packet directly sent as a buffer.
358 * @param s RTP parse context.
e309128f 359 * @param pkt returned packet
8b1ab7bf 360 * @param buf input buffer or NULL to read the next packets
e309128f 361 * @param len buffer len
8b1ab7bf
FB
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).
e309128f 364 */
8b1ab7bf
FB
365int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
366 const uint8_t *buf, int len)
e309128f 367{
e309128f 368 unsigned int ssrc, h;
8b1ab7bf 369 int payload_type, seq, delta_timestamp, ret;
e309128f 370 AVStream *st;
0c1a9eda 371 uint32_t timestamp;
e309128f 372
8b1ab7bf
FB
373 if (!buf) {
374 /* return the next packets, if any */
375 if (s->read_buf_index >= s->read_buf_size)
376 return -1;
377 ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
378 s->read_buf_size - s->read_buf_index);
379 if (ret < 0)
380 return -1;
381 s->read_buf_index += ret;
382 if (s->read_buf_index < s->read_buf_size)
383 return 1;
384 else
385 return 0;
386 }
387
e309128f
FB
388 if (len < 12)
389 return -1;
390
391 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
392 return -1;
393 if (buf[1] >= 200 && buf[1] <= 204) {
8b1ab7bf 394 rtcp_parse_packet(s, buf, len);
e309128f
FB
395 return -1;
396 }
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);
401
e309128f
FB
402 /* NOTE: we can handle only one payload type */
403 if (s->payload_type != payload_type)
404 return -1;
405#if defined(DEBUG) || 1
406 if (seq != ((s->seq + 1) & 0xffff)) {
01f4895c 407 av_log(s->st->codec, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
e309128f
FB
408 payload_type, seq, ((s->seq + 1) & 0xffff));
409 }
e309128f 410#endif
d1ccf0e0 411 s->seq = seq;
e309128f
FB
412 len -= 12;
413 buf += 12;
8b1ab7bf
FB
414
415 st = s->st;
416 if (!st) {
417 /* specific MPEG2TS demux support */
418 ret = mpegts_parse_packet(s->ts, pkt, buf, len);
419 if (ret < 0)
e309128f 420 return -1;
8b1ab7bf
FB
421 if (ret < len) {
422 s->read_buf_size = len - ret;
423 memcpy(s->buf, buf + ret, s->read_buf_size);
424 s->read_buf_index = 0;
425 return 1;
426 }
427 } else {
01f4895c 428 switch(st->codec->codec_id) {
8b1ab7bf
FB
429 case CODEC_ID_MP2:
430 /* better than nothing: skip mpeg audio RTP header */
431 if (len <= 4)
432 return -1;
433 h = decode_be32(buf);
434 len -= 4;
435 buf += 4;
436 av_new_packet(pkt, len);
437 memcpy(pkt->data, buf, len);
438 break;
439 case CODEC_ID_MPEG1VIDEO:
ccd39ae6 440 /* better than nothing: skip mpeg video RTP header */
e309128f
FB
441 if (len <= 4)
442 return -1;
8b1ab7bf 443 h = decode_be32(buf);
e309128f
FB
444 buf += 4;
445 len -= 4;
8b1ab7bf
FB
446 if (h & (1 << 26)) {
447 /* mpeg2 */
448 if (len <= 4)
449 return -1;
450 buf += 4;
451 len -= 4;
452 }
453 av_new_packet(pkt, len);
454 memcpy(pkt->data, buf, len);
455 break;
456 default:
457 av_new_packet(pkt, len);
458 memcpy(pkt->data, buf, len);
459 break;
e309128f 460 }
8b1ab7bf 461
01f4895c 462 switch(st->codec->codec_id) {
8b1ab7bf
FB
463 case CODEC_ID_MP2:
464 case CODEC_ID_MPEG1VIDEO:
465 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
466 int64_t addend;
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;
474 }
475 break;
d1ccf0e0
RD
476 case CODEC_ID_MPEG4:
477 pkt->pts = timestamp;
478 break;
479 case CODEC_ID_MPEG4AAC:
480 if (rtp_parse_mp4_au(s, buf))
481 return -1;
d3655fad 482 {
d1ccf0e0
RD
483 rtp_payload_data_t *infos = s->rtp_payload_data;
484 if (infos == NULL)
485 return -1;
486 buf += infos->au_headers_length_bytes + 2;
487 len -= infos->au_headers_length_bytes + 2;
488
489 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
490 one au_header */
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;
d3655fad 495 }
d1ccf0e0
RD
496 s->read_buf_size = len;
497 s->buf_ptr = (char *)buf;
498 pkt->stream_index = s->st->index;
499 return 0;
8b1ab7bf
FB
500 default:
501 /* no timestamp info yet */
502 break;
e5526b2c 503 }
8b1ab7bf 504 pkt->stream_index = s->st->index;
e309128f
FB
505 }
506 return 0;
507}
508
8b1ab7bf 509void rtp_parse_close(RTPDemuxContext *s)
e309128f 510{
d1ccf0e0 511 if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
8b1ab7bf 512 mpegts_parse_close(s->ts);
e309128f 513 }
8b1ab7bf 514 av_free(s);
e309128f
FB
515}
516
517/* rtp output */
518
519static int rtp_write_header(AVFormatContext *s1)
520{
8b1ab7bf
FB
521 RTPDemuxContext *s = s1->priv_data;
522 int payload_type, max_packet_size, n;
e309128f
FB
523 AVStream *st;
524
525 if (s1->nb_streams != 1)
526 return -1;
527 st = s1->streams[0];
528
01f4895c 529 payload_type = rtp_get_payload_type(st->codec);
e309128f 530 if (payload_type < 0)
65e70450 531 payload_type = RTP_PT_PRIVATE; /* private payload type */
e309128f
FB
532 s->payload_type = payload_type;
533
534 s->base_timestamp = random();
535 s->timestamp = s->base_timestamp;
536 s->ssrc = random();
537 s->first_packet = 1;
538
539 max_packet_size = url_fget_max_packet_size(&s1->pb);
540 if (max_packet_size <= 12)
541 return AVERROR_IO;
542 s->max_payload_size = max_packet_size - 12;
543
01f4895c 544 switch(st->codec->codec_id) {
e309128f 545 case CODEC_ID_MP2:
80783dc2 546 case CODEC_ID_MP3:
e309128f
FB
547 s->buf_ptr = s->buf + 4;
548 s->cur_timestamp = 0;
549 break;
550 case CODEC_ID_MPEG1VIDEO:
551 s->cur_timestamp = 0;
552 break;
8b1ab7bf
FB
553 case CODEC_ID_MPEG2TS:
554 n = s->max_payload_size / TS_PACKET_SIZE;
555 if (n < 1)
556 n = 1;
557 s->max_payload_size = n * TS_PACKET_SIZE;
558 s->buf_ptr = s->buf;
559 break;
e309128f
FB
560 default:
561 s->buf_ptr = s->buf;
562 break;
563 }
564
565 return 0;
566}
567
568/* send an rtcp sender report packet */
0c1a9eda 569static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
e309128f 570{
8b1ab7bf 571 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
572#if defined(DEBUG)
573 printf("RTCP: %02x %Lx %x\n", s->payload_type, ntp_time, s->timestamp);
574#endif
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);
584}
585
586/* send an rtp packet. sequence number is incremented, but the caller
587 must update the timestamp itself */
49057904 588static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len)
e309128f 589{
8b1ab7bf 590 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
591
592#ifdef DEBUG
593 printf("rtp_send_data size=%d\n", len);
594#endif
595
596 /* build the RTP header */
597 put_byte(&s1->pb, (RTP_VERSION << 6));
598 put_byte(&s1->pb, s->payload_type & 0x7f);
599 put_be16(&s1->pb, s->seq);
600 put_be32(&s1->pb, s->timestamp);
601 put_be32(&s1->pb, s->ssrc);
602
603 put_buffer(&s1->pb, buf1, len);
604 put_flush_packet(&s1->pb);
605
606 s->seq++;
607 s->octet_count += len;
608 s->packet_count++;
609}
610
611/* send an integer number of samples and compute time stamp and fill
612 the rtp send buffer before sending. */
613static void rtp_send_samples(AVFormatContext *s1,
49057904 614 const uint8_t *buf1, int size, int sample_size)
e309128f 615{
8b1ab7bf 616 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
617 int len, max_packet_size, n;
618
619 max_packet_size = (s->max_payload_size / sample_size) * sample_size;
620 /* not needed, but who nows */
621 if ((size % sample_size) != 0)
622 av_abort();
623 while (size > 0) {
624 len = (max_packet_size - (s->buf_ptr - s->buf));
625 if (len > size)
626 len = size;
627
628 /* copy data */
629 memcpy(s->buf_ptr, buf1, len);
630 s->buf_ptr += len;
631 buf1 += len;
632 size -= 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);
637 s->buf_ptr = s->buf;
638 /* update timestamp */
639 s->timestamp += n / sample_size;
640 }
641 }
642}
643
644/* NOTE: we suppose that exactly one frame is given as argument here */
645/* XXX: test it */
646static void rtp_send_mpegaudio(AVFormatContext *s1,
49057904 647 const uint8_t *buf1, int size)
e309128f 648{
8b1ab7bf 649 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
650 AVStream *st = s1->streams[0];
651 int len, count, max_packet_size;
652
653 max_packet_size = s->max_payload_size;
654
655 /* test if we must flush because not enough space */
656 len = (s->buf_ptr - s->buf);
657 if ((len + size) > max_packet_size) {
658 if (len > 4) {
659 rtp_send_data(s1, s->buf, s->buf_ptr - s->buf);
660 s->buf_ptr = s->buf + 4;
661 /* 90 KHz time stamp */
662 s->timestamp = s->base_timestamp +
01f4895c 663 (s->cur_timestamp * 90000LL) / st->codec->sample_rate;
e309128f
FB
664 }
665 }
666
667 /* add the packet */
668 if (size > max_packet_size) {
669 /* big packet: fragment */
670 count = 0;
671 while (size > 0) {
672 len = max_packet_size - 4;
673 if (len > size)
674 len = size;
675 /* build fragmented packet */
676 s->buf[0] = 0;
677 s->buf[1] = 0;
678 s->buf[2] = count >> 8;
679 s->buf[3] = count;
680 memcpy(s->buf + 4, buf1, len);
681 rtp_send_data(s1, s->buf, len + 4);
682 size -= len;
683 buf1 += len;
684 count += len;
685 }
686 } else {
687 if (s->buf_ptr == s->buf + 4) {
688 /* no fragmentation possible */
689 s->buf[0] = 0;
690 s->buf[1] = 0;
691 s->buf[2] = 0;
692 s->buf[3] = 0;
693 }
694 memcpy(s->buf_ptr, buf1, size);
695 s->buf_ptr += size;
696 }
01f4895c 697 s->cur_timestamp += st->codec->frame_size;
e309128f
FB
698}
699
700/* NOTE: a single frame must be passed with sequence header if
701 needed. XXX: use slices. */
702static void rtp_send_mpegvideo(AVFormatContext *s1,
49057904 703 const uint8_t *buf1, int size)
e309128f 704{
8b1ab7bf 705 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
706 AVStream *st = s1->streams[0];
707 int len, h, max_packet_size;
0c1a9eda 708 uint8_t *q;
e309128f
FB
709
710 max_packet_size = s->max_payload_size;
711
712 while (size > 0) {
713 /* XXX: more correct headers */
714 h = 0;
01f4895c 715 if (st->codec->sub_id == 2)
e309128f
FB
716 h |= 1 << 26; /* mpeg 2 indicator */
717 q = s->buf;
718 *q++ = h >> 24;
719 *q++ = h >> 16;
720 *q++ = h >> 8;
721 *q++ = h;
722
01f4895c 723 if (st->codec->sub_id == 2) {
e309128f
FB
724 h = 0;
725 *q++ = h >> 24;
726 *q++ = h >> 16;
727 *q++ = h >> 8;
728 *q++ = h;
729 }
730
731 len = max_packet_size - (q - s->buf);
732 if (len > size)
733 len = size;
734
735 memcpy(q, buf1, len);
736 q += len;
737
738 /* 90 KHz time stamp */
e309128f 739 s->timestamp = s->base_timestamp +
01f4895c 740 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
e309128f
FB
741 rtp_send_data(s1, s->buf, q - s->buf);
742
743 buf1 += len;
744 size -= len;
745 }
746 s->cur_timestamp++;
747}
748
65e70450 749static void rtp_send_raw(AVFormatContext *s1,
49057904 750 const uint8_t *buf1, int size)
65e70450 751{
8b1ab7bf 752 RTPDemuxContext *s = s1->priv_data;
65e70450
FB
753 AVStream *st = s1->streams[0];
754 int len, max_packet_size;
755
756 max_packet_size = s->max_payload_size;
757
758 while (size > 0) {
759 len = max_packet_size;
760 if (len > size)
761 len = size;
762
763 /* 90 KHz time stamp */
65e70450 764 s->timestamp = s->base_timestamp +
01f4895c 765 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
65e70450
FB
766 rtp_send_data(s1, buf1, len);
767
768 buf1 += len;
769 size -= len;
770 }
771 s->cur_timestamp++;
772}
773
8b1ab7bf
FB
774/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
775static void rtp_send_mpegts_raw(AVFormatContext *s1,
776 const uint8_t *buf1, int size)
777{
778 RTPDemuxContext *s = s1->priv_data;
779 int len, out_len;
780
781 while (size >= TS_PACKET_SIZE) {
782 len = s->max_payload_size - (s->buf_ptr - s->buf);
783 if (len > size)
784 len = size;
785 memcpy(s->buf_ptr, buf1, len);
786 buf1 += len;
787 size -= len;
788 s->buf_ptr += len;
789
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);
793 s->buf_ptr = s->buf;
794 }
795 }
796}
797
e309128f 798/* write an RTP packet. 'buf1' must contain a single specific frame. */
e928649b 799static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
e309128f 800{
8b1ab7bf 801 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
802 AVStream *st = s1->streams[0];
803 int rtcp_bytes;
0c1a9eda 804 int64_t ntp_time;
e928649b
MN
805 int size= pkt->size;
806 uint8_t *buf1= pkt->data;
e309128f
FB
807
808#ifdef DEBUG
e928649b 809 printf("%d: write len=%d\n", pkt->stream_index, size);
e309128f
FB
810#endif
811
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) /
814 RTCP_TX_RATIO_DEN;
815 if (s->first_packet || rtcp_bytes >= 28) {
816 /* compute NTP time */
e5526b2c 817 /* XXX: 90 kHz timestamp hardcoded */
e928649b 818 ntp_time = (pkt->pts << 28) / 5625;
e309128f
FB
819 rtcp_send_sr(s1, ntp_time);
820 s->last_octet_count = s->octet_count;
821 s->first_packet = 0;
822 }
823
01f4895c 824 switch(st->codec->codec_id) {
e309128f
FB
825 case CODEC_ID_PCM_MULAW:
826 case CODEC_ID_PCM_ALAW:
827 case CODEC_ID_PCM_U8:
828 case CODEC_ID_PCM_S8:
01f4895c 829 rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
e309128f
FB
830 break;
831 case CODEC_ID_PCM_U16BE:
832 case CODEC_ID_PCM_U16LE:
833 case CODEC_ID_PCM_S16BE:
834 case CODEC_ID_PCM_S16LE:
01f4895c 835 rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
e309128f
FB
836 break;
837 case CODEC_ID_MP2:
80783dc2 838 case CODEC_ID_MP3:
e309128f
FB
839 rtp_send_mpegaudio(s1, buf1, size);
840 break;
841 case CODEC_ID_MPEG1VIDEO:
842 rtp_send_mpegvideo(s1, buf1, size);
843 break;
8b1ab7bf
FB
844 case CODEC_ID_MPEG2TS:
845 rtp_send_mpegts_raw(s1, buf1, size);
846 break;
e309128f 847 default:
65e70450
FB
848 /* better than nothing : send the codec raw data */
849 rtp_send_raw(s1, buf1, size);
850 break;
e309128f
FB
851 }
852 return 0;
853}
854
855static int rtp_write_trailer(AVFormatContext *s1)
856{
8b1ab7bf 857 // RTPDemuxContext *s = s1->priv_data;
e309128f
FB
858 return 0;
859}
860
e309128f
FB
861AVOutputFormat rtp_mux = {
862 "rtp",
863 "RTP output format",
864 NULL,
865 NULL,
8b1ab7bf 866 sizeof(RTPDemuxContext),
e309128f
FB
867 CODEC_ID_PCM_MULAW,
868 CODEC_ID_NONE,
869 rtp_write_header,
870 rtp_write_packet,
871 rtp_write_trailer,
872};
873
874int rtp_init(void)
875{
876 av_register_output_format(&rtp_mux);
e309128f
FB
877 return 0;
878}