Remove the "AVRtpPayloadTypes[i].pt == i" assumption from RTP and RTSP
[ffmpeg.git] / libavformat / rtp.c
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 "network.h"
27
28 #include "rtp_internal.h"
29 #include "rtp_h264.h"
30 #include "rtp_mpv.h"
31 #include "rtp_aac.h"
32
33 //#define DEBUG
34
35 #define RTCP_SR_SIZE 28
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_QCELP, 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 /* statistics functions */
181 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
182
183 static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
184 static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
185
186 static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
187 {
188     handler->next= RTPFirstDynamicPayloadHandler;
189     RTPFirstDynamicPayloadHandler= handler;
190 }
191
192 void av_register_rtp_dynamic_payload_handlers(void)
193 {
194     register_dynamic_payload_handler(&mp4v_es_handler);
195     register_dynamic_payload_handler(&mpeg4_generic_handler);
196     register_dynamic_payload_handler(&ff_h264_dynamic_handler);
197 }
198
199 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
200 {
201     int i = 0;
202
203     for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
204         if (AVRtpPayloadTypes[i].pt == payload_type) {
205             if (AVRtpPayloadTypes[i].codec_id != CODEC_ID_NONE) {
206                 codec->codec_type = AVRtpPayloadTypes[i].codec_type;
207                 codec->codec_id = AVRtpPayloadTypes[i].codec_id;
208                 if (AVRtpPayloadTypes[i].audio_channels > 0)
209                     codec->channels = AVRtpPayloadTypes[i].audio_channels;
210                 if (AVRtpPayloadTypes[i].clock_rate > 0)
211                     codec->sample_rate = AVRtpPayloadTypes[i].clock_rate;
212                 return 0;
213             }
214         }
215     return -1;
216 }
217
218 int rtp_get_payload_type(AVCodecContext *codec)
219 {
220     int i, payload_type;
221
222     /* compute the payload type */
223     for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
224         if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
225             if (codec->codec_id == CODEC_ID_PCM_S16BE)
226                 if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
227                     continue;
228             payload_type = AVRtpPayloadTypes[i].pt;
229         }
230     return payload_type;
231 }
232
233 const char *ff_rtp_enc_name(int payload_type)
234 {
235     int i;
236
237     for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
238         if (AVRtpPayloadTypes[i].pt == payload_type) {
239             return AVRtpPayloadTypes[i].enc_name;
240         }
241
242     return "";
243 }
244
245 enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type)
246 {
247     int i;
248
249     for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
250         if (!strcmp(buf, AVRtpPayloadTypes[i].enc_name) && (codec_type == AVRtpPayloadTypes[i].codec_type)){
251             return AVRtpPayloadTypes[i].codec_id;
252         }
253
254     return CODEC_ID_NONE;
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 = AV_RB64(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 = AV_RB32(buf + 16);
265     return 0;
266 }
267
268 #define RTP_SEQ_MOD (1<<16)
269
270 /**
271 * called on parse open packet
272 */
273 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
274 {
275     memset(s, 0, sizeof(RTPStatistics));
276     s->max_seq= base_sequence;
277     s->probation= 1;
278 }
279
280 /**
281 * called whenever there is a large jump in sequence numbers, or when they get out of probation...
282 */
283 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
284 {
285     s->max_seq= seq;
286     s->cycles= 0;
287     s->base_seq= seq -1;
288     s->bad_seq= RTP_SEQ_MOD + 1;
289     s->received= 0;
290     s->expected_prior= 0;
291     s->received_prior= 0;
292     s->jitter= 0;
293     s->transit= 0;
294 }
295
296 /**
297 * returns 1 if we should handle this packet.
298 */
299 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
300 {
301     uint16_t udelta= seq - s->max_seq;
302     const int MAX_DROPOUT= 3000;
303     const int MAX_MISORDER = 100;
304     const int MIN_SEQUENTIAL = 2;
305
306     /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
307     if(s->probation)
308     {
309         if(seq==s->max_seq + 1) {
310             s->probation--;
311             s->max_seq= seq;
312             if(s->probation==0) {
313                 rtp_init_sequence(s, seq);
314                 s->received++;
315                 return 1;
316             }
317         } else {
318             s->probation= MIN_SEQUENTIAL - 1;
319             s->max_seq = seq;
320         }
321     } else if (udelta < MAX_DROPOUT) {
322         // in order, with permissible gap
323         if(seq < s->max_seq) {
324             //sequence number wrapped; count antother 64k cycles
325             s->cycles += RTP_SEQ_MOD;
326         }
327         s->max_seq= seq;
328     } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
329         // sequence made a large jump...
330         if(seq==s->bad_seq) {
331             // two sequential packets-- assume that the other side restarted without telling us; just resync.
332             rtp_init_sequence(s, seq);
333         } else {
334             s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
335             return 0;
336         }
337     } else {
338         // duplicate or reordered packet...
339     }
340     s->received++;
341     return 1;
342 }
343
344 #if 0
345 /**
346 * This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
347 * difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
348 * never change.  I left this in in case someone else can see a way. (rdm)
349 */
350 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
351 {
352     uint32_t transit= arrival_timestamp - sent_timestamp;
353     int d;
354     s->transit= transit;
355     d= FFABS(transit - s->transit);
356     s->jitter += d - ((s->jitter + 8)>>4);
357 }
358 #endif
359
360 int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
361 {
362     ByteIOContext pb;
363     uint8_t *buf;
364     int len;
365     int rtcp_bytes;
366     RTPStatistics *stats= &s->statistics;
367     uint32_t lost;
368     uint32_t extended_max;
369     uint32_t expected_interval;
370     uint32_t received_interval;
371     uint32_t lost_interval;
372     uint32_t expected;
373     uint32_t fraction;
374     uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
375
376     if (!s->rtp_ctx || (count < 1))
377         return -1;
378
379     /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
380     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
381     s->octet_count += count;
382     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
383         RTCP_TX_RATIO_DEN;
384     rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
385     if (rtcp_bytes < 28)
386         return -1;
387     s->last_octet_count = s->octet_count;
388
389     if (url_open_dyn_buf(&pb) < 0)
390         return -1;
391
392     // Receiver Report
393     put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
394     put_byte(&pb, 201);
395     put_be16(&pb, 7); /* length in words - 1 */
396     put_be32(&pb, s->ssrc); // our own SSRC
397     put_be32(&pb, s->ssrc); // XXX: should be the server's here!
398     // some placeholders we should really fill...
399     // RFC 1889/p64
400     extended_max= stats->cycles + stats->max_seq;
401     expected= extended_max - stats->base_seq + 1;
402     lost= expected - stats->received;
403     lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
404     expected_interval= expected - stats->expected_prior;
405     stats->expected_prior= expected;
406     received_interval= stats->received - stats->received_prior;
407     stats->received_prior= stats->received;
408     lost_interval= expected_interval - received_interval;
409     if (expected_interval==0 || lost_interval<=0) fraction= 0;
410     else fraction = (lost_interval<<8)/expected_interval;
411
412     fraction= (fraction<<24) | lost;
413
414     put_be32(&pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
415     put_be32(&pb, extended_max); /* max sequence received */
416     put_be32(&pb, stats->jitter>>4); /* jitter */
417
418     if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
419     {
420         put_be32(&pb, 0); /* last SR timestamp */
421         put_be32(&pb, 0); /* delay since last SR */
422     } else {
423         uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
424         uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
425
426         put_be32(&pb, middle_32_bits); /* last SR timestamp */
427         put_be32(&pb, delay_since_last); /* delay since last SR */
428     }
429
430     // CNAME
431     put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
432     put_byte(&pb, 202);
433     len = strlen(s->hostname);
434     put_be16(&pb, (6 + len + 3) / 4); /* length in words - 1 */
435     put_be32(&pb, s->ssrc);
436     put_byte(&pb, 0x01);
437     put_byte(&pb, len);
438     put_buffer(&pb, s->hostname, len);
439     // padding
440     for (len = (6 + len) % 4; len % 4; len++) {
441         put_byte(&pb, 0);
442     }
443
444     put_flush_packet(&pb);
445     len = url_close_dyn_buf(&pb, &buf);
446     if ((len > 0) && buf) {
447         int result;
448 #if defined(DEBUG)
449         printf("sending %d bytes of RR\n", len);
450 #endif
451         result= url_write(s->rtp_ctx, buf, len);
452 #if defined(DEBUG)
453         printf("result from url_write: %d\n", result);
454 #endif
455         av_free(buf);
456     }
457     return 0;
458 }
459
460 /**
461  * open a new RTP parse context for stream 'st'. 'st' can be NULL for
462  * MPEG2TS streams to indicate that they should be demuxed inside the
463  * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
464  * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
465  */
466 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
467 {
468     RTPDemuxContext *s;
469
470     s = av_mallocz(sizeof(RTPDemuxContext));
471     if (!s)
472         return NULL;
473     s->payload_type = payload_type;
474     s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
475     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
476     s->ic = s1;
477     s->st = st;
478     s->rtp_payload_data = rtp_payload_data;
479     rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
480     if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
481         s->ts = mpegts_parse_open(s->ic);
482         if (s->ts == NULL) {
483             av_free(s);
484             return NULL;
485         }
486     } else {
487         switch(st->codec->codec_id) {
488         case CODEC_ID_MPEG1VIDEO:
489         case CODEC_ID_MPEG2VIDEO:
490         case CODEC_ID_MP2:
491         case CODEC_ID_MP3:
492         case CODEC_ID_MPEG4:
493         case CODEC_ID_H264:
494             st->need_parsing = AVSTREAM_PARSE_FULL;
495             break;
496         default:
497             break;
498         }
499     }
500     // needed to send back RTCP RR in RTSP sessions
501     s->rtp_ctx = rtpc;
502     gethostname(s->hostname, sizeof(s->hostname));
503     return s;
504 }
505
506 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
507 {
508     int au_headers_length, au_header_size, i;
509     GetBitContext getbitcontext;
510     rtp_payload_data_t *infos;
511
512     infos = s->rtp_payload_data;
513
514     if (infos == NULL)
515         return -1;
516
517     /* decode the first 2 bytes where are stored the AUHeader sections
518        length in bits */
519     au_headers_length = AV_RB16(buf);
520
521     if (au_headers_length > RTP_MAX_PACKET_LENGTH)
522       return -1;
523
524     infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
525
526     /* skip AU headers length section (2 bytes) */
527     buf += 2;
528
529     init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
530
531     /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
532     au_header_size = infos->sizelength + infos->indexlength;
533     if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
534         return -1;
535
536     infos->nb_au_headers = au_headers_length / au_header_size;
537     infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
538
539     /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
540        In my test, the FAAD decoder does not behave correctly when sending each AU one by one
541        but does when sending the whole as one big packet...  */
542     infos->au_headers[0].size = 0;
543     infos->au_headers[0].index = 0;
544     for (i = 0; i < infos->nb_au_headers; ++i) {
545         infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
546         infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
547     }
548
549     infos->nb_au_headers = 1;
550
551     return 0;
552 }
553
554 /**
555  * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
556  */
557 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
558 {
559     switch(s->st->codec->codec_id) {
560         case CODEC_ID_MP2:
561         case CODEC_ID_MPEG1VIDEO:
562             if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
563                 int64_t addend;
564
565                 int delta_timestamp;
566                 /* XXX: is it really necessary to unify the timestamp base ? */
567                 /* compute pts from timestamp with received ntp_time */
568                 delta_timestamp = timestamp - s->last_rtcp_timestamp;
569                 /* convert to 90 kHz without overflow */
570                 addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
571                 addend = (addend * 5625) >> 14;
572                 pkt->pts = addend + delta_timestamp;
573             }
574             break;
575         case CODEC_ID_AAC:
576         case CODEC_ID_H264:
577         case CODEC_ID_MPEG4:
578             pkt->pts = timestamp;
579             break;
580         default:
581             /* no timestamp info yet */
582             break;
583     }
584     pkt->stream_index = s->st->index;
585 }
586
587 /**
588  * Parse an RTP or RTCP packet directly sent as a buffer.
589  * @param s RTP parse context.
590  * @param pkt returned packet
591  * @param buf input buffer or NULL to read the next packets
592  * @param len buffer len
593  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
594  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
595  */
596 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
597                      const uint8_t *buf, int len)
598 {
599     unsigned int ssrc, h;
600     int payload_type, seq, ret;
601     AVStream *st;
602     uint32_t timestamp;
603     int rv= 0;
604
605     if (!buf) {
606         /* return the next packets, if any */
607         if(s->st && s->parse_packet) {
608             timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
609             rv= s->parse_packet(s, pkt, &timestamp, NULL, 0);
610             finalize_packet(s, pkt, timestamp);
611             return rv;
612         } else {
613             // TODO: Move to a dynamic packet handler (like above)
614             if (s->read_buf_index >= s->read_buf_size)
615                 return -1;
616             ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
617                                       s->read_buf_size - s->read_buf_index);
618             if (ret < 0)
619                 return -1;
620             s->read_buf_index += ret;
621             if (s->read_buf_index < s->read_buf_size)
622                 return 1;
623             else
624                 return 0;
625         }
626     }
627
628     if (len < 12)
629         return -1;
630
631     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
632         return -1;
633     if (buf[1] >= 200 && buf[1] <= 204) {
634         rtcp_parse_packet(s, buf, len);
635         return -1;
636     }
637     payload_type = buf[1] & 0x7f;
638     seq  = AV_RB16(buf + 2);
639     timestamp = AV_RB32(buf + 4);
640     ssrc = AV_RB32(buf + 8);
641     /* store the ssrc in the RTPDemuxContext */
642     s->ssrc = ssrc;
643
644     /* NOTE: we can handle only one payload type */
645     if (s->payload_type != payload_type)
646         return -1;
647
648     st = s->st;
649     // only do something with this if all the rtp checks pass...
650     if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
651     {
652         av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
653                payload_type, seq, ((s->seq + 1) & 0xffff));
654         return -1;
655     }
656
657     s->seq = seq;
658     len -= 12;
659     buf += 12;
660
661     if (!st) {
662         /* specific MPEG2TS demux support */
663         ret = mpegts_parse_packet(s->ts, pkt, buf, len);
664         if (ret < 0)
665             return -1;
666         if (ret < len) {
667             s->read_buf_size = len - ret;
668             memcpy(s->buf, buf + ret, s->read_buf_size);
669             s->read_buf_index = 0;
670             return 1;
671         }
672     } else {
673         // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
674         switch(st->codec->codec_id) {
675         case CODEC_ID_MP2:
676             /* better than nothing: skip mpeg audio RTP header */
677             if (len <= 4)
678                 return -1;
679             h = AV_RB32(buf);
680             len -= 4;
681             buf += 4;
682             av_new_packet(pkt, len);
683             memcpy(pkt->data, buf, len);
684             break;
685         case CODEC_ID_MPEG1VIDEO:
686             /* better than nothing: skip mpeg video RTP header */
687             if (len <= 4)
688                 return -1;
689             h = AV_RB32(buf);
690             buf += 4;
691             len -= 4;
692             if (h & (1 << 26)) {
693                 /* mpeg2 */
694                 if (len <= 4)
695                     return -1;
696                 buf += 4;
697                 len -= 4;
698             }
699             av_new_packet(pkt, len);
700             memcpy(pkt->data, buf, len);
701             break;
702             // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
703             // timestamps.
704             // TODO: Put this into a dynamic packet handler...
705         case CODEC_ID_AAC:
706             if (rtp_parse_mp4_au(s, buf))
707                 return -1;
708             {
709                 rtp_payload_data_t *infos = s->rtp_payload_data;
710                 if (infos == NULL)
711                     return -1;
712                 buf += infos->au_headers_length_bytes + 2;
713                 len -= infos->au_headers_length_bytes + 2;
714
715                 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
716                     one au_header */
717                 av_new_packet(pkt, infos->au_headers[0].size);
718                 memcpy(pkt->data, buf, infos->au_headers[0].size);
719                 buf += infos->au_headers[0].size;
720                 len -= infos->au_headers[0].size;
721             }
722             s->read_buf_size = len;
723             rv= 0;
724             break;
725         default:
726             if(s->parse_packet) {
727                 rv= s->parse_packet(s, pkt, &timestamp, buf, len);
728             } else {
729                 av_new_packet(pkt, len);
730                 memcpy(pkt->data, buf, len);
731             }
732             break;
733         }
734
735         // now perform timestamp things....
736         finalize_packet(s, pkt, timestamp);
737     }
738     return rv;
739 }
740
741 void rtp_parse_close(RTPDemuxContext *s)
742 {
743     // TODO: fold this into the protocol specific data fields.
744     if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
745         mpegts_parse_close(s->ts);
746     }
747     av_free(s);
748 }
749
750 /* rtp output */
751
752 static int rtp_write_header(AVFormatContext *s1)
753 {
754     RTPDemuxContext *s = s1->priv_data;
755     int payload_type, max_packet_size, n;
756     AVStream *st;
757
758     if (s1->nb_streams != 1)
759         return -1;
760     st = s1->streams[0];
761
762     payload_type = rtp_get_payload_type(st->codec);
763     if (payload_type < 0)
764         payload_type = RTP_PT_PRIVATE; /* private payload type */
765     s->payload_type = payload_type;
766
767 // following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
768     s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
769     s->timestamp = s->base_timestamp;
770     s->cur_timestamp = 0;
771     s->ssrc = 0; /* FIXME: was random(), what should this be? */
772     s->first_packet = 1;
773     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
774
775     max_packet_size = url_fget_max_packet_size(&s1->pb);
776     if (max_packet_size <= 12)
777         return AVERROR(EIO);
778     s->max_payload_size = max_packet_size - 12;
779
780     s->max_frames_per_packet = 0;
781     if (s1->max_delay) {
782         if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
783             if (st->codec->frame_size == 0) {
784                 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
785             } else {
786                 s->max_frames_per_packet = av_rescale_rnd(s1->max_delay, st->codec->sample_rate, AV_TIME_BASE * st->codec->frame_size, AV_ROUND_DOWN);
787             }
788         }
789         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
790             /* FIXME: We should round down here... */
791             s->max_frames_per_packet = av_rescale_q(s1->max_delay, AV_TIME_BASE_Q, st->codec->time_base);
792         }
793     }
794
795     av_set_pts_info(st, 32, 1, 90000);
796     switch(st->codec->codec_id) {
797     case CODEC_ID_MP2:
798     case CODEC_ID_MP3:
799         s->buf_ptr = s->buf + 4;
800         break;
801     case CODEC_ID_MPEG1VIDEO:
802         break;
803     case CODEC_ID_MPEG2TS:
804         n = s->max_payload_size / TS_PACKET_SIZE;
805         if (n < 1)
806             n = 1;
807         s->max_payload_size = n * TS_PACKET_SIZE;
808         s->buf_ptr = s->buf;
809         break;
810     case CODEC_ID_AAC:
811         s->read_buf_index = 0;
812     default:
813         if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
814             av_set_pts_info(st, 32, 1, st->codec->sample_rate);
815         }
816         s->buf_ptr = s->buf;
817         break;
818     }
819
820     return 0;
821 }
822
823 /* send an rtcp sender report packet */
824 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
825 {
826     RTPDemuxContext *s = s1->priv_data;
827     uint32_t rtp_ts;
828
829 #if defined(DEBUG)
830     printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
831 #endif
832
833     if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
834     s->last_rtcp_ntp_time = ntp_time;
835     rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, AV_TIME_BASE_Q,
836                           s1->streams[0]->time_base) + s->base_timestamp;
837     put_byte(&s1->pb, (RTP_VERSION << 6));
838     put_byte(&s1->pb, 200);
839     put_be16(&s1->pb, 6); /* length in words - 1 */
840     put_be32(&s1->pb, s->ssrc);
841     put_be32(&s1->pb, ntp_time / 1000000);
842     put_be32(&s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
843     put_be32(&s1->pb, rtp_ts);
844     put_be32(&s1->pb, s->packet_count);
845     put_be32(&s1->pb, s->octet_count);
846     put_flush_packet(&s1->pb);
847 }
848
849 /* send an rtp packet. sequence number is incremented, but the caller
850    must update the timestamp itself */
851 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
852 {
853     RTPDemuxContext *s = s1->priv_data;
854
855 #ifdef DEBUG
856     printf("rtp_send_data size=%d\n", len);
857 #endif
858
859     /* build the RTP header */
860     put_byte(&s1->pb, (RTP_VERSION << 6));
861     put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
862     put_be16(&s1->pb, s->seq);
863     put_be32(&s1->pb, s->timestamp);
864     put_be32(&s1->pb, s->ssrc);
865
866     put_buffer(&s1->pb, buf1, len);
867     put_flush_packet(&s1->pb);
868
869     s->seq++;
870     s->octet_count += len;
871     s->packet_count++;
872 }
873
874 /* send an integer number of samples and compute time stamp and fill
875    the rtp send buffer before sending. */
876 static void rtp_send_samples(AVFormatContext *s1,
877                              const uint8_t *buf1, int size, int sample_size)
878 {
879     RTPDemuxContext *s = s1->priv_data;
880     int len, max_packet_size, n;
881
882     max_packet_size = (s->max_payload_size / sample_size) * sample_size;
883     /* not needed, but who nows */
884     if ((size % sample_size) != 0)
885         av_abort();
886     n = 0;
887     while (size > 0) {
888         s->buf_ptr = s->buf;
889         len = FFMIN(max_packet_size, size);
890
891         /* copy data */
892         memcpy(s->buf_ptr, buf1, len);
893         s->buf_ptr += len;
894         buf1 += len;
895         size -= len;
896         s->timestamp = s->cur_timestamp + n / sample_size;
897         ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
898         n += (s->buf_ptr - s->buf);
899     }
900 }
901
902 /* NOTE: we suppose that exactly one frame is given as argument here */
903 /* XXX: test it */
904 static void rtp_send_mpegaudio(AVFormatContext *s1,
905                                const uint8_t *buf1, int size)
906 {
907     RTPDemuxContext *s = s1->priv_data;
908     int len, count, max_packet_size;
909
910     max_packet_size = s->max_payload_size;
911
912     /* test if we must flush because not enough space */
913     len = (s->buf_ptr - s->buf);
914     if ((len + size) > max_packet_size) {
915         if (len > 4) {
916             ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
917             s->buf_ptr = s->buf + 4;
918         }
919     }
920     if (s->buf_ptr == s->buf + 4) {
921         s->timestamp = s->cur_timestamp;
922     }
923
924     /* add the packet */
925     if (size > max_packet_size) {
926         /* big packet: fragment */
927         count = 0;
928         while (size > 0) {
929             len = max_packet_size - 4;
930             if (len > size)
931                 len = size;
932             /* build fragmented packet */
933             s->buf[0] = 0;
934             s->buf[1] = 0;
935             s->buf[2] = count >> 8;
936             s->buf[3] = count;
937             memcpy(s->buf + 4, buf1, len);
938             ff_rtp_send_data(s1, s->buf, len + 4, 0);
939             size -= len;
940             buf1 += len;
941             count += len;
942         }
943     } else {
944         if (s->buf_ptr == s->buf + 4) {
945             /* no fragmentation possible */
946             s->buf[0] = 0;
947             s->buf[1] = 0;
948             s->buf[2] = 0;
949             s->buf[3] = 0;
950         }
951         memcpy(s->buf_ptr, buf1, size);
952         s->buf_ptr += size;
953     }
954 }
955
956 static void rtp_send_raw(AVFormatContext *s1,
957                          const uint8_t *buf1, int size)
958 {
959     RTPDemuxContext *s = s1->priv_data;
960     int len, max_packet_size;
961
962     max_packet_size = s->max_payload_size;
963
964     while (size > 0) {
965         len = max_packet_size;
966         if (len > size)
967             len = size;
968
969         s->timestamp = s->cur_timestamp;
970         ff_rtp_send_data(s1, buf1, len, (len == size));
971
972         buf1 += len;
973         size -= len;
974     }
975 }
976
977 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
978 static void rtp_send_mpegts_raw(AVFormatContext *s1,
979                                 const uint8_t *buf1, int size)
980 {
981     RTPDemuxContext *s = s1->priv_data;
982     int len, out_len;
983
984     while (size >= TS_PACKET_SIZE) {
985         len = s->max_payload_size - (s->buf_ptr - s->buf);
986         if (len > size)
987             len = size;
988         memcpy(s->buf_ptr, buf1, len);
989         buf1 += len;
990         size -= len;
991         s->buf_ptr += len;
992
993         out_len = s->buf_ptr - s->buf;
994         if (out_len >= s->max_payload_size) {
995             ff_rtp_send_data(s1, s->buf, out_len, 0);
996             s->buf_ptr = s->buf;
997         }
998     }
999 }
1000
1001 /* write an RTP packet. 'buf1' must contain a single specific frame. */
1002 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
1003 {
1004     RTPDemuxContext *s = s1->priv_data;
1005     AVStream *st = s1->streams[0];
1006     int rtcp_bytes;
1007     int size= pkt->size;
1008     uint8_t *buf1= pkt->data;
1009
1010 #ifdef DEBUG
1011     printf("%d: write len=%d\n", pkt->stream_index, size);
1012 #endif
1013
1014     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
1015     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
1016         RTCP_TX_RATIO_DEN;
1017     if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
1018                            (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
1019         rtcp_send_sr(s1, av_gettime());
1020         s->last_octet_count = s->octet_count;
1021         s->first_packet = 0;
1022     }
1023     s->cur_timestamp = s->base_timestamp + pkt->pts;
1024
1025     switch(st->codec->codec_id) {
1026     case CODEC_ID_PCM_MULAW:
1027     case CODEC_ID_PCM_ALAW:
1028     case CODEC_ID_PCM_U8:
1029     case CODEC_ID_PCM_S8:
1030         rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
1031         break;
1032     case CODEC_ID_PCM_U16BE:
1033     case CODEC_ID_PCM_U16LE:
1034     case CODEC_ID_PCM_S16BE:
1035     case CODEC_ID_PCM_S16LE:
1036         rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
1037         break;
1038     case CODEC_ID_MP2:
1039     case CODEC_ID_MP3:
1040         rtp_send_mpegaudio(s1, buf1, size);
1041         break;
1042     case CODEC_ID_MPEG1VIDEO:
1043         ff_rtp_send_mpegvideo(s1, buf1, size);
1044         break;
1045     case CODEC_ID_AAC:
1046         ff_rtp_send_aac(s1, buf1, size);
1047         break;
1048     case CODEC_ID_MPEG2TS:
1049         rtp_send_mpegts_raw(s1, buf1, size);
1050         break;
1051     default:
1052         /* better than nothing : send the codec raw data */
1053         rtp_send_raw(s1, buf1, size);
1054         break;
1055     }
1056     return 0;
1057 }
1058
1059 AVOutputFormat rtp_muxer = {
1060     "rtp",
1061     "RTP output format",
1062     NULL,
1063     NULL,
1064     sizeof(RTPDemuxContext),
1065     CODEC_ID_PCM_MULAW,
1066     CODEC_ID_NONE,
1067     rtp_write_header,
1068     rtp_write_packet,
1069 };