Remove the "AVRtpPayloadTypes[i].pt == i" assumption from RTP and RTSP
[libav.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 };