3 * Copyright (c) 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/mathematics.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/time.h"
25 #include "libavcodec/get_bits.h"
31 #include "rtpdec_formats.h"
33 #define MIN_FEEDBACK_INTERVAL 200000 /* 200 ms in us */
35 static RTPDynamicProtocolHandler gsm_dynamic_handler
= {
37 .codec_type
= AVMEDIA_TYPE_AUDIO
,
38 .codec_id
= AV_CODEC_ID_GSM
,
41 static RTPDynamicProtocolHandler realmedia_mp3_dynamic_handler
= {
42 .enc_name
= "X-MP3-draft-00",
43 .codec_type
= AVMEDIA_TYPE_AUDIO
,
44 .codec_id
= AV_CODEC_ID_MP3ADU
,
47 static RTPDynamicProtocolHandler speex_dynamic_handler
= {
49 .codec_type
= AVMEDIA_TYPE_AUDIO
,
50 .codec_id
= AV_CODEC_ID_SPEEX
,
53 static RTPDynamicProtocolHandler opus_dynamic_handler
= {
55 .codec_type
= AVMEDIA_TYPE_AUDIO
,
56 .codec_id
= AV_CODEC_ID_OPUS
,
59 static RTPDynamicProtocolHandler
*rtp_first_dynamic_payload_handler
= NULL
;
61 void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler
*handler
)
63 handler
->next
= rtp_first_dynamic_payload_handler
;
64 rtp_first_dynamic_payload_handler
= handler
;
67 void ff_register_rtp_dynamic_payload_handlers(void)
69 ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler
);
70 ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler
);
71 ff_register_dynamic_payload_handler(&ff_g726_16_dynamic_handler
);
72 ff_register_dynamic_payload_handler(&ff_g726_24_dynamic_handler
);
73 ff_register_dynamic_payload_handler(&ff_g726_32_dynamic_handler
);
74 ff_register_dynamic_payload_handler(&ff_g726_40_dynamic_handler
);
75 ff_register_dynamic_payload_handler(&ff_h261_dynamic_handler
);
76 ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler
);
77 ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler
);
78 ff_register_dynamic_payload_handler(&ff_h263_rfc2190_dynamic_handler
);
79 ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler
);
80 ff_register_dynamic_payload_handler(&ff_h265_dynamic_handler
);
81 ff_register_dynamic_payload_handler(&ff_hevc_dynamic_handler
);
82 ff_register_dynamic_payload_handler(&ff_ilbc_dynamic_handler
);
83 ff_register_dynamic_payload_handler(&ff_jpeg_dynamic_handler
);
84 ff_register_dynamic_payload_handler(&ff_mp4a_latm_dynamic_handler
);
85 ff_register_dynamic_payload_handler(&ff_mp4v_es_dynamic_handler
);
86 ff_register_dynamic_payload_handler(&ff_mpeg_audio_dynamic_handler
);
87 ff_register_dynamic_payload_handler(&ff_mpeg_video_dynamic_handler
);
88 ff_register_dynamic_payload_handler(&ff_mpeg4_generic_dynamic_handler
);
89 ff_register_dynamic_payload_handler(&ff_mpegts_dynamic_handler
);
90 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler
);
91 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler
);
92 ff_register_dynamic_payload_handler(&ff_qcelp_dynamic_handler
);
93 ff_register_dynamic_payload_handler(&ff_qdm2_dynamic_handler
);
94 ff_register_dynamic_payload_handler(&ff_qt_rtp_aud_handler
);
95 ff_register_dynamic_payload_handler(&ff_qt_rtp_vid_handler
);
96 ff_register_dynamic_payload_handler(&ff_quicktime_rtp_aud_handler
);
97 ff_register_dynamic_payload_handler(&ff_quicktime_rtp_vid_handler
);
98 ff_register_dynamic_payload_handler(&ff_svq3_dynamic_handler
);
99 ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler
);
100 ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler
);
101 ff_register_dynamic_payload_handler(&ff_vp8_dynamic_handler
);
102 ff_register_dynamic_payload_handler(&gsm_dynamic_handler
);
103 ff_register_dynamic_payload_handler(&opus_dynamic_handler
);
104 ff_register_dynamic_payload_handler(&realmedia_mp3_dynamic_handler
);
105 ff_register_dynamic_payload_handler(&speex_dynamic_handler
);
108 RTPDynamicProtocolHandler
*ff_rtp_handler_find_by_name(const char *name
,
109 enum AVMediaType codec_type
)
111 RTPDynamicProtocolHandler
*handler
;
112 for (handler
= rtp_first_dynamic_payload_handler
;
113 handler
; handler
= handler
->next
)
114 if (!av_strcasecmp(name
, handler
->enc_name
) &&
115 codec_type
== handler
->codec_type
)
120 RTPDynamicProtocolHandler
*ff_rtp_handler_find_by_id(int id
,
121 enum AVMediaType codec_type
)
123 RTPDynamicProtocolHandler
*handler
;
124 for (handler
= rtp_first_dynamic_payload_handler
;
125 handler
; handler
= handler
->next
)
126 if (handler
->static_payload_id
&& handler
->static_payload_id
== id
&&
127 codec_type
== handler
->codec_type
)
132 static int rtcp_parse_packet(RTPDemuxContext
*s
, const unsigned char *buf
,
137 payload_len
= FFMIN(len
, (AV_RB16(buf
+ 2) + 1) * 4);
141 if (payload_len
< 20) {
142 av_log(NULL
, AV_LOG_ERROR
,
143 "Invalid length for RTCP SR packet\n");
144 return AVERROR_INVALIDDATA
;
147 s
->last_rtcp_reception_time
= av_gettime();
148 s
->last_rtcp_ntp_time
= AV_RB64(buf
+ 8);
149 s
->last_rtcp_timestamp
= AV_RB32(buf
+ 16);
150 if (s
->first_rtcp_ntp_time
== AV_NOPTS_VALUE
) {
151 s
->first_rtcp_ntp_time
= s
->last_rtcp_ntp_time
;
152 if (!s
->base_timestamp
)
153 s
->base_timestamp
= s
->last_rtcp_timestamp
;
154 s
->rtcp_ts_offset
= s
->last_rtcp_timestamp
- s
->base_timestamp
;
168 #define RTP_SEQ_MOD (1 << 16)
170 static void rtp_init_statistics(RTPStatistics
*s
, uint16_t base_sequence
)
172 memset(s
, 0, sizeof(RTPStatistics
));
173 s
->max_seq
= base_sequence
;
178 * Called whenever there is a large jump in sequence numbers,
179 * or when they get out of probation...
181 static void rtp_init_sequence(RTPStatistics
*s
, uint16_t seq
)
185 s
->base_seq
= seq
- 1;
186 s
->bad_seq
= RTP_SEQ_MOD
+ 1;
188 s
->expected_prior
= 0;
189 s
->received_prior
= 0;
194 /* Returns 1 if we should handle this packet. */
195 static int rtp_valid_packet_in_sequence(RTPStatistics
*s
, uint16_t seq
)
197 uint16_t udelta
= seq
- s
->max_seq
;
198 const int MAX_DROPOUT
= 3000;
199 const int MAX_MISORDER
= 100;
200 const int MIN_SEQUENTIAL
= 2;
202 /* source not valid until MIN_SEQUENTIAL packets with sequence
203 * seq. numbers have been received */
205 if (seq
== s
->max_seq
+ 1) {
208 if (s
->probation
== 0) {
209 rtp_init_sequence(s
, seq
);
214 s
->probation
= MIN_SEQUENTIAL
- 1;
217 } else if (udelta
< MAX_DROPOUT
) {
218 // in order, with permissible gap
219 if (seq
< s
->max_seq
) {
220 // sequence number wrapped; count another 64k cycles
221 s
->cycles
+= RTP_SEQ_MOD
;
224 } else if (udelta
<= RTP_SEQ_MOD
- MAX_MISORDER
) {
225 // sequence made a large jump...
226 if (seq
== s
->bad_seq
) {
227 /* two sequential packets -- assume that the other side
228 * restarted without telling us; just resync. */
229 rtp_init_sequence(s
, seq
);
231 s
->bad_seq
= (seq
+ 1) & (RTP_SEQ_MOD
- 1);
235 // duplicate or reordered packet...
241 static void rtcp_update_jitter(RTPStatistics
*s
, uint32_t sent_timestamp
,
242 uint32_t arrival_timestamp
)
244 // Most of this is pretty straight from RFC 3550 appendix A.8
245 uint32_t transit
= arrival_timestamp
- sent_timestamp
;
246 uint32_t prev_transit
= s
->transit
;
247 int32_t d
= transit
- prev_transit
;
248 // Doing the FFABS() call directly on the "transit - prev_transit"
249 // expression doesn't work, since it's an unsigned expression. Doing the
250 // transit calculation in unsigned is desired though, since it most
251 // probably will need to wrap around.
253 s
->transit
= transit
;
256 s
->jitter
+= d
- (int32_t) ((s
->jitter
+ 8) >> 4);
259 int ff_rtp_check_and_send_back_rr(RTPDemuxContext
*s
, URLContext
*fd
,
260 AVIOContext
*avio
, int count
)
266 RTPStatistics
*stats
= &s
->statistics
;
268 uint32_t extended_max
;
269 uint32_t expected_interval
;
270 uint32_t received_interval
;
271 int32_t lost_interval
;
275 if ((!fd
&& !avio
) || (count
< 1))
278 /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
279 /* XXX: MPEG pts hardcoded. RTCP send every 0.5 seconds */
280 s
->octet_count
+= count
;
281 rtcp_bytes
= ((s
->octet_count
- s
->last_octet_count
) * RTCP_TX_RATIO_NUM
) /
283 rtcp_bytes
/= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
286 s
->last_octet_count
= s
->octet_count
;
290 else if (avio_open_dyn_buf(&pb
) < 0)
294 avio_w8(pb
, (RTP_VERSION
<< 6) + 1); /* 1 report block */
295 avio_w8(pb
, RTCP_RR
);
296 avio_wb16(pb
, 7); /* length in words - 1 */
297 // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
298 avio_wb32(pb
, s
->ssrc
+ 1);
299 avio_wb32(pb
, s
->ssrc
); // server SSRC
300 // some placeholders we should really fill...
302 extended_max
= stats
->cycles
+ stats
->max_seq
;
303 expected
= extended_max
- stats
->base_seq
;
304 lost
= expected
- stats
->received
;
305 lost
= FFMIN(lost
, 0xffffff); // clamp it since it's only 24 bits...
306 expected_interval
= expected
- stats
->expected_prior
;
307 stats
->expected_prior
= expected
;
308 received_interval
= stats
->received
- stats
->received_prior
;
309 stats
->received_prior
= stats
->received
;
310 lost_interval
= expected_interval
- received_interval
;
311 if (expected_interval
== 0 || lost_interval
<= 0)
314 fraction
= (lost_interval
<< 8) / expected_interval
;
316 fraction
= (fraction
<< 24) | lost
;
318 avio_wb32(pb
, fraction
); /* 8 bits of fraction, 24 bits of total packets lost */
319 avio_wb32(pb
, extended_max
); /* max sequence received */
320 avio_wb32(pb
, stats
->jitter
>> 4); /* jitter */
322 if (s
->last_rtcp_ntp_time
== AV_NOPTS_VALUE
) {
323 avio_wb32(pb
, 0); /* last SR timestamp */
324 avio_wb32(pb
, 0); /* delay since last SR */
326 uint32_t middle_32_bits
= s
->last_rtcp_ntp_time
>> 16; // this is valid, right? do we need to handle 64 bit values special?
327 uint32_t delay_since_last
= av_rescale(av_gettime() - s
->last_rtcp_reception_time
,
328 65536, AV_TIME_BASE
);
330 avio_wb32(pb
, middle_32_bits
); /* last SR timestamp */
331 avio_wb32(pb
, delay_since_last
); /* delay since last SR */
335 avio_w8(pb
, (RTP_VERSION
<< 6) + 1); /* 1 report block */
336 avio_w8(pb
, RTCP_SDES
);
337 len
= strlen(s
->hostname
);
338 avio_wb16(pb
, (7 + len
+ 3) / 4); /* length in words - 1 */
339 avio_wb32(pb
, s
->ssrc
+ 1);
342 avio_write(pb
, s
->hostname
, len
);
343 avio_w8(pb
, 0); /* END */
345 for (len
= (7 + len
) % 4; len
% 4; len
++)
351 len
= avio_close_dyn_buf(pb
, &buf
);
352 if ((len
> 0) && buf
) {
353 int av_unused result
;
354 av_dlog(s
->ic
, "sending %d bytes of RR\n", len
);
355 result
= ffurl_write(fd
, buf
, len
);
356 av_dlog(s
->ic
, "result from ffurl_write: %d\n", result
);
362 void ff_rtp_send_punch_packets(URLContext
*rtp_handle
)
368 /* Send a small RTP packet */
369 if (avio_open_dyn_buf(&pb
) < 0)
372 avio_w8(pb
, (RTP_VERSION
<< 6));
373 avio_w8(pb
, 0); /* Payload type */
374 avio_wb16(pb
, 0); /* Seq */
375 avio_wb32(pb
, 0); /* Timestamp */
376 avio_wb32(pb
, 0); /* SSRC */
379 len
= avio_close_dyn_buf(pb
, &buf
);
380 if ((len
> 0) && buf
)
381 ffurl_write(rtp_handle
, buf
, len
);
384 /* Send a minimal RTCP RR */
385 if (avio_open_dyn_buf(&pb
) < 0)
388 avio_w8(pb
, (RTP_VERSION
<< 6));
389 avio_w8(pb
, RTCP_RR
); /* receiver report */
390 avio_wb16(pb
, 1); /* length in words - 1 */
391 avio_wb32(pb
, 0); /* our own SSRC */
394 len
= avio_close_dyn_buf(pb
, &buf
);
395 if ((len
> 0) && buf
)
396 ffurl_write(rtp_handle
, buf
, len
);
400 static int find_missing_packets(RTPDemuxContext
*s
, uint16_t *first_missing
,
401 uint16_t *missing_mask
)
404 uint16_t next_seq
= s
->seq
+ 1;
405 RTPPacket
*pkt
= s
->queue
;
407 if (!pkt
|| pkt
->seq
== next_seq
)
411 for (i
= 1; i
<= 16; i
++) {
412 uint16_t missing_seq
= next_seq
+ i
;
414 int16_t diff
= pkt
->seq
- missing_seq
;
421 if (pkt
->seq
== missing_seq
)
423 *missing_mask
|= 1 << (i
- 1);
426 *first_missing
= next_seq
;
430 int ff_rtp_send_rtcp_feedback(RTPDemuxContext
*s
, URLContext
*fd
,
433 int len
, need_keyframe
, missing_packets
;
437 uint16_t first_missing
= 0, missing_mask
= 0;
442 need_keyframe
= s
->handler
&& s
->handler
->need_keyframe
&&
443 s
->handler
->need_keyframe(s
->dynamic_protocol_context
);
444 missing_packets
= find_missing_packets(s
, &first_missing
, &missing_mask
);
446 if (!need_keyframe
&& !missing_packets
)
449 /* Send new feedback if enough time has elapsed since the last
450 * feedback packet. */
453 if (s
->last_feedback_time
&&
454 (now
- s
->last_feedback_time
) < MIN_FEEDBACK_INTERVAL
)
456 s
->last_feedback_time
= now
;
460 else if (avio_open_dyn_buf(&pb
) < 0)
464 avio_w8(pb
, (RTP_VERSION
<< 6) | 1); /* PLI */
465 avio_w8(pb
, RTCP_PSFB
);
466 avio_wb16(pb
, 2); /* length in words - 1 */
467 // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
468 avio_wb32(pb
, s
->ssrc
+ 1);
469 avio_wb32(pb
, s
->ssrc
); // server SSRC
472 if (missing_packets
) {
473 avio_w8(pb
, (RTP_VERSION
<< 6) | 1); /* NACK */
474 avio_w8(pb
, RTCP_RTPFB
);
475 avio_wb16(pb
, 3); /* length in words - 1 */
476 avio_wb32(pb
, s
->ssrc
+ 1);
477 avio_wb32(pb
, s
->ssrc
); // server SSRC
479 avio_wb16(pb
, first_missing
);
480 avio_wb16(pb
, missing_mask
);
486 len
= avio_close_dyn_buf(pb
, &buf
);
487 if (len
> 0 && buf
) {
488 ffurl_write(fd
, buf
, len
);
495 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
498 RTPDemuxContext
*ff_rtp_parse_open(AVFormatContext
*s1
, AVStream
*st
,
499 int payload_type
, int queue_size
)
503 s
= av_mallocz(sizeof(RTPDemuxContext
));
506 s
->payload_type
= payload_type
;
507 s
->last_rtcp_ntp_time
= AV_NOPTS_VALUE
;
508 s
->first_rtcp_ntp_time
= AV_NOPTS_VALUE
;
511 s
->queue_size
= queue_size
;
512 rtp_init_statistics(&s
->statistics
, 0);
514 switch (st
->codec
->codec_id
) {
515 case AV_CODEC_ID_ADPCM_G722
:
516 /* According to RFC 3551, the stream clock rate is 8000
517 * even if the sample rate is 16000. */
518 if (st
->codec
->sample_rate
== 8000)
519 st
->codec
->sample_rate
= 16000;
525 // needed to send back RTCP RR in RTSP sessions
526 gethostname(s
->hostname
, sizeof(s
->hostname
));
530 void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext
*s
, PayloadContext
*ctx
,
531 RTPDynamicProtocolHandler
*handler
)
533 s
->dynamic_protocol_context
= ctx
;
534 s
->handler
= handler
;
537 void ff_rtp_parse_set_crypto(RTPDemuxContext
*s
, const char *suite
,
540 if (!ff_srtp_set_crypto(&s
->srtp
, suite
, params
))
545 * This was the second switch in rtp_parse packet.
546 * Normalizes time, if required, sets stream_index, etc.
548 static void finalize_packet(RTPDemuxContext
*s
, AVPacket
*pkt
, uint32_t timestamp
)
550 if (pkt
->pts
!= AV_NOPTS_VALUE
|| pkt
->dts
!= AV_NOPTS_VALUE
)
551 return; /* Timestamp already set by depacketizer */
552 if (timestamp
== RTP_NOTS_VALUE
)
555 if (s
->last_rtcp_ntp_time
!= AV_NOPTS_VALUE
&& s
->ic
->nb_streams
> 1) {
559 /* compute pts from timestamp with received ntp_time */
560 delta_timestamp
= timestamp
- s
->last_rtcp_timestamp
;
561 /* convert to the PTS timebase */
562 addend
= av_rescale(s
->last_rtcp_ntp_time
- s
->first_rtcp_ntp_time
,
563 s
->st
->time_base
.den
,
564 (uint64_t) s
->st
->time_base
.num
<< 32);
565 pkt
->pts
= s
->range_start_offset
+ s
->rtcp_ts_offset
+ addend
+
570 if (!s
->base_timestamp
)
571 s
->base_timestamp
= timestamp
;
572 /* assume that the difference is INT32_MIN < x < INT32_MAX,
573 * but allow the first timestamp to exceed INT32_MAX */
575 s
->unwrapped_timestamp
+= timestamp
;
577 s
->unwrapped_timestamp
+= (int32_t)(timestamp
- s
->timestamp
);
578 s
->timestamp
= timestamp
;
579 pkt
->pts
= s
->unwrapped_timestamp
+ s
->range_start_offset
-
583 static int rtp_parse_packet_internal(RTPDemuxContext
*s
, AVPacket
*pkt
,
584 const uint8_t *buf
, int len
)
587 int payload_type
, seq
, flags
= 0;
593 csrc
= buf
[0] & 0x0f;
595 payload_type
= buf
[1] & 0x7f;
597 flags
|= RTP_FLAG_MARKER
;
598 seq
= AV_RB16(buf
+ 2);
599 timestamp
= AV_RB32(buf
+ 4);
600 ssrc
= AV_RB32(buf
+ 8);
601 /* store the ssrc in the RTPDemuxContext */
604 /* NOTE: we can handle only one payload type */
605 if (s
->payload_type
!= payload_type
)
609 // only do something with this if all the rtp checks pass...
610 if (!rtp_valid_packet_in_sequence(&s
->statistics
, seq
)) {
611 av_log(st
? st
->codec
: NULL
, AV_LOG_ERROR
,
612 "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
613 payload_type
, seq
, ((s
->seq
+ 1) & 0xffff));
618 int padding
= buf
[len
- 1];
619 if (len
>= 12 + padding
)
630 return AVERROR_INVALIDDATA
;
632 /* RFC 3550 Section 5.3.1 RTP Header Extension handling */
636 /* calculate the header extension length (stored as number
637 * of 32-bit words) */
638 ext
= (AV_RB16(buf
+ 2) + 1) << 2;
642 // skip past RTP header extension
647 if (s
->handler
&& s
->handler
->parse_packet
) {
648 rv
= s
->handler
->parse_packet(s
->ic
, s
->dynamic_protocol_context
,
649 s
->st
, pkt
, ×tamp
, buf
, len
, seq
,
652 if ((rv
= av_new_packet(pkt
, len
)) < 0)
654 memcpy(pkt
->data
, buf
, len
);
655 pkt
->stream_index
= st
->index
;
657 return AVERROR(EINVAL
);
660 // now perform timestamp things....
661 finalize_packet(s
, pkt
, timestamp
);
666 void ff_rtp_reset_packet_queue(RTPDemuxContext
*s
)
669 RTPPacket
*next
= s
->queue
->next
;
670 av_free(s
->queue
->buf
);
679 static void enqueue_packet(RTPDemuxContext
*s
, uint8_t *buf
, int len
)
681 uint16_t seq
= AV_RB16(buf
+ 2);
682 RTPPacket
**cur
= &s
->queue
, *packet
;
684 /* Find the correct place in the queue to insert the packet */
686 int16_t diff
= seq
- (*cur
)->seq
;
692 packet
= av_mallocz(sizeof(*packet
));
695 packet
->recvtime
= av_gettime();
704 static int has_next_packet(RTPDemuxContext
*s
)
706 return s
->queue
&& s
->queue
->seq
== (uint16_t) (s
->seq
+ 1);
709 int64_t ff_rtp_queued_packet_time(RTPDemuxContext
*s
)
711 return s
->queue
? s
->queue
->recvtime
: 0;
714 static int rtp_parse_queued_packet(RTPDemuxContext
*s
, AVPacket
*pkt
)
719 if (s
->queue_len
<= 0)
722 if (!has_next_packet(s
))
723 av_log(s
->st
? s
->st
->codec
: NULL
, AV_LOG_WARNING
,
724 "RTP: missed %d packets\n", s
->queue
->seq
- s
->seq
- 1);
726 /* Parse the first packet in the queue, and dequeue it */
727 rv
= rtp_parse_packet_internal(s
, pkt
, s
->queue
->buf
, s
->queue
->len
);
728 next
= s
->queue
->next
;
729 av_free(s
->queue
->buf
);
736 static int rtp_parse_one_packet(RTPDemuxContext
*s
, AVPacket
*pkt
,
737 uint8_t **bufptr
, int len
)
739 uint8_t *buf
= bufptr
? *bufptr
: NULL
;
745 /* If parsing of the previous packet actually returned 0 or an error,
746 * there's nothing more to be parsed from that packet, but we may have
747 * indicated that we can return the next enqueued packet. */
748 if (s
->prev_ret
<= 0)
749 return rtp_parse_queued_packet(s
, pkt
);
750 /* return the next packets, if any */
751 if (s
->handler
&& s
->handler
->parse_packet
) {
752 /* timestamp should be overwritten by parse_packet, if not,
753 * the packet is left with pts == AV_NOPTS_VALUE */
754 timestamp
= RTP_NOTS_VALUE
;
755 rv
= s
->handler
->parse_packet(s
->ic
, s
->dynamic_protocol_context
,
756 s
->st
, pkt
, ×tamp
, NULL
, 0, 0,
758 finalize_packet(s
, pkt
, timestamp
);
766 if ((buf
[0] & 0xc0) != (RTP_VERSION
<< 6))
768 if (RTP_PT_IS_RTCP(buf
[1])) {
769 return rtcp_parse_packet(s
, buf
, len
);
773 int64_t received
= av_gettime();
774 uint32_t arrival_ts
= av_rescale_q(received
, AV_TIME_BASE_Q
,
776 timestamp
= AV_RB32(buf
+ 4);
777 // Calculate the jitter immediately, before queueing the packet
778 // into the reordering queue.
779 rtcp_update_jitter(&s
->statistics
, timestamp
, arrival_ts
);
782 if ((s
->seq
== 0 && !s
->queue
) || s
->queue_size
<= 1) {
783 /* First packet, or no reordering */
784 return rtp_parse_packet_internal(s
, pkt
, buf
, len
);
786 uint16_t seq
= AV_RB16(buf
+ 2);
787 int16_t diff
= seq
- s
->seq
;
789 /* Packet older than the previously emitted one, drop */
790 av_log(s
->st
? s
->st
->codec
: NULL
, AV_LOG_WARNING
,
791 "RTP: dropping old packet received too late\n");
793 } else if (diff
<= 1) {
795 rv
= rtp_parse_packet_internal(s
, pkt
, buf
, len
);
798 /* Still missing some packet, enqueue this one. */
799 enqueue_packet(s
, buf
, len
);
801 /* Return the first enqueued packet if the queue is full,
802 * even if we're missing something */
803 if (s
->queue_len
>= s
->queue_size
)
804 return rtp_parse_queued_packet(s
, pkt
);
811 * Parse an RTP or RTCP packet directly sent as a buffer.
812 * @param s RTP parse context.
813 * @param pkt returned packet
814 * @param bufptr pointer to the input buffer or NULL to read the next packets
815 * @param len buffer len
816 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
817 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
819 int ff_rtp_parse_packet(RTPDemuxContext
*s
, AVPacket
*pkt
,
820 uint8_t **bufptr
, int len
)
823 if (s
->srtp_enabled
&& bufptr
&& ff_srtp_decrypt(&s
->srtp
, *bufptr
, &len
) < 0)
825 rv
= rtp_parse_one_packet(s
, pkt
, bufptr
, len
);
827 while (rv
== AVERROR(EAGAIN
) && has_next_packet(s
))
828 rv
= rtp_parse_queued_packet(s
, pkt
);
829 return rv
? rv
: has_next_packet(s
);
832 void ff_rtp_parse_close(RTPDemuxContext
*s
)
834 ff_rtp_reset_packet_queue(s
);
835 ff_srtp_free(&s
->srtp
);
839 int ff_parse_fmtp(AVFormatContext
*s
,
840 AVStream
*stream
, PayloadContext
*data
, const char *p
,
841 int (*parse_fmtp
)(AVFormatContext
*s
,
843 PayloadContext
*data
,
844 char *attr
, char *value
))
849 int value_size
= strlen(p
) + 1;
851 if (!(value
= av_malloc(value_size
))) {
852 av_log(NULL
, AV_LOG_ERROR
, "Failed to allocate data for FMTP.\n");
853 return AVERROR(ENOMEM
);
856 // remove protocol identifier
857 while (*p
&& *p
== ' ')
859 while (*p
&& *p
!= ' ')
860 p
++; // eat protocol identifier
861 while (*p
&& *p
== ' ')
862 p
++; // strip trailing spaces
864 while (ff_rtsp_next_attr_and_value(&p
,
866 value
, value_size
)) {
867 res
= parse_fmtp(s
, stream
, data
, attr
, value
);
868 if (res
< 0 && res
!= AVERROR_PATCHWELCOME
) {
877 int ff_rtp_finalize_packet(AVPacket
*pkt
, AVIOContext
**dyn_buf
, int stream_idx
)
882 pkt
->size
= avio_close_dyn_buf(*dyn_buf
, &pkt
->data
);
883 pkt
->stream_index
= stream_idx
;
885 if ((ret
= av_packet_from_data(pkt
, pkt
->data
, pkt
->size
)) < 0) {
886 av_freep(&pkt
->data
);