RTP/RTSP and MPEG4-AAC audio
[ffmpeg.git] / libavformat / rtp.c
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"
20 #include "mpegts.h"
21 #include "bitstream.h"
22
23 #include <unistd.h>
24 #include <sys/types.h>
25 #include <sys/socket.h>
26 #include <netinet/in.h>
27 #ifndef __BEOS__
28 # include <arpa/inet.h>
29 #else
30 # include "barpainet.h"
31 #endif
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
46 /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
47 AVRtpPayloadType_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
180 AVRtpDynamicPayloadType_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 };
186
187 struct RTPDemuxContext {
188     AVFormatContext *ic;
189     AVStream *st;
190     int payload_type;
191     uint32_t ssrc;
192     uint16_t seq;
193     uint32_t timestamp;
194     uint32_t base_timestamp;
195     uint32_t cur_timestamp;
196     int max_payload_size;
197     MpegTSContext *ts; /* only used for MP2T payloads */
198     int read_buf_index;
199     int read_buf_size;
200     
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;
209     int first_packet;
210     /* buffer for output */
211     uint8_t buf[RTP_MAX_PACKET_LENGTH];
212     uint8_t *buf_ptr;
213     /* special infos for au headers parsing */
214     rtp_payload_data_t *rtp_payload_data;
215 };
216
217 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
218 {
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;
227     }
228     return -1;
229 }
230
231 /* return < 0 if unknown payload type */
232 int rtp_get_payload_type(AVCodecContext *codec)
233 {
234     int i, payload_type;
235
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)
241                     continue;
242             payload_type = AVRtpPayloadTypes[i].pt;
243         }
244     return payload_type;
245 }
246
247 static inline uint32_t decode_be32(const uint8_t *p)
248 {
249     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
250 }
251
252 static inline uint64_t decode_be64(const uint8_t *p)
253 {
254     return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
255 }
256
257 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
258 {
259     if (buf[1] != 200)
260         return -1;
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);
265     return 0;
266 }
267
268 /**
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  */
273 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, rtp_payload_data_t *rtp_payload_data)
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;
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);
288         if (s->ts == NULL) {
289             av_free(s);
290             return NULL;
291         }
292     } else {
293         switch(st->codec.codec_id) {
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         }
304     }
305     return s;
306 }
307
308 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
309 {
310     AVCodecContext codec;
311     int au_headers_length, au_header_size, i;
312     GetBitContext getbitcontext;
313     rtp_payload_data_t *infos;
314
315     infos = s->rtp_payload_data;
316
317     if (infos == NULL)
318         return -1;
319
320     codec = s->st->codec;
321
322     /* decode the first 2 bytes where are stored the AUHeader sections
323        length in bits */
324     au_headers_length = BE_16(buf);
325
326     if (au_headers_length > RTP_MAX_PACKET_LENGTH)
327       return -1;
328
329     infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
330
331     /* skip AU headers length section (2 bytes) */
332     buf += 2;
333
334     init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
335
336     /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
337     au_header_size = infos->sizelength + infos->indexlength;
338     if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
339         return -1;
340
341     infos->nb_au_headers = au_headers_length / au_header_size;
342     infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
343
344     /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
345        In my test, the faad decoder doesnt behave correctly when sending each AU one by one
346        but does when sending the whole as one big packet...  */
347     infos->au_headers[0].size = 0;
348     infos->au_headers[0].index = 0;
349     for (i = 0; i < infos->nb_au_headers; ++i) {
350         infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
351         infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
352     }
353
354     infos->nb_au_headers = 1;
355
356     return 0;
357 }
358
359 /**
360  * Parse an RTP or RTCP packet directly sent as a buffer. 
361  * @param s RTP parse context.
362  * @param pkt returned packet
363  * @param buf input buffer or NULL to read the next packets
364  * @param len buffer len
365  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow 
366  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
367  */
368 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, 
369                      const uint8_t *buf, int len)
370 {
371     unsigned int ssrc, h;
372     int payload_type, seq, delta_timestamp, ret;
373     AVStream *st;
374     uint32_t timestamp;
375     
376     if (!buf) {
377         /* return the next packets, if any */
378         if (s->read_buf_index >= s->read_buf_size)
379             return -1;
380         ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index, 
381                                   s->read_buf_size - s->read_buf_index);
382         if (ret < 0)
383             return -1;
384         s->read_buf_index += ret;
385         if (s->read_buf_index < s->read_buf_size)
386             return 1;
387         else
388             return 0;
389     }
390
391     if (len < 12)
392         return -1;
393
394     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
395         return -1;
396     if (buf[1] >= 200 && buf[1] <= 204) {
397         rtcp_parse_packet(s, buf, len);
398         return -1;
399     }
400     payload_type = buf[1] & 0x7f;
401     seq  = (buf[2] << 8) | buf[3];
402     timestamp = decode_be32(buf + 4);
403     ssrc = decode_be32(buf + 8);
404     
405     /* NOTE: we can handle only one payload type */
406     if (s->payload_type != payload_type)
407         return -1;
408 #if defined(DEBUG) || 1
409     if (seq != ((s->seq + 1) & 0xffff)) {
410         av_log(&s->st->codec, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n", 
411                payload_type, seq, ((s->seq + 1) & 0xffff));
412     }
413 #endif
414     s->seq = seq;
415     len -= 12;
416     buf += 12;
417
418     st = s->st;
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             rtp_payload_data_t *infos = s->rtp_payload_data;
486             if (infos == NULL)
487                 return -1;
488             buf += infos->au_headers_length_bytes + 2;
489             len -= infos->au_headers_length_bytes + 2;
490
491             /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
492                one au_header */
493             av_new_packet(pkt, infos->au_headers[0].size);
494             memcpy(pkt->data, buf, infos->au_headers[0].size);
495             buf += infos->au_headers[0].size;
496             len -= infos->au_headers[0].size;
497             s->read_buf_size = len;
498             s->buf_ptr = (char *)buf;
499             pkt->stream_index = s->st->index;
500             return 0;
501         default:
502             /* no timestamp info yet */
503             break;
504         }
505         pkt->stream_index = s->st->index;
506     }
507     return 0;
508 }
509
510 void rtp_parse_close(RTPDemuxContext *s)
511 {
512     if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
513         mpegts_parse_close(s->ts);
514     }
515     av_free(s);
516 }
517
518 /* rtp output */
519
520 static int rtp_write_header(AVFormatContext *s1)
521 {
522     RTPDemuxContext *s = s1->priv_data;
523     int payload_type, max_packet_size, n;
524     AVStream *st;
525
526     if (s1->nb_streams != 1)
527         return -1;
528     st = s1->streams[0];
529
530     payload_type = rtp_get_payload_type(&st->codec);
531     if (payload_type < 0)
532         payload_type = RTP_PT_PRIVATE; /* private payload type */
533     s->payload_type = payload_type;
534
535     s->base_timestamp = random();
536     s->timestamp = s->base_timestamp;
537     s->ssrc = random();
538     s->first_packet = 1;
539
540     max_packet_size = url_fget_max_packet_size(&s1->pb);
541     if (max_packet_size <= 12)
542         return AVERROR_IO;
543     s->max_payload_size = max_packet_size - 12;
544
545     switch(st->codec.codec_id) {
546     case CODEC_ID_MP2:
547     case CODEC_ID_MP3:
548         s->buf_ptr = s->buf + 4;
549         s->cur_timestamp = 0;
550         break;
551     case CODEC_ID_MPEG1VIDEO:
552         s->cur_timestamp = 0;
553         break;
554     case CODEC_ID_MPEG2TS:
555         n = s->max_payload_size / TS_PACKET_SIZE;
556         if (n < 1)
557             n = 1;
558         s->max_payload_size = n * TS_PACKET_SIZE;
559         s->buf_ptr = s->buf;
560         break;
561     default:
562         s->buf_ptr = s->buf;
563         break;
564     }
565
566     return 0;
567 }
568
569 /* send an rtcp sender report packet */
570 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
571 {
572     RTPDemuxContext *s = s1->priv_data;
573 #if defined(DEBUG)
574     printf("RTCP: %02x %Lx %x\n", s->payload_type, ntp_time, s->timestamp);
575 #endif
576     put_byte(&s1->pb, (RTP_VERSION << 6));
577     put_byte(&s1->pb, 200);
578     put_be16(&s1->pb, 6); /* length in words - 1 */
579     put_be32(&s1->pb, s->ssrc);
580     put_be64(&s1->pb, ntp_time);
581     put_be32(&s1->pb, s->timestamp);
582     put_be32(&s1->pb, s->packet_count);
583     put_be32(&s1->pb, s->octet_count);
584     put_flush_packet(&s1->pb);
585 }
586
587 /* send an rtp packet. sequence number is incremented, but the caller
588    must update the timestamp itself */
589 static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len)
590 {
591     RTPDemuxContext *s = s1->priv_data;
592
593 #ifdef DEBUG
594     printf("rtp_send_data size=%d\n", len);
595 #endif
596
597     /* build the RTP header */
598     put_byte(&s1->pb, (RTP_VERSION << 6));
599     put_byte(&s1->pb, s->payload_type & 0x7f);
600     put_be16(&s1->pb, s->seq);
601     put_be32(&s1->pb, s->timestamp);
602     put_be32(&s1->pb, s->ssrc);
603     
604     put_buffer(&s1->pb, buf1, len);
605     put_flush_packet(&s1->pb);
606     
607     s->seq++;
608     s->octet_count += len;
609     s->packet_count++;
610 }
611
612 /* send an integer number of samples and compute time stamp and fill
613    the rtp send buffer before sending. */
614 static void rtp_send_samples(AVFormatContext *s1,
615                              const uint8_t *buf1, int size, int sample_size)
616 {
617     RTPDemuxContext *s = s1->priv_data;
618     int len, max_packet_size, n;
619
620     max_packet_size = (s->max_payload_size / sample_size) * sample_size;
621     /* not needed, but who nows */
622     if ((size % sample_size) != 0)
623         av_abort();
624     while (size > 0) {
625         len = (max_packet_size - (s->buf_ptr - s->buf));
626         if (len > size)
627             len = size;
628
629         /* copy data */
630         memcpy(s->buf_ptr, buf1, len);
631         s->buf_ptr += len;
632         buf1 += len;
633         size -= len;
634         n = (s->buf_ptr - s->buf);
635         /* if buffer full, then send it */
636         if (n >= max_packet_size) {
637             rtp_send_data(s1, s->buf, n);
638             s->buf_ptr = s->buf;
639             /* update timestamp */
640             s->timestamp += n / sample_size;
641         }
642     }
643
644
645 /* NOTE: we suppose that exactly one frame is given as argument here */
646 /* XXX: test it */
647 static void rtp_send_mpegaudio(AVFormatContext *s1,
648                                const uint8_t *buf1, int size)
649 {
650     RTPDemuxContext *s = s1->priv_data;
651     AVStream *st = s1->streams[0];
652     int len, count, max_packet_size;
653
654     max_packet_size = s->max_payload_size;
655
656     /* test if we must flush because not enough space */
657     len = (s->buf_ptr - s->buf);
658     if ((len + size) > max_packet_size) {
659         if (len > 4) {
660             rtp_send_data(s1, s->buf, s->buf_ptr - s->buf);
661             s->buf_ptr = s->buf + 4;
662             /* 90 KHz time stamp */
663             s->timestamp = s->base_timestamp + 
664                 (s->cur_timestamp * 90000LL) / st->codec.sample_rate;
665         }
666     }
667
668     /* add the packet */
669     if (size > max_packet_size) {
670         /* big packet: fragment */
671         count = 0;
672         while (size > 0) {
673             len = max_packet_size - 4;
674             if (len > size)
675                 len = size;
676             /* build fragmented packet */
677             s->buf[0] = 0;
678             s->buf[1] = 0;
679             s->buf[2] = count >> 8;
680             s->buf[3] = count;
681             memcpy(s->buf + 4, buf1, len);
682             rtp_send_data(s1, s->buf, len + 4);
683             size -= len;
684             buf1 += len;
685             count += len;
686         }
687     } else {
688         if (s->buf_ptr == s->buf + 4) {
689             /* no fragmentation possible */
690             s->buf[0] = 0;
691             s->buf[1] = 0;
692             s->buf[2] = 0;
693             s->buf[3] = 0;
694         }
695         memcpy(s->buf_ptr, buf1, size);
696         s->buf_ptr += size;
697     }
698     s->cur_timestamp += st->codec.frame_size;
699 }
700
701 /* NOTE: a single frame must be passed with sequence header if
702    needed. XXX: use slices. */
703 static void rtp_send_mpegvideo(AVFormatContext *s1,
704                                const uint8_t *buf1, int size)
705 {
706     RTPDemuxContext *s = s1->priv_data;
707     AVStream *st = s1->streams[0];
708     int len, h, max_packet_size;
709     uint8_t *q;
710
711     max_packet_size = s->max_payload_size;
712
713     while (size > 0) {
714         /* XXX: more correct headers */
715         h = 0;
716         if (st->codec.sub_id == 2)
717             h |= 1 << 26; /* mpeg 2 indicator */
718         q = s->buf;
719         *q++ = h >> 24;
720         *q++ = h >> 16;
721         *q++ = h >> 8;
722         *q++ = h;
723
724         if (st->codec.sub_id == 2) {
725             h = 0;
726             *q++ = h >> 24;
727             *q++ = h >> 16;
728             *q++ = h >> 8;
729             *q++ = h;
730         }
731         
732         len = max_packet_size - (q - s->buf);
733         if (len > size)
734             len = size;
735
736         memcpy(q, buf1, len);
737         q += len;
738
739         /* 90 KHz time stamp */
740         s->timestamp = s->base_timestamp + 
741             av_rescale((int64_t)s->cur_timestamp * st->codec.time_base.num, 90000, st->codec.time_base.den); //FIXME pass timestamps
742         rtp_send_data(s1, s->buf, q - s->buf);
743
744         buf1 += len;
745         size -= len;
746     }
747     s->cur_timestamp++;
748 }
749
750 static void rtp_send_raw(AVFormatContext *s1,
751                          const uint8_t *buf1, int size)
752 {
753     RTPDemuxContext *s = s1->priv_data;
754     AVStream *st = s1->streams[0];
755     int len, max_packet_size;
756
757     max_packet_size = s->max_payload_size;
758
759     while (size > 0) {
760         len = max_packet_size;
761         if (len > size)
762             len = size;
763
764         /* 90 KHz time stamp */
765         s->timestamp = s->base_timestamp + 
766             av_rescale((int64_t)s->cur_timestamp * st->codec.time_base.num, 90000, st->codec.time_base.den); //FIXME pass timestamps
767         rtp_send_data(s1, buf1, len);
768
769         buf1 += len;
770         size -= len;
771     }
772     s->cur_timestamp++;
773 }
774
775 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
776 static void rtp_send_mpegts_raw(AVFormatContext *s1,
777                                 const uint8_t *buf1, int size)
778 {
779     RTPDemuxContext *s = s1->priv_data;
780     int len, out_len;
781
782     while (size >= TS_PACKET_SIZE) {
783         len = s->max_payload_size - (s->buf_ptr - s->buf);
784         if (len > size)
785             len = size;
786         memcpy(s->buf_ptr, buf1, len);
787         buf1 += len;
788         size -= len;
789         s->buf_ptr += len;
790         
791         out_len = s->buf_ptr - s->buf;
792         if (out_len >= s->max_payload_size) {
793             rtp_send_data(s1, s->buf, out_len);
794             s->buf_ptr = s->buf;
795         }
796     }
797 }
798
799 /* write an RTP packet. 'buf1' must contain a single specific frame. */
800 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
801 {
802     RTPDemuxContext *s = s1->priv_data;
803     AVStream *st = s1->streams[0];
804     int rtcp_bytes;
805     int64_t ntp_time;
806     int size= pkt->size;
807     uint8_t *buf1= pkt->data;
808     
809 #ifdef DEBUG
810     printf("%d: write len=%d\n", pkt->stream_index, size);
811 #endif
812
813     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
814     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / 
815         RTCP_TX_RATIO_DEN;
816     if (s->first_packet || rtcp_bytes >= 28) {
817         /* compute NTP time */
818         /* XXX: 90 kHz timestamp hardcoded */
819         ntp_time = (pkt->pts << 28) / 5625;
820         rtcp_send_sr(s1, ntp_time); 
821         s->last_octet_count = s->octet_count;
822         s->first_packet = 0;
823     }
824
825     switch(st->codec.codec_id) {
826     case CODEC_ID_PCM_MULAW:
827     case CODEC_ID_PCM_ALAW:
828     case CODEC_ID_PCM_U8:
829     case CODEC_ID_PCM_S8:
830         rtp_send_samples(s1, buf1, size, 1 * st->codec.channels);
831         break;
832     case CODEC_ID_PCM_U16BE:
833     case CODEC_ID_PCM_U16LE:
834     case CODEC_ID_PCM_S16BE:
835     case CODEC_ID_PCM_S16LE:
836         rtp_send_samples(s1, buf1, size, 2 * st->codec.channels);
837         break;
838     case CODEC_ID_MP2:
839     case CODEC_ID_MP3:
840         rtp_send_mpegaudio(s1, buf1, size);
841         break;
842     case CODEC_ID_MPEG1VIDEO:
843         rtp_send_mpegvideo(s1, buf1, size);
844         break;
845     case CODEC_ID_MPEG2TS:
846         rtp_send_mpegts_raw(s1, buf1, size);
847         break;
848     default:
849         /* better than nothing : send the codec raw data */
850         rtp_send_raw(s1, buf1, size);
851         break;
852     }
853     return 0;
854 }
855
856 static int rtp_write_trailer(AVFormatContext *s1)
857 {
858     //    RTPDemuxContext *s = s1->priv_data;
859     return 0;
860 }
861
862 AVOutputFormat rtp_mux = {
863     "rtp",
864     "RTP output format",
865     NULL,
866     NULL,
867     sizeof(RTPDemuxContext),
868     CODEC_ID_PCM_MULAW,
869     CODEC_ID_NONE,
870     rtp_write_header,
871     rtp_write_packet,
872     rtp_write_trailer,
873 };
874
875 int rtp_init(void)
876 {
877     av_register_output_format(&rtp_mux);
878     return 0;
879 }