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