Mercurial > audlegacy-plugins

comparison src/ffmpeg/libavformat/rtp.c @ 808:e8776388b02a trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn] - add ffmpeg
author nenolod
date Mon, 12 Mar 2007 11:18:54 -0700
parents
children
comparison
equal deleted inserted replaced
807:0f9c8d4d3ac4 808:e8776388b02a
1 /*
2 * RTP input/output format
3 * Copyright (c) 2002 Fabrice Bellard.
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21 #include "avformat.h"
22 #include "mpegts.h"
23 #include "bitstream.h"
24
25 #include <unistd.h>
26 #include <sys/types.h>
27 #include <sys/socket.h>
28 #include <netinet/in.h>
29 #ifndef __BEOS__
30 # include <arpa/inet.h>
31 #else
32 # include "barpainet.h"
33 #endif
34 #include <netdb.h>
35
36 //#define DEBUG
37
38
39 /* TODO: - add RTCP statistics reporting (should be optional).
40
41 - add support for h263/mpeg4 packetized output : IDEA: send a
42 buffer to 'rtp_write_packet' contains all the packets for ONE
43 frame. Each packet should have a four byte header containing
44 the length in big endian format (same trick as
45 'url_open_dyn_packet_buf')
46 */
47
48 /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
49 AVRtpPayloadType_t AVRtpPayloadTypes[]=
50 {
51 {0, "PCMU", CODEC_TYPE_AUDIO, CODEC_ID_PCM_MULAW, 8000, 1},
52 {1, "Reserved", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
53 {2, "Reserved", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
54 {3, "GSM", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
55 {4, "G723", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
56 {5, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
57 {6, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 16000, 1},
58 {7, "LPC", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
59 {8, "PCMA", CODEC_TYPE_AUDIO, CODEC_ID_PCM_ALAW, 8000, 1},
60 {9, "G722", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
61 {10, "L16", CODEC_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 2},
62 {11, "L16", CODEC_TYPE_AUDIO, CODEC_ID_PCM_S16BE, 44100, 1},
63 {12, "QCELP", CODEC_TYPE_AUDIO, CODEC_ID_QCELP, 8000, 1},
64 {13, "CN", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
65 {14, "MPA", CODEC_TYPE_AUDIO, CODEC_ID_MP2, 90000, -1},
66 {15, "G728", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
67 {16, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 11025, 1},
68 {17, "DVI4", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 22050, 1},
69 {18, "G729", CODEC_TYPE_AUDIO, CODEC_ID_NONE, 8000, 1},
70 {19, "reserved", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
71 {20, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
72 {21, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
73 {22, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
74 {23, "unassigned", CODEC_TYPE_AUDIO, CODEC_ID_NONE, -1, -1},
75 {24, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
76 {25, "CelB", CODEC_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
77 {26, "JPEG", CODEC_TYPE_VIDEO, CODEC_ID_MJPEG, 90000, -1},
78 {27, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
79 {28, "nv", CODEC_TYPE_VIDEO, CODEC_ID_NONE, 90000, -1},
80 {29, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
81 {30, "unassigned", CODEC_TYPE_VIDEO, CODEC_ID_NONE, -1, -1},
82 {31, "H261", CODEC_TYPE_VIDEO, CODEC_ID_H261, 90000, -1},
83 {32, "MPV", CODEC_TYPE_VIDEO, CODEC_ID_MPEG1VIDEO, 90000, -1},
84 {33, "MP2T", CODEC_TYPE_DATA, CODEC_ID_MPEG2TS, 90000, -1},
85 {34, "H263", CODEC_TYPE_VIDEO, CODEC_ID_H263, 90000, -1},
86 {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
87 {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
88 {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
89 {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
90 {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
91 {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
92 {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
93 {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
94 {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
95 {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
96 {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
97 {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
98 {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
99 {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
100 {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
101 {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
102 {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
103 {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
104 {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
105 {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
106 {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
107 {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
108 {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
109 {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
110 {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
111 {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
112 {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
113 {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
114 {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
115 {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
116 {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
117 {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
118 {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
119 {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
120 {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
121 {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
122 {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
123 {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
124 {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
125 {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
126 {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
127 {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
128 {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
129 {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
130 {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
131 {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
132 {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
133 {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
134 {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
135 {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
136 {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
137 {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
138 {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
139 {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
140 {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
141 {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
142 {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
143 {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
144 {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
145 {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
146 {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
147 {96, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
148 {97, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
149 {98, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
150 {99, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
151 {100, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
152 {101, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
153 {102, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
154 {103, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
155 {104, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
156 {105, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
157 {106, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
158 {107, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
159 {108, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
160 {109, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
161 {110, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
162 {111, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
163 {112, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
164 {113, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
165 {114, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
166 {115, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
167 {116, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
168 {117, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
169 {118, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
170 {119, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
171 {120, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
172 {121, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
173 {122, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
174 {123, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
175 {124, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
176 {125, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
177 {126, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
178 {127, "dynamic", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
179 {-1, "", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
180 };
181
182 AVRtpDynamicPayloadType_t AVRtpDynamicPayloadTypes[]=
183 {
184 {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4},
185 {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_MPEG4AAC},
186 {"", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE}
187 };
188
189 struct RTPDemuxContext {
190 AVFormatContext *ic;
191 AVStream *st;
192 int payload_type;
193 uint32_t ssrc;
194 uint16_t seq;
195 uint32_t timestamp;
196 uint32_t base_timestamp;
197 uint32_t cur_timestamp;
198 int max_payload_size;
199 MpegTSContext *ts; /* only used for MP2T payloads */
200 int read_buf_index;
201 int read_buf_size;
202
203 /* rtcp sender statistics receive */
204 int64_t last_rtcp_ntp_time;
205 int64_t first_rtcp_ntp_time;
206 uint32_t last_rtcp_timestamp;
207 /* rtcp sender statistics */
208 unsigned int packet_count;
209 unsigned int octet_count;
210 unsigned int last_octet_count;
211 int first_packet;
212 /* buffer for output */
213 uint8_t buf[RTP_MAX_PACKET_LENGTH];
214 uint8_t *buf_ptr;
215 /* special infos for au headers parsing */
216 rtp_payload_data_t *rtp_payload_data;
217 };
218
219 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
220 {
221 if (AVRtpPayloadTypes[payload_type].codec_id != CODEC_ID_NONE) {
222 codec->codec_type = AVRtpPayloadTypes[payload_type].codec_type;
223 codec->codec_id = AVRtpPayloadTypes[payload_type].codec_id;
224 if (AVRtpPayloadTypes[payload_type].audio_channels > 0)
225 codec->channels = AVRtpPayloadTypes[payload_type].audio_channels;
226 if (AVRtpPayloadTypes[payload_type].clock_rate > 0)
227 codec->sample_rate = AVRtpPayloadTypes[payload_type].clock_rate;
228 return 0;
229 }
230 return -1;
231 }
232
233 /* return < 0 if unknown payload type */
234 int rtp_get_payload_type(AVCodecContext *codec)
235 {
236 int i, payload_type;
237
238 /* compute the payload type */
239 for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
240 if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
241 if (codec->codec_id == CODEC_ID_PCM_S16BE)
242 if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
243 continue;
244 payload_type = AVRtpPayloadTypes[i].pt;
245 }
246 return payload_type;
247 }
248
249 static inline uint32_t decode_be32(const uint8_t *p)
250 {
251 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
252 }
253
254 static inline uint64_t decode_be64(const uint8_t *p)
255 {
256 return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
257 }
258
259 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
260 {
261 if (buf[1] != 200)
262 return -1;
263 s->last_rtcp_ntp_time = decode_be64(buf + 8);
264 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
265 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
266 s->last_rtcp_timestamp = decode_be32(buf + 16);
267 return 0;
268 }
269
270 /**
271 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
272 * MPEG2TS streams to indicate that they should be demuxed inside the
273 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
274 */
275 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, rtp_payload_data_t *rtp_payload_data)
276 {
277 RTPDemuxContext *s;
278
279 s = av_mallocz(sizeof(RTPDemuxContext));
280 if (!s)
281 return NULL;
282 s->payload_type = payload_type;
283 s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
284 s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
285 s->ic = s1;
286 s->st = st;
287 s->rtp_payload_data = rtp_payload_data;
288 if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
289 s->ts = mpegts_parse_open(s->ic);
290 if (s->ts == NULL) {
291 av_free(s);
292 return NULL;
293 }
294 } else {
295 switch(st->codec->codec_id) {
296 case CODEC_ID_MPEG1VIDEO:
297 case CODEC_ID_MPEG2VIDEO:
298 case CODEC_ID_MP2:
299 case CODEC_ID_MP3:
300 case CODEC_ID_MPEG4:
301 st->need_parsing = 1;
302 break;
303 default:
304 break;
305 }
306 }
307 return s;
308 }
309
310 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
311 {
312 int au_headers_length, au_header_size, i;
313 GetBitContext getbitcontext;
314 rtp_payload_data_t *infos;
315
316 infos = s->rtp_payload_data;
317
318 if (infos == NULL)
319 return -1;
320
321 /* decode the first 2 bytes where are stored the AUHeader sections
322 length in bits */
323 au_headers_length = BE_16(buf);
324
325 if (au_headers_length > RTP_MAX_PACKET_LENGTH)
326 return -1;
327
328 infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
329
330 /* skip AU headers length section (2 bytes) */
331 buf += 2;
332
333 init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
334
335 /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
336 au_header_size = infos->sizelength + infos->indexlength;
337 if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
338 return -1;
339
340 infos->nb_au_headers = au_headers_length / au_header_size;
341 infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
342
343 /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
344 In my test, the faad decoder doesnt behave correctly when sending each AU one by one
345 but does when sending the whole as one big packet... */
346 infos->au_headers[0].size = 0;
347 infos->au_headers[0].index = 0;
348 for (i = 0; i < infos->nb_au_headers; ++i) {
349 infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
350 infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
351 }
352
353 infos->nb_au_headers = 1;
354
355 return 0;
356 }
357
358 /**
359 * Parse an RTP or RTCP packet directly sent as a buffer.
360 * @param s RTP parse context.
361 * @param pkt returned packet
362 * @param buf input buffer or NULL to read the next packets
363 * @param len buffer len
364 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
365 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
366 */
367 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
368 const uint8_t *buf, int len)
369 {
370 unsigned int ssrc, h;
371 int payload_type, seq, delta_timestamp, ret;
372 AVStream *st;
373 uint32_t timestamp;
374
375 if (!buf) {
376 /* return the next packets, if any */
377 if (s->read_buf_index >= s->read_buf_size)
378 return -1;
379 ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
380 s->read_buf_size - s->read_buf_index);
381 if (ret < 0)
382 return -1;
383 s->read_buf_index += ret;
384 if (s->read_buf_index < s->read_buf_size)
385 return 1;
386 else
387 return 0;
388 }
389
390 if (len < 12)
391 return -1;
392
393 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
394 return -1;
395 if (buf[1] >= 200 && buf[1] <= 204) {
396 rtcp_parse_packet(s, buf, len);
397 return -1;
398 }
399 payload_type = buf[1] & 0x7f;
400 seq = (buf[2] << 8) | buf[3];
401 timestamp = decode_be32(buf + 4);
402 ssrc = decode_be32(buf + 8);
403
404 /* NOTE: we can handle only one payload type */
405 if (s->payload_type != payload_type)
406 return -1;
407
408 st = s->st;
409 #if defined(DEBUG) || 1
410 if (seq != ((s->seq + 1) & 0xffff)) {
411 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
412 payload_type, seq, ((s->seq + 1) & 0xffff));
413 }
414 #endif
415 s->seq = seq;
416 len -= 12;
417 buf += 12;
418
419 if (!st) {
420 /* specific MPEG2TS demux support */
421 ret = mpegts_parse_packet(s->ts, pkt, buf, len);
422 if (ret < 0)
423 return -1;
424 if (ret < len) {
425 s->read_buf_size = len - ret;
426 memcpy(s->buf, buf + ret, s->read_buf_size);
427 s->read_buf_index = 0;
428 return 1;
429 }
430 } else {
431 switch(st->codec->codec_id) {
432 case CODEC_ID_MP2:
433 /* better than nothing: skip mpeg audio RTP header */
434 if (len <= 4)
435 return -1;
436 h = decode_be32(buf);
437 len -= 4;
438 buf += 4;
439 av_new_packet(pkt, len);
440 memcpy(pkt->data, buf, len);
441 break;
442 case CODEC_ID_MPEG1VIDEO:
443 /* better than nothing: skip mpeg video RTP header */
444 if (len <= 4)
445 return -1;
446 h = decode_be32(buf);
447 buf += 4;
448 len -= 4;
449 if (h & (1 << 26)) {
450 /* mpeg2 */
451 if (len <= 4)
452 return -1;
453 buf += 4;
454 len -= 4;
455 }
456 av_new_packet(pkt, len);
457 memcpy(pkt->data, buf, len);
458 break;
459 default:
460 av_new_packet(pkt, len);
461 memcpy(pkt->data, buf, len);
462 break;
463 }
464
465 switch(st->codec->codec_id) {
466 case CODEC_ID_MP2:
467 case CODEC_ID_MPEG1VIDEO:
468 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
469 int64_t addend;
470 /* XXX: is it really necessary to unify the timestamp base ? */
471 /* compute pts from timestamp with received ntp_time */
472 delta_timestamp = timestamp - s->last_rtcp_timestamp;
473 /* convert to 90 kHz without overflow */
474 addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
475 addend = (addend * 5625) >> 14;
476 pkt->pts = addend + delta_timestamp;
477 }
478 break;
479 case CODEC_ID_MPEG4:
480 pkt->pts = timestamp;
481 break;
482 case CODEC_ID_MPEG4AAC:
483 if (rtp_parse_mp4_au(s, buf))
484 return -1;
485 {
486 rtp_payload_data_t *infos = s->rtp_payload_data;
487 if (infos == NULL)
488 return -1;
489 buf += infos->au_headers_length_bytes + 2;
490 len -= infos->au_headers_length_bytes + 2;
491
492 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
493 one au_header */
494 av_new_packet(pkt, infos->au_headers[0].size);
495 memcpy(pkt->data, buf, infos->au_headers[0].size);
496 buf += infos->au_headers[0].size;
497 len -= infos->au_headers[0].size;
498 }
499 s->read_buf_size = len;
500 s->buf_ptr = buf;
501 pkt->stream_index = s->st->index;
502 return 0;
503 default:
504 /* no timestamp info yet */
505 break;
506 }
507 pkt->stream_index = s->st->index;
508 }
509 return 0;
510 }
511
512 void rtp_parse_close(RTPDemuxContext *s)
513 {
514 if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
515 mpegts_parse_close(s->ts);
516 }
517 av_free(s);
518 }
519
520 /* rtp output */
521
522 static int rtp_write_header(AVFormatContext *s1)
523 {
524 RTPDemuxContext *s = s1->priv_data;
525 int payload_type, max_packet_size, n;
526 AVStream *st;
527
528 if (s1->nb_streams != 1)
529 return -1;
530 st = s1->streams[0];
531
532 payload_type = rtp_get_payload_type(st->codec);
533 if (payload_type < 0)
534 payload_type = RTP_PT_PRIVATE; /* private payload type */
535 s->payload_type = payload_type;
536
537 // following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
538 s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
539 s->timestamp = s->base_timestamp;
540 s->ssrc = 0; /* FIXME: was random(), what should this be? */
541 s->first_packet = 1;
542
543 max_packet_size = url_fget_max_packet_size(&s1->pb);
544 if (max_packet_size <= 12)
545 return AVERROR_IO;
546 s->max_payload_size = max_packet_size - 12;
547
548 switch(st->codec->codec_id) {
549 case CODEC_ID_MP2:
550 case CODEC_ID_MP3:
551 s->buf_ptr = s->buf + 4;
552 s->cur_timestamp = 0;
553 break;
554 case CODEC_ID_MPEG1VIDEO:
555 s->cur_timestamp = 0;
556 break;
557 case CODEC_ID_MPEG2TS:
558 n = s->max_payload_size / TS_PACKET_SIZE;
559 if (n < 1)
560 n = 1;
561 s->max_payload_size = n * TS_PACKET_SIZE;
562 s->buf_ptr = s->buf;
563 break;
564 default:
565 s->buf_ptr = s->buf;
566 break;
567 }
568
569 return 0;
570 }
571
572 /* send an rtcp sender report packet */
573 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
574 {
575 RTPDemuxContext *s = s1->priv_data;
576 #if defined(DEBUG)
577 printf("RTCP: %02x %Lx %x\n", s->payload_type, ntp_time, s->timestamp);
578 #endif
579 put_byte(&s1->pb, (RTP_VERSION << 6));
580 put_byte(&s1->pb, 200);
581 put_be16(&s1->pb, 6); /* length in words - 1 */
582 put_be32(&s1->pb, s->ssrc);
583 put_be64(&s1->pb, ntp_time);
584 put_be32(&s1->pb, s->timestamp);
585 put_be32(&s1->pb, s->packet_count);
586 put_be32(&s1->pb, s->octet_count);
587 put_flush_packet(&s1->pb);
588 }
589
590 /* send an rtp packet. sequence number is incremented, but the caller
591 must update the timestamp itself */
592 static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
593 {
594 RTPDemuxContext *s = s1->priv_data;
595
596 #ifdef DEBUG
597 printf("rtp_send_data size=%d\n", len);
598 #endif
599
600 /* build the RTP header */
601 put_byte(&s1->pb, (RTP_VERSION << 6));
602 put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
603 put_be16(&s1->pb, s->seq);
604 put_be32(&s1->pb, s->timestamp);
605 put_be32(&s1->pb, s->ssrc);
606
607 put_buffer(&s1->pb, buf1, len);
608 put_flush_packet(&s1->pb);
609
610 s->seq++;
611 s->octet_count += len;
612 s->packet_count++;
613 }
614
615 /* send an integer number of samples and compute time stamp and fill
616 the rtp send buffer before sending. */
617 static void rtp_send_samples(AVFormatContext *s1,
618 const uint8_t *buf1, int size, int sample_size)
619 {
620 RTPDemuxContext *s = s1->priv_data;
621 int len, max_packet_size, n;
622
623 max_packet_size = (s->max_payload_size / sample_size) * sample_size;
624 /* not needed, but who nows */
625 if ((size % sample_size) != 0)
626 av_abort();
627 while (size > 0) {
628 len = (max_packet_size - (s->buf_ptr - s->buf));
629 if (len > size)
630 len = size;
631
632 /* copy data */
633 memcpy(s->buf_ptr, buf1, len);
634 s->buf_ptr += len;
635 buf1 += len;
636 size -= len;
637 n = (s->buf_ptr - s->buf);
638 /* if buffer full, then send it */
639 if (n >= max_packet_size) {
640 rtp_send_data(s1, s->buf, n, 0);
641 s->buf_ptr = s->buf;
642 /* update timestamp */
643 s->timestamp += n / sample_size;
644 }
645 }
646 }
647
648 /* NOTE: we suppose that exactly one frame is given as argument here */
649 /* XXX: test it */
650 static void rtp_send_mpegaudio(AVFormatContext *s1,
651 const uint8_t *buf1, int size)
652 {
653 RTPDemuxContext *s = s1->priv_data;
654 AVStream *st = s1->streams[0];
655 int len, count, max_packet_size;
656
657 max_packet_size = s->max_payload_size;
658
659 /* test if we must flush because not enough space */
660 len = (s->buf_ptr - s->buf);
661 if ((len + size) > max_packet_size) {
662 if (len > 4) {
663 rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
664 s->buf_ptr = s->buf + 4;
665 /* 90 KHz time stamp */
666 s->timestamp = s->base_timestamp +
667 (s->cur_timestamp * 90000LL) / st->codec->sample_rate;
668 }
669 }
670
671 /* add the packet */
672 if (size > max_packet_size) {
673 /* big packet: fragment */
674 count = 0;
675 while (size > 0) {
676 len = max_packet_size - 4;
677 if (len > size)
678 len = size;
679 /* build fragmented packet */
680 s->buf[0] = 0;
681 s->buf[1] = 0;
682 s->buf[2] = count >> 8;
683 s->buf[3] = count;
684 memcpy(s->buf + 4, buf1, len);
685 rtp_send_data(s1, s->buf, len + 4, 0);
686 size -= len;
687 buf1 += len;
688 count += len;
689 }
690 } else {
691 if (s->buf_ptr == s->buf + 4) {
692 /* no fragmentation possible */
693 s->buf[0] = 0;
694 s->buf[1] = 0;
695 s->buf[2] = 0;
696 s->buf[3] = 0;
697 }
698 memcpy(s->buf_ptr, buf1, size);
699 s->buf_ptr += size;
700 }
701 s->cur_timestamp += st->codec->frame_size;
702 }
703
704 /* NOTE: a single frame must be passed with sequence header if
705 needed. XXX: use slices. */
706 static void rtp_send_mpegvideo(AVFormatContext *s1,
707 const uint8_t *buf1, int size)
708 {
709 RTPDemuxContext *s = s1->priv_data;
710 AVStream *st = s1->streams[0];
711 int len, h, max_packet_size;
712 uint8_t *q;
713
714 max_packet_size = s->max_payload_size;
715
716 while (size > 0) {
717 /* XXX: more correct headers */
718 h = 0;
719 if (st->codec->sub_id == 2)
720 h |= 1 << 26; /* mpeg 2 indicator */
721 q = s->buf;
722 *q++ = h >> 24;
723 *q++ = h >> 16;
724 *q++ = h >> 8;
725 *q++ = h;
726
727 if (st->codec->sub_id == 2) {
728 h = 0;
729 *q++ = h >> 24;
730 *q++ = h >> 16;
731 *q++ = h >> 8;
732 *q++ = h;
733 }
734
735 len = max_packet_size - (q - s->buf);
736 if (len > size)
737 len = size;
738
739 memcpy(q, buf1, len);
740 q += len;
741
742 /* 90 KHz time stamp */
743 s->timestamp = s->base_timestamp +
744 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
745 rtp_send_data(s1, s->buf, q - s->buf, (len == size));
746
747 buf1 += len;
748 size -= len;
749 }
750 s->cur_timestamp++;
751 }
752
753 static void rtp_send_raw(AVFormatContext *s1,
754 const uint8_t *buf1, int size)
755 {
756 RTPDemuxContext *s = s1->priv_data;
757 AVStream *st = s1->streams[0];
758 int len, max_packet_size;
759
760 max_packet_size = s->max_payload_size;
761
762 while (size > 0) {
763 len = max_packet_size;
764 if (len > size)
765 len = size;
766
767 /* 90 KHz time stamp */
768 s->timestamp = s->base_timestamp +
769 av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
770 rtp_send_data(s1, buf1, len, (len == size));
771
772 buf1 += len;
773 size -= len;
774 }
775 s->cur_timestamp++;
776 }
777
778 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
779 static void rtp_send_mpegts_raw(AVFormatContext *s1,
780 const uint8_t *buf1, int size)
781 {
782 RTPDemuxContext *s = s1->priv_data;
783 int len, out_len;
784
785 while (size >= TS_PACKET_SIZE) {
786 len = s->max_payload_size - (s->buf_ptr - s->buf);
787 if (len > size)
788 len = size;
789 memcpy(s->buf_ptr, buf1, len);
790 buf1 += len;
791 size -= len;
792 s->buf_ptr += len;
793
794 out_len = s->buf_ptr - s->buf;
795 if (out_len >= s->max_payload_size) {
796 rtp_send_data(s1, s->buf, out_len, 0);
797 s->buf_ptr = s->buf;
798 }
799 }
800 }
801
802 /* write an RTP packet. 'buf1' must contain a single specific frame. */
803 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
804 {
805 RTPDemuxContext *s = s1->priv_data;
806 AVStream *st = s1->streams[0];
807 int rtcp_bytes;
808 int64_t ntp_time;
809 int size= pkt->size;
810 uint8_t *buf1= pkt->data;
811
812 #ifdef DEBUG
813 printf("%d: write len=%d\n", pkt->stream_index, size);
814 #endif
815
816 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
817 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
818 RTCP_TX_RATIO_DEN;
819 if (s->first_packet || rtcp_bytes >= 28) {
820 /* compute NTP time */
821 /* XXX: 90 kHz timestamp hardcoded */
822 ntp_time = (pkt->pts << 28) / 5625;
823 rtcp_send_sr(s1, ntp_time);
824 s->last_octet_count = s->octet_count;
825 s->first_packet = 0;
826 }
827
828 switch(st->codec->codec_id) {
829 case CODEC_ID_PCM_MULAW:
830 case CODEC_ID_PCM_ALAW:
831 case CODEC_ID_PCM_U8:
832 case CODEC_ID_PCM_S8:
833 rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
834 break;
835 case CODEC_ID_PCM_U16BE:
836 case CODEC_ID_PCM_U16LE:
837 case CODEC_ID_PCM_S16BE:
838 case CODEC_ID_PCM_S16LE:
839 rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
840 break;
841 case CODEC_ID_MP2:
842 case CODEC_ID_MP3:
843 rtp_send_mpegaudio(s1, buf1, size);
844 break;
845 case CODEC_ID_MPEG1VIDEO:
846 rtp_send_mpegvideo(s1, buf1, size);
847 break;
848 case CODEC_ID_MPEG2TS:
849 rtp_send_mpegts_raw(s1, buf1, size);
850 break;
851 default:
852 /* better than nothing : send the codec raw data */
853 rtp_send_raw(s1, buf1, size);
854 break;
855 }
856 return 0;
857 }
858
859 static int rtp_write_trailer(AVFormatContext *s1)
860 {
861 // RTPDemuxContext *s = s1->priv_data;
862 return 0;
863 }
864
865 AVOutputFormat rtp_muxer = {
866 "rtp",
867 "RTP output format",
868 NULL,
869 NULL,
870 sizeof(RTPDemuxContext),
871 CODEC_ID_PCM_MULAW,
872 CODEC_ID_NONE,
873 rtp_write_header,
874 rtp_write_packet,
875 rtp_write_trailer,
876 };