vorbisdec: read the previous window flag for long windows
[libav.git] / libavformat / rtpdec.c
CommitLineData
8eb793c4
LA
1/*
2 * RTP input format
406792e7 3 * Copyright (c) 2002 Fabrice Bellard
8eb793c4 4 *
2912e87a 5 * This file is part of Libav.
8eb793c4 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
8eb793c4
LA
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 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
8eb793c4
LA
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
8eb793c4
LA
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
245976da 21
0ebcdf5c 22#include "libavutil/mathematics.h"
bb3244de 23#include "libavutil/avstring.h"
9106a698 24#include "libavcodec/get_bits.h"
8eb793c4
LA
25#include "avformat.h"
26#include "mpegts.h"
925e908b 27#include "url.h"
8eb793c4
LA
28
29#include <unistd.h>
30#include "network.h"
31
302879cb 32#include "rtpdec.h"
965a3ddb 33#include "rtpdec_formats.h"
8eb793c4
LA
34
35//#define DEBUG
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
403ee835 43 'ffio_open_dyn_packet_buf')
8eb793c4
LA
44*/
45
69ad22c7 46static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {
2eeefe20
MS
47 .enc_name = "X-MP3-draft-00",
48 .codec_type = AVMEDIA_TYPE_AUDIO,
49 .codec_id = CODEC_ID_MP3ADU,
50};
51
8eb793c4 52/* statistics functions */
119cc033 53static RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
8eb793c4 54
0369d2b0 55void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
8eb793c4
LA
56{
57 handler->next= RTPFirstDynamicPayloadHandler;
58 RTPFirstDynamicPayloadHandler= handler;
59}
60
61void av_register_rtp_dynamic_payload_handlers(void)
62{
9b3788ef
JA
63 ff_register_dynamic_payload_handler(&ff_mp4v_es_dynamic_handler);
64 ff_register_dynamic_payload_handler(&ff_mpeg4_generic_dynamic_handler);
556aa7a1
RB
65 ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler);
66 ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler);
45aa9080
RB
67 ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler);
68 ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler);
08bddfcd 69 ff_register_dynamic_payload_handler(&ff_h263_rfc2190_dynamic_handler);
0369d2b0 70 ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
e6327fba 71 ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
887af2aa 72 ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
a59096e4 73 ff_register_dynamic_payload_handler(&ff_qdm2_dynamic_handler);
4449df6b 74 ff_register_dynamic_payload_handler(&ff_svq3_dynamic_handler);
1ddc176e 75 ff_register_dynamic_payload_handler(&ff_mp4a_latm_dynamic_handler);
51291e60 76 ff_register_dynamic_payload_handler(&ff_vp8_dynamic_handler);
35014efc 77 ff_register_dynamic_payload_handler(&ff_qcelp_dynamic_handler);
2eeefe20 78 ff_register_dynamic_payload_handler(&ff_realmedia_mp3_dynamic_handler);
e9fce261
RB
79
80 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
81 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
3ece3e4c
MS
82
83 ff_register_dynamic_payload_handler(&ff_qt_rtp_aud_handler);
84 ff_register_dynamic_payload_handler(&ff_qt_rtp_vid_handler);
85 ff_register_dynamic_payload_handler(&ff_quicktime_rtp_aud_handler);
86 ff_register_dynamic_payload_handler(&ff_quicktime_rtp_vid_handler);
06d7325a
MS
87
88 ff_register_dynamic_payload_handler(&ff_g726_16_dynamic_handler);
89 ff_register_dynamic_payload_handler(&ff_g726_24_dynamic_handler);
90 ff_register_dynamic_payload_handler(&ff_g726_32_dynamic_handler);
91 ff_register_dynamic_payload_handler(&ff_g726_40_dynamic_handler);
8eb793c4
LA
92}
93
1e515c42
MS
94RTPDynamicProtocolHandler *ff_rtp_handler_find_by_name(const char *name,
95 enum AVMediaType codec_type)
96{
97 RTPDynamicProtocolHandler *handler;
98 for (handler = RTPFirstDynamicPayloadHandler;
99 handler; handler = handler->next)
bb3244de 100 if (!av_strcasecmp(name, handler->enc_name) &&
1e515c42
MS
101 codec_type == handler->codec_type)
102 return handler;
103 return NULL;
104}
105
106RTPDynamicProtocolHandler *ff_rtp_handler_find_by_id(int id,
107 enum AVMediaType codec_type)
108{
109 RTPDynamicProtocolHandler *handler;
110 for (handler = RTPFirstDynamicPayloadHandler;
111 handler; handler = handler->next)
112 if (handler->static_payload_id && handler->static_payload_id == id &&
113 codec_type == handler->codec_type)
114 return handler;
115 return NULL;
116}
117
8eb793c4
LA
118static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
119{
ff328c02 120 int payload_len;
07b77fe3
JB
121 while (len >= 4) {
122 payload_len = FFMIN(len, (AV_RB16(buf + 2) + 1) * 4);
123
ff328c02
JA
124 switch (buf[1]) {
125 case RTCP_SR:
07b77fe3 126 if (payload_len < 20) {
ff328c02
JA
127 av_log(NULL, AV_LOG_ERROR, "Invalid length for RTCP SR packet\n");
128 return AVERROR_INVALIDDATA;
129 }
ff328c02 130
682d28a9 131 s->last_rtcp_ntp_time = AV_RB64(buf + 8);
682d28a9 132 s->last_rtcp_timestamp = AV_RB32(buf + 16);
3a1cdcc7
MS
133 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
134 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
135 if (!s->base_timestamp)
136 s->base_timestamp = s->last_rtcp_timestamp;
137 s->rtcp_ts_offset = s->last_rtcp_timestamp - s->base_timestamp;
138 }
ff328c02 139
ff328c02 140 break;
b20359f5
JA
141 case RTCP_BYE:
142 return -RTCP_BYE;
ff328c02 143 }
07b77fe3
JB
144
145 buf += payload_len;
146 len -= payload_len;
ff328c02 147 }
b20359f5 148 return -1;
8eb793c4
LA
149}
150
151#define RTP_SEQ_MOD (1<<16)
152
153/**
154* called on parse open packet
155*/
156static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
157{
158 memset(s, 0, sizeof(RTPStatistics));
159 s->max_seq= base_sequence;
160 s->probation= 1;
161}
162
163/**
164* called whenever there is a large jump in sequence numbers, or when they get out of probation...
165*/
166static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
167{
168 s->max_seq= seq;
169 s->cycles= 0;
170 s->base_seq= seq -1;
171 s->bad_seq= RTP_SEQ_MOD + 1;
172 s->received= 0;
173 s->expected_prior= 0;
174 s->received_prior= 0;
175 s->jitter= 0;
176 s->transit= 0;
177}
178
179/**
180* returns 1 if we should handle this packet.
181*/
182static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
183{
184 uint16_t udelta= seq - s->max_seq;
185 const int MAX_DROPOUT= 3000;
186 const int MAX_MISORDER = 100;
187 const int MIN_SEQUENTIAL = 2;
188
189 /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
190 if(s->probation)
191 {
192 if(seq==s->max_seq + 1) {
193 s->probation--;
194 s->max_seq= seq;
195 if(s->probation==0) {
196 rtp_init_sequence(s, seq);
197 s->received++;
198 return 1;
199 }
200 } else {
201 s->probation= MIN_SEQUENTIAL - 1;
202 s->max_seq = seq;
203 }
204 } else if (udelta < MAX_DROPOUT) {
205 // in order, with permissible gap
206 if(seq < s->max_seq) {
207 //sequence number wrapped; count antother 64k cycles
208 s->cycles += RTP_SEQ_MOD;
209 }
210 s->max_seq= seq;
211 } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
212 // sequence made a large jump...
213 if(seq==s->bad_seq) {
214 // two sequential packets-- assume that the other side restarted without telling us; just resync.
215 rtp_init_sequence(s, seq);
216 } else {
217 s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
218 return 0;
219 }
220 } else {
221 // duplicate or reordered packet...
222 }
223 s->received++;
224 return 1;
225}
226
bfc6db44 227int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
8eb793c4 228{
ae628ec1 229 AVIOContext *pb;
8eb793c4
LA
230 uint8_t *buf;
231 int len;
232 int rtcp_bytes;
233 RTPStatistics *stats= &s->statistics;
234 uint32_t lost;
235 uint32_t extended_max;
236 uint32_t expected_interval;
237 uint32_t received_interval;
238 uint32_t lost_interval;
239 uint32_t expected;
240 uint32_t fraction;
241 uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
242
243 if (!s->rtp_ctx || (count < 1))
244 return -1;
245
246 /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
247 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
248 s->octet_count += count;
249 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
250 RTCP_TX_RATIO_DEN;
251 rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
252 if (rtcp_bytes < 28)
253 return -1;
254 s->last_octet_count = s->octet_count;
255
b92c5452 256 if (avio_open_dyn_buf(&pb) < 0)
8eb793c4
LA
257 return -1;
258
259 // Receiver Report
77eb5504
AK
260 avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
261 avio_w8(pb, RTCP_RR);
262 avio_wb16(pb, 7); /* length in words - 1 */
952139a3 263 // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
77eb5504
AK
264 avio_wb32(pb, s->ssrc + 1);
265 avio_wb32(pb, s->ssrc); // server SSRC
8eb793c4
LA
266 // some placeholders we should really fill...
267 // RFC 1889/p64
268 extended_max= stats->cycles + stats->max_seq;
269 expected= extended_max - stats->base_seq + 1;
270 lost= expected - stats->received;
271 lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
272 expected_interval= expected - stats->expected_prior;
273 stats->expected_prior= expected;
274 received_interval= stats->received - stats->received_prior;
275 stats->received_prior= stats->received;
276 lost_interval= expected_interval - received_interval;
277 if (expected_interval==0 || lost_interval<=0) fraction= 0;
278 else fraction = (lost_interval<<8)/expected_interval;
279
280 fraction= (fraction<<24) | lost;
281
77eb5504
AK
282 avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
283 avio_wb32(pb, extended_max); /* max sequence received */
284 avio_wb32(pb, stats->jitter>>4); /* jitter */
8eb793c4
LA
285
286 if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
287 {
77eb5504
AK
288 avio_wb32(pb, 0); /* last SR timestamp */
289 avio_wb32(pb, 0); /* delay since last SR */
8eb793c4
LA
290 } else {
291 uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
292 uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
293
77eb5504
AK
294 avio_wb32(pb, middle_32_bits); /* last SR timestamp */
295 avio_wb32(pb, delay_since_last); /* delay since last SR */
8eb793c4
LA
296 }
297
298 // CNAME
77eb5504
AK
299 avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
300 avio_w8(pb, RTCP_SDES);
8eb793c4 301 len = strlen(s->hostname);
77eb5504 302 avio_wb16(pb, (6 + len + 3) / 4); /* length in words - 1 */
ad7beb2c 303 avio_wb32(pb, s->ssrc + 1);
77eb5504
AK
304 avio_w8(pb, 0x01);
305 avio_w8(pb, len);
306 avio_write(pb, s->hostname, len);
8eb793c4
LA
307 // padding
308 for (len = (6 + len) % 4; len % 4; len++) {
77eb5504 309 avio_w8(pb, 0);
8eb793c4
LA
310 }
311
b7f2fdde 312 avio_flush(pb);
6dc7d80d 313 len = avio_close_dyn_buf(pb, &buf);
8eb793c4 314 if ((len > 0) && buf) {
5e1166b3 315 int av_unused result;
dfd2a005 316 av_dlog(s->ic, "sending %d bytes of RR\n", len);
925e908b
AK
317 result= ffurl_write(s->rtp_ctx, buf, len);
318 av_dlog(s->ic, "result from ffurl_write: %d\n", result);
8eb793c4
LA
319 av_free(buf);
320 }
321 return 0;
322}
323
bfc6db44 324void ff_rtp_send_punch_packets(URLContext* rtp_handle)
9c8fa20d 325{
ae628ec1 326 AVIOContext *pb;
9c8fa20d
MS
327 uint8_t *buf;
328 int len;
329
330 /* Send a small RTP packet */
b92c5452 331 if (avio_open_dyn_buf(&pb) < 0)
9c8fa20d
MS
332 return;
333
77eb5504
AK
334 avio_w8(pb, (RTP_VERSION << 6));
335 avio_w8(pb, 0); /* Payload type */
336 avio_wb16(pb, 0); /* Seq */
337 avio_wb32(pb, 0); /* Timestamp */
338 avio_wb32(pb, 0); /* SSRC */
9c8fa20d 339
b7f2fdde 340 avio_flush(pb);
6dc7d80d 341 len = avio_close_dyn_buf(pb, &buf);
9c8fa20d 342 if ((len > 0) && buf)
925e908b 343 ffurl_write(rtp_handle, buf, len);
9c8fa20d
MS
344 av_free(buf);
345
346 /* Send a minimal RTCP RR */
b92c5452 347 if (avio_open_dyn_buf(&pb) < 0)
9c8fa20d
MS
348 return;
349
77eb5504
AK
350 avio_w8(pb, (RTP_VERSION << 6));
351 avio_w8(pb, RTCP_RR); /* receiver report */
352 avio_wb16(pb, 1); /* length in words - 1 */
353 avio_wb32(pb, 0); /* our own SSRC */
9c8fa20d 354
b7f2fdde 355 avio_flush(pb);
6dc7d80d 356 len = avio_close_dyn_buf(pb, &buf);
9c8fa20d 357 if ((len > 0) && buf)
925e908b 358 ffurl_write(rtp_handle, buf, len);
9c8fa20d
MS
359 av_free(buf);
360}
361
362
8eb793c4
LA
363/**
364 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
365 * MPEG2TS streams to indicate that they should be demuxed inside the
366 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
8eb793c4 367 */
bfc6db44 368RTPDemuxContext *ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, int queue_size)
8eb793c4
LA
369{
370 RTPDemuxContext *s;
371
372 s = av_mallocz(sizeof(RTPDemuxContext));
373 if (!s)
374 return NULL;
375 s->payload_type = payload_type;
376 s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
2cab6b48 377 s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
8eb793c4
LA
378 s->ic = s1;
379 s->st = st;
58ee0991 380 s->queue_size = queue_size;
8eb793c4
LA
381 rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
382 if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
9125806e 383 s->ts = ff_mpegts_parse_open(s->ic);
8eb793c4
LA
384 if (s->ts == NULL) {
385 av_free(s);
386 return NULL;
387 }
388 } else {
389 switch(st->codec->codec_id) {
390 case CODEC_ID_MPEG1VIDEO:
391 case CODEC_ID_MPEG2VIDEO:
392 case CODEC_ID_MP2:
393 case CODEC_ID_MP3:
394 case CODEC_ID_MPEG4:
45aa9080 395 case CODEC_ID_H263:
8eb793c4
LA
396 case CODEC_ID_H264:
397 st->need_parsing = AVSTREAM_PARSE_FULL;
398 break;
0048a2a8 399 case CODEC_ID_ADPCM_G722:
0048a2a8
MS
400 /* According to RFC 3551, the stream clock rate is 8000
401 * even if the sample rate is 16000. */
402 if (st->codec->sample_rate == 8000)
403 st->codec->sample_rate = 16000;
404 break;
8eb793c4
LA
405 default:
406 break;
407 }
408 }
409 // needed to send back RTCP RR in RTSP sessions
410 s->rtp_ctx = rtpc;
411 gethostname(s->hostname, sizeof(s->hostname));
412 return s;
413}
414
99a1d191 415void
bfc6db44
MS
416ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
417 RTPDynamicProtocolHandler *handler)
99a1d191
RB
418{
419 s->dynamic_protocol_context = ctx;
420 s->parse_packet = handler->parse_packet;
421}
422
8eb793c4
LA
423/**
424 * This was the second switch in rtp_parse packet. Normalizes time, if required, sets stream_index, etc.
425 */
426static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
427{
79d482b1
MS
428 if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE)
429 return; /* Timestamp already set by depacketizer */
b8a1b880
JB
430 if (timestamp == RTP_NOTS_VALUE)
431 return;
432
525c5b08 433 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE && s->ic->nb_streams > 1) {
fba7815d
LA
434 int64_t addend;
435 int delta_timestamp;
436
437 /* compute pts from timestamp with received ntp_time */
438 delta_timestamp = timestamp - s->last_rtcp_timestamp;
439 /* convert to the PTS timebase */
2cab6b48 440 addend = av_rescale(s->last_rtcp_ntp_time - s->first_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
3a1cdcc7
MS
441 pkt->pts = s->range_start_offset + s->rtcp_ts_offset + addend +
442 delta_timestamp;
443 return;
fba7815d 444 }
b8a1b880 445
3a1cdcc7
MS
446 if (!s->base_timestamp)
447 s->base_timestamp = timestamp;
12348ca2
JB
448 /* assume that the difference is INT32_MIN < x < INT32_MAX, but allow the first timestamp to exceed INT32_MAX */
449 if (!s->timestamp)
450 s->unwrapped_timestamp += timestamp;
451 else
452 s->unwrapped_timestamp += (int32_t)(timestamp - s->timestamp);
453 s->timestamp = timestamp;
454 pkt->pts = s->unwrapped_timestamp + s->range_start_offset - s->base_timestamp;
8eb793c4
LA
455}
456
02607418
MS
457static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt,
458 const uint8_t *buf, int len)
8eb793c4
LA
459{
460 unsigned int ssrc, h;
f841a0fc 461 int payload_type, seq, ret, flags = 0;
9446b4bb 462 int ext;
8eb793c4
LA
463 AVStream *st;
464 uint32_t timestamp;
465 int rv= 0;
466
9446b4bb 467 ext = buf[0] & 0x10;
8eb793c4 468 payload_type = buf[1] & 0x7f;
144ae29d
RB
469 if (buf[1] & 0x80)
470 flags |= RTP_FLAG_MARKER;
8eb793c4
LA
471 seq = AV_RB16(buf + 2);
472 timestamp = AV_RB32(buf + 4);
473 ssrc = AV_RB32(buf + 8);
474 /* store the ssrc in the RTPDemuxContext */
475 s->ssrc = ssrc;
476
477 /* NOTE: we can handle only one payload type */
478 if (s->payload_type != payload_type)
479 return -1;
480
481 st = s->st;
482 // only do something with this if all the rtp checks pass...
483 if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
484 {
485 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
486 payload_type, seq, ((s->seq + 1) & 0xffff));
487 return -1;
488 }
489
4838cdab
MS
490 if (buf[0] & 0x20) {
491 int padding = buf[len - 1];
492 if (len >= 12 + padding)
493 len -= padding;
494 }
495
8eb793c4
LA
496 s->seq = seq;
497 len -= 12;
498 buf += 12;
499
9446b4bb
RS
500 /* RFC 3550 Section 5.3.1 RTP Header Extension handling */
501 if (ext) {
502 if (len < 4)
503 return -1;
504 /* calculate the header extension length (stored as number
505 * of 32-bit words) */
506 ext = (AV_RB16(buf + 2) + 1) << 2;
507
508 if (len < ext)
509 return -1;
510 // skip past RTP header extension
511 len -= ext;
512 buf += ext;
513 }
514
8eb793c4
LA
515 if (!st) {
516 /* specific MPEG2TS demux support */
9125806e 517 ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
946df059
MS
518 /* The only error that can be returned from ff_mpegts_parse_packet
519 * is "no more data to return from the provided buffer", so return
520 * AVERROR(EAGAIN) for all errors */
4ffff367 521 if (ret < 0)
946df059 522 return AVERROR(EAGAIN);
8eb793c4
LA
523 if (ret < len) {
524 s->read_buf_size = len - ret;
525 memcpy(s->buf, buf + ret, s->read_buf_size);
526 s->read_buf_index = 0;
527 return 1;
528 }
f3e71942 529 return 0;
b4e3330c 530 } else if (s->parse_packet) {
1a45a9f4 531 rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
9b932b8a 532 s->st, pkt, &timestamp, buf, len, flags);
8eb793c4
LA
533 } else {
534 // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise.
535 switch(st->codec->codec_id) {
536 case CODEC_ID_MP2:
76faff6e 537 case CODEC_ID_MP3:
8eb793c4
LA
538 /* better than nothing: skip mpeg audio RTP header */
539 if (len <= 4)
540 return -1;
541 h = AV_RB32(buf);
542 len -= 4;
543 buf += 4;
544 av_new_packet(pkt, len);
545 memcpy(pkt->data, buf, len);
546 break;
547 case CODEC_ID_MPEG1VIDEO:
548 case CODEC_ID_MPEG2VIDEO:
549 /* better than nothing: skip mpeg video RTP header */
550 if (len <= 4)
551 return -1;
552 h = AV_RB32(buf);
553 buf += 4;
554 len -= 4;
555 if (h & (1 << 26)) {
556 /* mpeg2 */
557 if (len <= 4)
558 return -1;
559 buf += 4;
560 len -= 4;
561 }
562 av_new_packet(pkt, len);
563 memcpy(pkt->data, buf, len);
564 break;
8eb793c4 565 default:
f739b36d
RB
566 av_new_packet(pkt, len);
567 memcpy(pkt->data, buf, len);
8eb793c4
LA
568 break;
569 }
eafb17d1
RB
570
571 pkt->stream_index = st->index;
f3e71942 572 }
8eb793c4 573
95f03cf3
RB
574 // now perform timestamp things....
575 finalize_packet(s, pkt, timestamp);
f3e71942 576
8eb793c4
LA
577 return rv;
578}
579
58ee0991
MS
580void ff_rtp_reset_packet_queue(RTPDemuxContext *s)
581{
582 while (s->queue) {
583 RTPPacket *next = s->queue->next;
584 av_free(s->queue->buf);
585 av_free(s->queue);
586 s->queue = next;
587 }
588 s->seq = 0;
589 s->queue_len = 0;
590 s->prev_ret = 0;
591}
592
593static void enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len)
594{
595 uint16_t seq = AV_RB16(buf + 2);
596 RTPPacket *cur = s->queue, *prev = NULL, *packet;
597
598 /* Find the correct place in the queue to insert the packet */
599 while (cur) {
600 int16_t diff = seq - cur->seq;
601 if (diff < 0)
602 break;
603 prev = cur;
604 cur = cur->next;
605 }
606
607 packet = av_mallocz(sizeof(*packet));
608 if (!packet)
609 return;
610 packet->recvtime = av_gettime();
611 packet->seq = seq;
612 packet->len = len;
613 packet->buf = buf;
614 packet->next = cur;
615 if (prev)
616 prev->next = packet;
617 else
618 s->queue = packet;
619 s->queue_len++;
620}
621
622static int has_next_packet(RTPDemuxContext *s)
623{
ddcf8411 624 return s->queue && s->queue->seq == (uint16_t) (s->seq + 1);
58ee0991
MS
625}
626
627int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
628{
629 return s->queue ? s->queue->recvtime : 0;
630}
631
632static int rtp_parse_queued_packet(RTPDemuxContext *s, AVPacket *pkt)
633{
634 int rv;
635 RTPPacket *next;
636
637 if (s->queue_len <= 0)
638 return -1;
639
640 if (!has_next_packet(s))
641 av_log(s->st ? s->st->codec : NULL, AV_LOG_WARNING,
642 "RTP: missed %d packets\n", s->queue->seq - s->seq - 1);
643
644 /* Parse the first packet in the queue, and dequeue it */
645 rv = rtp_parse_packet_internal(s, pkt, s->queue->buf, s->queue->len);
646 next = s->queue->next;
647 av_free(s->queue->buf);
648 av_free(s->queue);
649 s->queue = next;
650 s->queue_len--;
4ffff367 651 return rv;
58ee0991
MS
652}
653
4ffff367 654static int rtp_parse_one_packet(RTPDemuxContext *s, AVPacket *pkt,
02607418
MS
655 uint8_t **bufptr, int len)
656{
657 uint8_t* buf = bufptr ? *bufptr : NULL;
658 int ret, flags = 0;
659 uint32_t timestamp;
660 int rv= 0;
661
662 if (!buf) {
f6e138b4
MS
663 /* If parsing of the previous packet actually returned 0 or an error,
664 * there's nothing more to be parsed from that packet, but we may have
58ee0991 665 * indicated that we can return the next enqueued packet. */
f6e138b4 666 if (s->prev_ret <= 0)
58ee0991 667 return rtp_parse_queued_packet(s, pkt);
02607418
MS
668 /* return the next packets, if any */
669 if(s->st && s->parse_packet) {
670 /* timestamp should be overwritten by parse_packet, if not,
671 * the packet is left with pts == AV_NOPTS_VALUE */
672 timestamp = RTP_NOTS_VALUE;
673 rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
674 s->st, pkt, &timestamp, NULL, 0, flags);
675 finalize_packet(s, pkt, timestamp);
4ffff367 676 return rv;
02607418
MS
677 } else {
678 // TODO: Move to a dynamic packet handler (like above)
4ffff367 679 if (s->read_buf_index >= s->read_buf_size)
91ec7aea 680 return AVERROR(EAGAIN);
02607418
MS
681 ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
682 s->read_buf_size - s->read_buf_index);
4ffff367 683 if (ret < 0)
946df059 684 return AVERROR(EAGAIN);
02607418
MS
685 s->read_buf_index += ret;
686 if (s->read_buf_index < s->read_buf_size)
687 return 1;
4ffff367
MS
688 else
689 return 0;
02607418
MS
690 }
691 }
692
693 if (len < 12)
694 return -1;
695
696 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
697 return -1;
298a587f 698 if (RTP_PT_IS_RTCP(buf[1])) {
02607418
MS
699 return rtcp_parse_packet(s, buf, len);
700 }
701
65cdee9c 702 if ((s->seq == 0 && !s->queue) || s->queue_size <= 1) {
58ee0991
MS
703 /* First packet, or no reordering */
704 return rtp_parse_packet_internal(s, pkt, buf, len);
705 } else {
706 uint16_t seq = AV_RB16(buf + 2);
707 int16_t diff = seq - s->seq;
708 if (diff < 0) {
709 /* Packet older than the previously emitted one, drop */
710 av_log(s->st ? s->st->codec : NULL, AV_LOG_WARNING,
711 "RTP: dropping old packet received too late\n");
712 return -1;
713 } else if (diff <= 1) {
714 /* Correct packet */
715 rv = rtp_parse_packet_internal(s, pkt, buf, len);
4ffff367 716 return rv;
58ee0991
MS
717 } else {
718 /* Still missing some packet, enqueue this one. */
719 enqueue_packet(s, buf, len);
720 *bufptr = NULL;
721 /* Return the first enqueued packet if the queue is full,
722 * even if we're missing something */
723 if (s->queue_len >= s->queue_size)
724 return rtp_parse_queued_packet(s, pkt);
725 return -1;
726 }
727 }
02607418
MS
728}
729
4ffff367
MS
730/**
731 * Parse an RTP or RTCP packet directly sent as a buffer.
732 * @param s RTP parse context.
733 * @param pkt returned packet
734 * @param bufptr pointer to the input buffer or NULL to read the next packets
735 * @param len buffer len
736 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
737 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
738 */
bfc6db44
MS
739int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
740 uint8_t **bufptr, int len)
4ffff367
MS
741{
742 int rv = rtp_parse_one_packet(s, pkt, bufptr, len);
743 s->prev_ret = rv;
d678a6fd
MS
744 while (rv == AVERROR(EAGAIN) && has_next_packet(s))
745 rv = rtp_parse_queued_packet(s, pkt);
4ffff367
MS
746 return rv ? rv : has_next_packet(s);
747}
748
bfc6db44 749void ff_rtp_parse_close(RTPDemuxContext *s)
8eb793c4 750{
58ee0991 751 ff_rtp_reset_packet_queue(s);
8eb793c4 752 if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
9125806e 753 ff_mpegts_parse_close(s->ts);
8eb793c4
LA
754 }
755 av_free(s);
756}
016bc031
JA
757
758int ff_parse_fmtp(AVStream *stream, PayloadContext *data, const char *p,
759 int (*parse_fmtp)(AVStream *stream,
760 PayloadContext *data,
761 char *attr, char *value))
762{
763 char attr[256];
824535e3 764 char *value;
016bc031 765 int res;
824535e3
JA
766 int value_size = strlen(p) + 1;
767
768 if (!(value = av_malloc(value_size))) {
769 av_log(stream, AV_LOG_ERROR, "Failed to allocate data for FMTP.");
770 return AVERROR(ENOMEM);
771 }
016bc031
JA
772
773 // remove protocol identifier
774 while (*p && *p == ' ') p++; // strip spaces
775 while (*p && *p != ' ') p++; // eat protocol identifier
776 while (*p && *p == ' ') p++; // strip trailing spaces
777
778 while (ff_rtsp_next_attr_and_value(&p,
779 attr, sizeof(attr),
824535e3 780 value, value_size)) {
016bc031
JA
781
782 res = parse_fmtp(stream, data, attr, value);
824535e3
JA
783 if (res < 0 && res != AVERROR_PATCHWELCOME) {
784 av_free(value);
016bc031 785 return res;
824535e3 786 }
016bc031 787 }
824535e3 788 av_free(value);
016bc031
JA
789 return 0;
790}