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