Remove the "AVRtpPayloadTypes[i].pt == i" assumption from RTP and RTSP
[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{
7ed19d7f
LA
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 }
d1ccf0e0 215 return -1;
e309128f
FB
216}
217
e309128f
FB
218int rtp_get_payload_type(AVCodecContext *codec)
219{
d1ccf0e0 220 int i, payload_type;
e309128f
FB
221
222 /* compute the payload type */
d1ccf0e0
RD
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;
e309128f 229 }
e309128f
FB
230 return payload_type;
231}
232
7ed19d7f
LA
233const 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
245enum 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
8b1ab7bf 257static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
e309128f 258{
e309128f
FB
259 if (buf[1] != 200)
260 return -1;
48961970 261 s->last_rtcp_ntp_time = AV_RB64(buf + 8);
e5526b2c
FB
262 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
263 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
48961970 264 s->last_rtcp_timestamp = AV_RB32(buf + 16);
e309128f
FB
265 return 0;
266}
267
4a6cc061
RM
268#define RTP_SEQ_MOD (1<<16)
269
270/**
271* called on parse open packet
272*/
273static 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*/
283static 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*/
299static 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*/
350static 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
dbf30963
T
360int 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;
4a6cc061
RM
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?
dbf30963
T
375
376 if (!s->rtp_ctx || (count < 1))
377 return -1;
378
4a6cc061 379 /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
dbf30963
T
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...
4a6cc061
RM
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 }
dbf30963
T
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) {
4a6cc061 447 int result;
dbf30963
T
448#if defined(DEBUG)
449 printf("sending %d bytes of RR\n", len);
450#endif
4a6cc061
RM
451 result= url_write(s->rtp_ctx, buf, len);
452#if defined(DEBUG)
453 printf("result from url_write: %d\n", result);
454#endif
dbf30963
T
455 av_free(buf);
456 }
457 return 0;
458}
459
460/**
8b1ab7bf
FB
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
115329f1 463 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
d0deedcb 464 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
8b1ab7bf 465 */
dbf30963 466RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
8b1ab7bf
FB
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;
d1ccf0e0 478 s->rtp_payload_data = rtp_payload_data;
4a6cc061 479 rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
7ed19d7f 480 if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
8b1ab7bf
FB
481 s->ts = mpegts_parse_open(s->ic);
482 if (s->ts == NULL) {
483 av_free(s);
484 return NULL;
485 }
ccd39ae6 486 } else {
01f4895c 487 switch(st->codec->codec_id) {
ccd39ae6
FB
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:
4934884a 493 case CODEC_ID_H264:
57004ff1 494 st->need_parsing = AVSTREAM_PARSE_FULL;
ccd39ae6
FB
495 break;
496 default:
497 break;
498 }
8b1ab7bf 499 }
dbf30963
T
500 // needed to send back RTCP RR in RTSP sessions
501 s->rtp_ctx = rtpc;
502 gethostname(s->hostname, sizeof(s->hostname));
8b1ab7bf
FB
503 return s;
504}
505
d1ccf0e0
RD
506static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
507{
d1ccf0e0
RD
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
d1ccf0e0
RD
517 /* decode the first 2 bytes where are stored the AUHeader sections
518 length in bits */
fead30d4 519 au_headers_length = AV_RB16(buf);
d1ccf0e0
RD
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)
755bfeab 540 In my test, the FAAD decoder does not behave correctly when sending each AU one by one
d1ccf0e0
RD
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
8b1ab7bf 554/**
d0deedcb
RM
555 * This was the second switch in rtp_parse packet. Normalizes time, if required, sets stream_index, etc.
556 */
557static 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;
cbee7a69 575 case CODEC_ID_AAC:
d0deedcb
RM
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/**
115329f1 588 * Parse an RTP or RTCP packet directly sent as a buffer.
8b1ab7bf 589 * @param s RTP parse context.
e309128f 590 * @param pkt returned packet
8b1ab7bf 591 * @param buf input buffer or NULL to read the next packets
e309128f 592 * @param len buffer len
115329f1 593 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
8b1ab7bf 594 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
e309128f 595 */
115329f1 596int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
8b1ab7bf 597 const uint8_t *buf, int len)
e309128f 598{
e309128f 599 unsigned int ssrc, h;
d0deedcb 600 int payload_type, seq, ret;
e309128f 601 AVStream *st;
0c1a9eda 602 uint32_t timestamp;
d0deedcb 603 int rv= 0;
115329f1 604
8b1ab7bf
FB
605 if (!buf) {
606 /* return the next packets, if any */
4934884a 607 if(s->st && s->parse_packet) {
d0deedcb
RM
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;
4934884a 612 } else {
d0deedcb 613 // TODO: Move to a dynamic packet handler (like above)
ed787542
RM
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;
4934884a 625 }
8b1ab7bf
FB
626 }
627
e309128f
FB
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) {
8b1ab7bf 634 rtcp_parse_packet(s, buf, len);
e309128f
FB
635 return -1;
636 }
637 payload_type = buf[1] & 0x7f;
80fb8234 638 seq = AV_RB16(buf + 2);
48961970
RB
639 timestamp = AV_RB32(buf + 4);
640 ssrc = AV_RB32(buf + 8);
dbf30963
T
641 /* store the ssrc in the RTPDemuxContext */
642 s->ssrc = ssrc;
115329f1 643
e309128f
FB
644 /* NOTE: we can handle only one payload type */
645 if (s->payload_type != payload_type)
646 return -1;
7581c5f5
FR
647
648 st = s->st;
4a6cc061
RM
649 // only do something with this if all the rtp checks pass...
650 if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
651 {
7581c5f5 652 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
e309128f 653 payload_type, seq, ((s->seq + 1) & 0xffff));
4a6cc061 654 return -1;
e309128f 655 }
4a6cc061 656
d1ccf0e0 657 s->seq = seq;
e309128f
FB
658 len -= 12;
659 buf += 12;
8b1ab7bf 660
8b1ab7bf
FB
661 if (!st) {
662 /* specific MPEG2TS demux support */
663 ret = mpegts_parse_packet(s->ts, pkt, buf, len);
664 if (ret < 0)
e309128f 665 return -1;
8b1ab7bf
FB
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 {
4934884a 673 // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise.
01f4895c 674 switch(st->codec->codec_id) {
8b1ab7bf
FB
675 case CODEC_ID_MP2:
676 /* better than nothing: skip mpeg audio RTP header */
677 if (len <= 4)
678 return -1;
48961970 679 h = AV_RB32(buf);
8b1ab7bf
FB
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:
ccd39ae6 686 /* better than nothing: skip mpeg video RTP header */
e309128f
FB
687 if (len <= 4)
688 return -1;
48961970 689 h = AV_RB32(buf);
e309128f
FB
690 buf += 4;
691 len -= 4;
8b1ab7bf
FB
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;
d8372330
RM
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...
cbee7a69 705 case CODEC_ID_AAC:
d8372330
RM
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;
d0deedcb 723 rv= 0;
d8372330 724 break;
8b1ab7bf 725 default:
4934884a 726 if(s->parse_packet) {
d0deedcb 727 rv= s->parse_packet(s, pkt, &timestamp, buf, len);
4934884a 728 } else {
ed787542
RM
729 av_new_packet(pkt, len);
730 memcpy(pkt->data, buf, len);
4934884a 731 }
8b1ab7bf 732 break;
e309128f 733 }
115329f1 734
d0deedcb
RM
735 // now perform timestamp things....
736 finalize_packet(s, pkt, timestamp);
e309128f 737 }
d0deedcb 738 return rv;
e309128f
FB
739}
740
8b1ab7bf 741void rtp_parse_close(RTPDemuxContext *s)
e309128f 742{
4934884a 743 // TODO: fold this into the protocol specific data fields.
7ed19d7f 744 if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
8b1ab7bf 745 mpegts_parse_close(s->ts);
e309128f 746 }
8b1ab7bf 747 av_free(s);
e309128f
FB
748}
749
750/* rtp output */
751
752static int rtp_write_header(AVFormatContext *s1)
753{
8b1ab7bf
FB
754 RTPDemuxContext *s = s1->priv_data;
755 int payload_type, max_packet_size, n;
e309128f
FB
756 AVStream *st;
757
758 if (s1->nb_streams != 1)
759 return -1;
760 st = s1->streams[0];
761
01f4895c 762 payload_type = rtp_get_payload_type(st->codec);
e309128f 763 if (payload_type < 0)
65e70450 764 payload_type = RTP_PT_PRIVATE; /* private payload type */
e309128f
FB
765 s->payload_type = payload_type;
766
ac2750ec 767// following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
f8801993 768 s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
e309128f 769 s->timestamp = s->base_timestamp;
af74c95a 770 s->cur_timestamp = 0;
f8801993 771 s->ssrc = 0; /* FIXME: was random(), what should this be? */
e309128f 772 s->first_packet = 1;
1b31b02e 773 s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
e309128f
FB
774
775 max_packet_size = url_fget_max_packet_size(&s1->pb);
776 if (max_packet_size <= 12)
6f3e0b21 777 return AVERROR(EIO);
e309128f
FB
778 s->max_payload_size = max_packet_size - 12;
779
e0d21bfe
LA
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
af74c95a 795 av_set_pts_info(st, 32, 1, 90000);
01f4895c 796 switch(st->codec->codec_id) {
e309128f 797 case CODEC_ID_MP2:
80783dc2 798 case CODEC_ID_MP3:
e309128f 799 s->buf_ptr = s->buf + 4;
e309128f
FB
800 break;
801 case CODEC_ID_MPEG1VIDEO:
e309128f 802 break;
8b1ab7bf
FB
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;
171dce48
LA
810 case CODEC_ID_AAC:
811 s->read_buf_index = 0;
e309128f 812 default:
1b31b02e
LA
813 if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
814 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
815 }
e309128f
FB
816 s->buf_ptr = s->buf;
817 break;
818 }
819
820 return 0;
821}
822
823/* send an rtcp sender report packet */
0c1a9eda 824static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
e309128f 825{
8b1ab7bf 826 RTPDemuxContext *s = s1->priv_data;
1b31b02e
LA
827 uint32_t rtp_ts;
828
e309128f 829#if defined(DEBUG)
949b1a13 830 printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
e309128f 831#endif
1b31b02e
LA
832
833 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
18c05a37 834 s->last_rtcp_ntp_time = ntp_time;
1b31b02e
LA
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;
e309128f
FB
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);
1b31b02e
LA
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);
e309128f
FB
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 */
98561024 851void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
e309128f 852{
8b1ab7bf 853 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
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));
00364063 861 put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
e309128f
FB
862 put_be16(&s1->pb, s->seq);
863 put_be32(&s1->pb, s->timestamp);
864 put_be32(&s1->pb, s->ssrc);
115329f1 865
e309128f
FB
866 put_buffer(&s1->pb, buf1, len);
867 put_flush_packet(&s1->pb);
115329f1 868
e309128f
FB
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. */
876static void rtp_send_samples(AVFormatContext *s1,
49057904 877 const uint8_t *buf1, int size, int sample_size)
e309128f 878{
8b1ab7bf 879 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
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();
af74c95a 886 n = 0;
e309128f 887 while (size > 0) {
af74c95a
LA
888 s->buf_ptr = s->buf;
889 len = FFMIN(max_packet_size, size);
e309128f
FB
890
891 /* copy data */
892 memcpy(s->buf_ptr, buf1, len);
893 s->buf_ptr += len;
894 buf1 += len;
895 size -= len;
af74c95a
LA
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);
e309128f 899 }
115329f1 900}
e309128f
FB
901
902/* NOTE: we suppose that exactly one frame is given as argument here */
903/* XXX: test it */
904static void rtp_send_mpegaudio(AVFormatContext *s1,
49057904 905 const uint8_t *buf1, int size)
e309128f 906{
8b1ab7bf 907 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
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) {
98561024 916 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
e309128f 917 s->buf_ptr = s->buf + 4;
e309128f
FB
918 }
919 }
af74c95a
LA
920 if (s->buf_ptr == s->buf + 4) {
921 s->timestamp = s->cur_timestamp;
922 }
e309128f
FB
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);
98561024 938 ff_rtp_send_data(s1, s->buf, len + 4, 0);
e309128f
FB
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 }
e309128f
FB
954}
955
65e70450 956static void rtp_send_raw(AVFormatContext *s1,
49057904 957 const uint8_t *buf1, int size)
65e70450 958{
8b1ab7bf 959 RTPDemuxContext *s = s1->priv_data;
65e70450
FB
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
af74c95a 969 s->timestamp = s->cur_timestamp;
98561024 970 ff_rtp_send_data(s1, buf1, len, (len == size));
65e70450
FB
971
972 buf1 += len;
973 size -= len;
974 }
65e70450
FB
975}
976
8b1ab7bf
FB
977/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
978static 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;
115329f1 992
8b1ab7bf
FB
993 out_len = s->buf_ptr - s->buf;
994 if (out_len >= s->max_payload_size) {
98561024 995 ff_rtp_send_data(s1, s->buf, out_len, 0);
8b1ab7bf
FB
996 s->buf_ptr = s->buf;
997 }
998 }
999}
1000
e309128f 1001/* write an RTP packet. 'buf1' must contain a single specific frame. */
e928649b 1002static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
e309128f 1003{
8b1ab7bf 1004 RTPDemuxContext *s = s1->priv_data;
e309128f
FB
1005 AVStream *st = s1->streams[0];
1006 int rtcp_bytes;
e928649b
MN
1007 int size= pkt->size;
1008 uint8_t *buf1= pkt->data;
115329f1 1009
e309128f 1010#ifdef DEBUG
e928649b 1011 printf("%d: write len=%d\n", pkt->stream_index, size);
e309128f
FB
1012#endif
1013
1014 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
115329f1 1015 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
e309128f 1016 RTCP_TX_RATIO_DEN;
18c05a37
LA
1017 if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
1018 (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
1b31b02e 1019 rtcp_send_sr(s1, av_gettime());
e309128f
FB
1020 s->last_octet_count = s->octet_count;
1021 s->first_packet = 0;
1022 }
af74c95a 1023 s->cur_timestamp = s->base_timestamp + pkt->pts;
e309128f 1024
01f4895c 1025 switch(st->codec->codec_id) {
e309128f
FB
1026 case CODEC_ID_PCM_MULAW:
1027 case CODEC_ID_PCM_ALAW:
1028 case CODEC_ID_PCM_U8:
1029 case CODEC_ID_PCM_S8:
01f4895c 1030 rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
e309128f
FB
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:
01f4895c 1036 rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
e309128f
FB
1037 break;
1038 case CODEC_ID_MP2:
80783dc2 1039 case CODEC_ID_MP3:
e309128f
FB
1040 rtp_send_mpegaudio(s1, buf1, size);
1041 break;
1042 case CODEC_ID_MPEG1VIDEO:
98561024 1043 ff_rtp_send_mpegvideo(s1, buf1, size);
e309128f 1044 break;
171dce48
LA
1045 case CODEC_ID_AAC:
1046 ff_rtp_send_aac(s1, buf1, size);
1047 break;
8b1ab7bf
FB
1048 case CODEC_ID_MPEG2TS:
1049 rtp_send_mpegts_raw(s1, buf1, size);
1050 break;
e309128f 1051 default:
65e70450
FB
1052 /* better than nothing : send the codec raw data */
1053 rtp_send_raw(s1, buf1, size);
1054 break;
e309128f
FB
1055 }
1056 return 0;
1057}
1058
d2a067d1 1059AVOutputFormat rtp_muxer = {
e309128f
FB
1060 "rtp",
1061 "RTP output format",
1062 NULL,
1063 NULL,
8b1ab7bf 1064 sizeof(RTPDemuxContext),
e309128f
FB
1065 CODEC_ID_PCM_MULAW,
1066 CODEC_ID_NONE,
1067 rtp_write_header,
1068 rtp_write_packet,
e309128f 1069};