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