FFmpeg: libavformat/rtpdec.c Source File

FFmpeg
rtpdec.c
Go to the documentation of this file.
1 /*
2  * RTP input format
3  * Copyright (c) 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/mathematics.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/time.h"
27 
28 #include "libavcodec/bytestream.h"
29 
30 #include "avformat.h"
31 #include "network.h"
32 #include "srtp.h"
33 #include "url.h"
34 #include "rtpdec.h"
35 #include "rtpdec_formats.h"
36 #include "internal.h"
37 
38  #define MIN_FEEDBACK_INTERVAL 200000 /* 200 ms in us */
39 
40  static const RTPDynamicProtocolHandler l24_dynamic_handler = {
41  .enc_name = "L24",
42  .codec_type = AVMEDIA_TYPE_AUDIO,
43  .codec_id = AV_CODEC_ID_PCM_S24BE,
44 };
45 
46  static const RTPDynamicProtocolHandler gsm_dynamic_handler = {
47  .enc_name = "GSM",
48  .codec_type = AVMEDIA_TYPE_AUDIO,
49  .codec_id = AV_CODEC_ID_GSM,
50 };
51 
52  static const RTPDynamicProtocolHandler realmedia_mp3_dynamic_handler = {
53  .enc_name = "X-MP3-draft-00",
54  .codec_type = AVMEDIA_TYPE_AUDIO,
55  .codec_id = AV_CODEC_ID_MP3ADU,
56 };
57 
58  static const RTPDynamicProtocolHandler speex_dynamic_handler = {
59  .enc_name = "speex",
60  .codec_type = AVMEDIA_TYPE_AUDIO,
61  .codec_id = AV_CODEC_ID_SPEEX,
62 };
63 
64  static const RTPDynamicProtocolHandler t140_dynamic_handler = { /* RFC 4103 */
65  .enc_name = "t140",
66  .codec_type = AVMEDIA_TYPE_SUBTITLE,
67  .codec_id = AV_CODEC_ID_TEXT,
68 };
69 
70 extern const RTPDynamicProtocolHandler ff_rdt_video_handler;
71 extern const RTPDynamicProtocolHandler ff_rdt_audio_handler;
72 extern const RTPDynamicProtocolHandler ff_rdt_live_video_handler;
73 extern const RTPDynamicProtocolHandler ff_rdt_live_audio_handler;
74 
75  static const RTPDynamicProtocolHandler *const rtp_dynamic_protocol_handler_list[] = {
76  /* rtp */
77  &ff_ac3_dynamic_handler,
78  &ff_amr_nb_dynamic_handler,
79  &ff_amr_wb_dynamic_handler,
80  &ff_av1_dynamic_handler,
81  &ff_dv_dynamic_handler,
82  &ff_g726_16_dynamic_handler,
83  &ff_g726_24_dynamic_handler,
84  &ff_g726_32_dynamic_handler,
85  &ff_g726_40_dynamic_handler,
86  &ff_g726le_16_dynamic_handler,
87  &ff_g726le_24_dynamic_handler,
88  &ff_g726le_32_dynamic_handler,
89  &ff_g726le_40_dynamic_handler,
90  &ff_h261_dynamic_handler,
91  &ff_h263_1998_dynamic_handler,
92  &ff_h263_2000_dynamic_handler,
93  &ff_h263_rfc2190_dynamic_handler,
94  &ff_h264_dynamic_handler,
95  &ff_hevc_dynamic_handler,
96  &ff_ilbc_dynamic_handler,
97  &ff_jpeg_dynamic_handler,
98  &ff_mp4a_latm_dynamic_handler,
99  &ff_mp4v_es_dynamic_handler,
100  &ff_mpeg_audio_dynamic_handler,
101  &ff_mpeg_audio_robust_dynamic_handler,
102  &ff_mpeg_video_dynamic_handler,
103  &ff_mpeg4_generic_dynamic_handler,
104  &ff_mpegts_dynamic_handler,
105  &ff_ms_rtp_asf_pfa_handler,
106  &ff_ms_rtp_asf_pfv_handler,
107  &ff_qcelp_dynamic_handler,
108  &ff_qdm2_dynamic_handler,
109  &ff_qt_rtp_aud_handler,
110  &ff_qt_rtp_vid_handler,
111  &ff_quicktime_rtp_aud_handler,
112  &ff_quicktime_rtp_vid_handler,
113  &ff_rfc4175_rtp_handler,
114  &ff_svq3_dynamic_handler,
115  &ff_theora_dynamic_handler,
116  &ff_vc2hq_dynamic_handler,
117  &ff_vorbis_dynamic_handler,
118  &ff_vp8_dynamic_handler,
119  &ff_vp9_dynamic_handler,
120  &gsm_dynamic_handler,
121  &l24_dynamic_handler,
122  &ff_opus_dynamic_handler,
123  &realmedia_mp3_dynamic_handler,
124  &speex_dynamic_handler,
125  &t140_dynamic_handler,
126  /* rdt */
127  &ff_rdt_video_handler,
128  &ff_rdt_audio_handler,
129  &ff_rdt_live_video_handler,
130  &ff_rdt_live_audio_handler,
131  NULL,
132 };
133 
134 /**
135  * Iterate over all registered rtp dynamic protocol handlers.
136  *
137  * @param opaque a pointer where libavformat will store the iteration state.
138  * Must point to NULL to start the iteration.
139  *
140  * @return the next registered rtp dynamic protocol handler
141  * or NULL when the iteration is finished
142  */
143  static const RTPDynamicProtocolHandler *rtp_handler_iterate(void **opaque)
144 {
145  uintptr_t i = (uintptr_t)*opaque;
146  const RTPDynamicProtocolHandler *r = rtp_dynamic_protocol_handler_list[i];
147 
148  if (r)
149  *opaque = (void*)(i + 1);
150 
151  return r;
152 }
153 
154  const RTPDynamicProtocolHandler *ff_rtp_handler_find_by_name(const char *name,
155  enum AVMediaType codec_type)
156 {
157  void *i = 0;
158  const RTPDynamicProtocolHandler *handler;
159  while (handler = rtp_handler_iterate(&i)) {
160  if (handler->enc_name &&
161  !av_strcasecmp(name, handler->enc_name) &&
162  codec_type == handler->codec_type)
163  return handler;
164  }
165  return NULL;
166 }
167 
168  const RTPDynamicProtocolHandler *ff_rtp_handler_find_by_id(int id,
169  enum AVMediaType codec_type)
170 {
171  void *i = 0;
172  const RTPDynamicProtocolHandler *handler;
173  while (handler = rtp_handler_iterate(&i)) {
174  if (handler->static_payload_id && handler->static_payload_id == id &&
175  codec_type == handler->codec_type)
176  return handler;
177  }
178  return NULL;
179 }
180 
181  static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf,
182  int len)
183 {
184  int payload_len;
185  while (len >= 4) {
186  payload_len = FFMIN(len, (AV_RB16(buf + 2) + 1) * 4);
187 
188  switch (buf[1]) {
189  case RTCP_SR:
190  if (payload_len < 28) {
191  av_log(s->ic, AV_LOG_ERROR, "Invalid RTCP SR packet length\n");
192  return AVERROR_INVALIDDATA;
193  }
194 
195  s->last_sr.ssrc = AV_RB32(buf + 4);
196  s->last_sr.ntp_timestamp = AV_RB64(buf + 8);
197  s->last_sr.rtp_timestamp = AV_RB32(buf + 16);
198  s->last_sr.sender_nb_packets = AV_RB32(buf + 20);
199  s->last_sr.sender_nb_bytes = AV_RB32(buf + 24);
200 
201  s->pending_sr = 1;
202  s->last_rtcp_reception_time = av_gettime_relative();
203 
204  if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
205  s->first_rtcp_ntp_time = s->last_sr.ntp_timestamp;
206  if (!s->base_timestamp)
207  s->base_timestamp = s->last_sr.rtp_timestamp;
208  s->rtcp_ts_offset = (int32_t)(s->last_sr.rtp_timestamp - s->base_timestamp);
209  }
210 
211  break;
212  case RTCP_BYE:
213  return -RTCP_BYE;
214  }
215 
216  buf += payload_len;
217  len -= payload_len;
218  }
219  return -1;
220 }
221 
222  #define RTP_SEQ_MOD (1 << 16)
223 
224  static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence)
225 {
226  memset(s, 0, sizeof(RTPStatistics));
227  s->max_seq = base_sequence;
228  s->probation = 1;
229 }
230 
231 /*
232  * Called whenever there is a large jump in sequence numbers,
233  * or when they get out of probation...
234  */
235  static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
236 {
237  s->max_seq = seq;
238  s->cycles = 0;
239  s->base_seq = seq - 1;
240  s->bad_seq = RTP_SEQ_MOD + 1;
241  s->received = 0;
242  s->expected_prior = 0;
243  s->received_prior = 0;
244  s->jitter = 0;
245  s->transit = 0;
246 }
247 
248 /* Returns 1 if we should handle this packet. */
249  static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
250 {
251  uint16_t udelta = seq - s->max_seq;
252  const int MAX_DROPOUT = 3000;
253  const int MAX_MISORDER = 100;
254  const int MIN_SEQUENTIAL = 2;
255 
256  /* source not valid until MIN_SEQUENTIAL packets with sequence
257  * seq. numbers have been received */
258  if (s->probation) {
259  if (seq == s->max_seq + 1) {
260  s->probation--;
261  s->max_seq = seq;
262  if (s->probation == 0) {
263  rtp_init_sequence(s, seq);
264  s->received++;
265  return 1;
266  }
267  } else {
268  s->probation = MIN_SEQUENTIAL - 1;
269  s->max_seq = seq;
270  }
271  } else if (udelta < MAX_DROPOUT) {
272  // in order, with permissible gap
273  if (seq < s->max_seq) {
274  // sequence number wrapped; count another 64k cycles
275  s->cycles += RTP_SEQ_MOD;
276  }
277  s->max_seq = seq;
278  } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
279  // sequence made a large jump...
280  if (seq == s->bad_seq) {
281  /* two sequential packets -- assume that the other side
282  * restarted without telling us; just resync. */
283  rtp_init_sequence(s, seq);
284  } else {
285  s->bad_seq = (seq + 1) & (RTP_SEQ_MOD - 1);
286  return 0;
287  }
288  } else {
289  // duplicate or reordered packet...
290  }
291  s->received++;
292  return 1;
293 }
294 
295  static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp,
296  uint32_t arrival_timestamp)
297 {
298  // Most of this is pretty straight from RFC 3550 appendix A.8
299  uint32_t transit = arrival_timestamp - sent_timestamp;
300  uint32_t prev_transit = s->transit;
301  int32_t d = transit - prev_transit;
302  // Doing the FFABS() call directly on the "transit - prev_transit"
303  // expression doesn't work, since it's an unsigned expression. Doing the
304  // transit calculation in unsigned is desired though, since it most
305  // probably will need to wrap around.
306  d = FFABS(d);
307  s->transit = transit;
308  if (!prev_transit)
309  return;
310  s->jitter += d - (int32_t) ((s->jitter + 8) >> 4);
311 }
312 
313  int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, URLContext *fd,
314  AVIOContext *avio, int count)
315 {
316  AVIOContext *pb;
317  uint8_t *buf;
318  int len;
319  int rtcp_bytes;
320  RTPStatistics *stats = &s->statistics;
321  uint32_t lost;
322  uint32_t extended_max;
323  uint32_t expected_interval;
324  uint32_t received_interval;
325  int32_t lost_interval;
326  uint32_t expected;
327  uint32_t fraction;
328 
329  if ((!fd && !avio) || (count < 1))
330  return -1;
331 
332  /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
333  /* XXX: MPEG pts hardcoded. RTCP send every 0.5 seconds */
334  s->octet_count += count;
335  rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
336  RTCP_TX_RATIO_DEN;
337  rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
338  if (rtcp_bytes < 28)
339  return -1;
340  s->last_octet_count = s->octet_count;
341 
342  if (!fd)
343  pb = avio;
344  else if (avio_open_dyn_buf(&pb) < 0)
345  return -1;
346 
347  // Receiver Report
348  avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
349  avio_w8(pb, RTCP_RR);
350  avio_wb16(pb, 7); /* length in words - 1 */
351  // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
352  avio_wb32(pb, s->ssrc + 1);
353  avio_wb32(pb, s->ssrc); // server SSRC
354  // some placeholders we should really fill...
355  // RFC 1889/p64
356  extended_max = stats->cycles + stats->max_seq;
357  expected = extended_max - stats->base_seq;
358  lost = expected - stats->received;
359  lost = FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
360  expected_interval = expected - stats->expected_prior;
361  stats->expected_prior = expected;
362  received_interval = stats->received - stats->received_prior;
363  stats->received_prior = stats->received;
364  lost_interval = expected_interval - received_interval;
365  if (expected_interval == 0 || lost_interval <= 0)
366  fraction = 0;
367  else
368  fraction = (lost_interval << 8) / expected_interval;
369 
370  fraction = (fraction << 24) | lost;
371 
372  avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
373  avio_wb32(pb, extended_max); /* max sequence received */
374  avio_wb32(pb, stats->jitter >> 4); /* jitter */
375 
376  if (s->last_sr.ntp_timestamp == AV_NOPTS_VALUE) {
377  avio_wb32(pb, 0); /* last SR timestamp */
378  avio_wb32(pb, 0); /* delay since last SR */
379  } else {
380  uint32_t middle_32_bits = s->last_sr.ntp_timestamp >> 16; // this is valid, right? do we need to handle 64 bit values special?
381  uint32_t delay_since_last = av_rescale(av_gettime_relative() - s->last_rtcp_reception_time,
382  65536, AV_TIME_BASE);
383 
384  avio_wb32(pb, middle_32_bits); /* last SR timestamp */
385  avio_wb32(pb, delay_since_last); /* delay since last SR */
386  }
387 
388  // CNAME
389  avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
390  avio_w8(pb, RTCP_SDES);
391  len = strlen(s->hostname);
392  avio_wb16(pb, (7 + len + 3) / 4); /* length in words - 1 */
393  avio_wb32(pb, s->ssrc + 1);
394  avio_w8(pb, 0x01);
395  avio_w8(pb, len);
396  avio_write(pb, s->hostname, len);
397  avio_w8(pb, 0); /* END */
398  // padding
399  for (len = (7 + len) % 4; len % 4; len++)
400  avio_w8(pb, 0);
401 
402  avio_flush(pb);
403  if (!fd)
404  return 0;
405  len = avio_close_dyn_buf(pb, &buf);
406  if ((len > 0) && buf) {
407  av_unused int result;
408  av_log(s->ic, AV_LOG_TRACE, "sending %d bytes of RR\n", len);
409  result = ffurl_write(fd, buf, len);
410  av_log(s->ic, AV_LOG_TRACE, "result from ffurl_write: %d\n", result);
411  av_free(buf);
412  }
413  return 0;
414 }
415 
416  void ff_rtp_send_punch_packets(URLContext *rtp_handle)
417 {
418  uint8_t buf[RTP_MIN_PACKET_LENGTH], *ptr = buf;
419 
420  /* Send a small RTP packet */
421 
422  bytestream_put_byte(&ptr, (RTP_VERSION << 6));
423  bytestream_put_byte(&ptr, 0); /* Payload type */
424  bytestream_put_be16(&ptr, 0); /* Seq */
425  bytestream_put_be32(&ptr, 0); /* Timestamp */
426  bytestream_put_be32(&ptr, 0); /* SSRC */
427 
428  ffurl_write(rtp_handle, buf, ptr - buf);
429 
430  /* Send a minimal RTCP RR */
431  ptr = buf;
432  bytestream_put_byte(&ptr, (RTP_VERSION << 6));
433  bytestream_put_byte(&ptr, RTCP_RR); /* receiver report */
434  bytestream_put_be16(&ptr, 1); /* length in words - 1 */
435  bytestream_put_be32(&ptr, 0); /* our own SSRC */
436 
437  ffurl_write(rtp_handle, buf, ptr - buf);
438 }
439 
440  static int find_missing_packets(RTPDemuxContext *s, uint16_t *first_missing,
441  uint16_t *missing_mask)
442 {
443  int i;
444  uint16_t next_seq = s->seq + 1;
445  RTPPacket *pkt = s->queue;
446 
447  if (!pkt || pkt->seq == next_seq)
448  return 0;
449 
450  *missing_mask = 0;
451  for (i = 1; i <= 16; i++) {
452  uint16_t missing_seq = next_seq + i;
453  while (pkt) {
454  int16_t diff = pkt->seq - missing_seq;
455  if (diff >= 0)
456  break;
457  pkt = pkt->next;
458  }
459  if (!pkt)
460  break;
461  if (pkt->seq == missing_seq)
462  continue;
463  *missing_mask |= 1 << (i - 1);
464  }
465 
466  *first_missing = next_seq;
467  return 1;
468 }
469 
470  int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd,
471  AVIOContext *avio)
472 {
473  int len, need_keyframe, missing_packets;
474  AVIOContext *pb;
475  uint8_t *buf;
476  int64_t now;
477  uint16_t first_missing = 0, missing_mask = 0;
478 
479  if (!fd && !avio)
480  return -1;
481 
482  need_keyframe = s->handler && s->handler->need_keyframe &&
483  s->handler->need_keyframe(s->dynamic_protocol_context);
484  missing_packets = find_missing_packets(s, &first_missing, &missing_mask);
485 
486  if (!need_keyframe && !missing_packets)
487  return 0;
488 
489  /* Send new feedback if enough time has elapsed since the last
490  * feedback packet. */
491 
492  now = av_gettime_relative();
493  if (s->last_feedback_time &&
494  (now - s->last_feedback_time) < MIN_FEEDBACK_INTERVAL)
495  return 0;
496  s->last_feedback_time = now;
497 
498  if (!fd)
499  pb = avio;
500  else if (avio_open_dyn_buf(&pb) < 0)
501  return -1;
502 
503  if (need_keyframe) {
504  avio_w8(pb, (RTP_VERSION << 6) | 1); /* PLI */
505  avio_w8(pb, RTCP_PSFB);
506  avio_wb16(pb, 2); /* length in words - 1 */
507  // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
508  avio_wb32(pb, s->ssrc + 1);
509  avio_wb32(pb, s->ssrc); // server SSRC
510  }
511 
512  if (missing_packets) {
513  avio_w8(pb, (RTP_VERSION << 6) | 1); /* NACK */
514  avio_w8(pb, RTCP_RTPFB);
515  avio_wb16(pb, 3); /* length in words - 1 */
516  avio_wb32(pb, s->ssrc + 1);
517  avio_wb32(pb, s->ssrc); // server SSRC
518 
519  avio_wb16(pb, first_missing);
520  avio_wb16(pb, missing_mask);
521  }
522 
523  avio_flush(pb);
524  if (!fd)
525  return 0;
526  len = avio_close_dyn_buf(pb, &buf);
527  if (len > 0 && buf) {
528  ffurl_write(fd, buf, len);
529  av_free(buf);
530  }
531  return 0;
532 }
533 
534 /**
535  * open a new RTP parse context for stream 'st'. 'st' can be NULL for
536  * MPEG-2 TS streams.
537  */
538  RTPDemuxContext *ff_rtp_parse_open(AVFormatContext *s1, AVStream *st,
539  int payload_type, int queue_size)
540 {
541  RTPDemuxContext *s;
542 
543  s = av_mallocz(sizeof(RTPDemuxContext));
544  if (!s)
545  return NULL;
546  s->payload_type = payload_type;
547  s->last_sr.ntp_timestamp = AV_NOPTS_VALUE;
548  s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
549  s->ic = s1;
550  s->st = st;
551  s->queue_size = queue_size;
552 
553  av_log(s->ic, AV_LOG_VERBOSE, "setting jitter buffer size to %d\n",
554  s->queue_size);
555 
556  rtp_init_statistics(&s->statistics, 0);
557  if (st) {
558  switch (st->codecpar->codec_id) {
559  case AV_CODEC_ID_ADPCM_G722:
560  /* According to RFC 3551, the stream clock rate is 8000
561  * even if the sample rate is 16000. */
562  if (st->codecpar->sample_rate == 8000)
563  st->codecpar->sample_rate = 16000;
564  break;
565  case AV_CODEC_ID_PCM_MULAW: {
566  AVCodecParameters *par = st->codecpar;
567  par->bits_per_coded_sample = av_get_bits_per_sample(par->codec_id);
568  par->block_align = par->ch_layout.nb_channels * par->bits_per_coded_sample / 8;
569  par->bit_rate = par->block_align * 8LL * par->sample_rate;
570  break;
571  }
572  default:
573  break;
574  }
575  }
576  // needed to send back RTCP RR in RTSP sessions
577  gethostname(s->hostname, sizeof(s->hostname));
578  return s;
579 }
580 
581  void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
582  const RTPDynamicProtocolHandler *handler)
583 {
584  s->dynamic_protocol_context = ctx;
585  s->handler = handler;
586 }
587 
588  void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite,
589  const char *params)
590 {
591  if (!ff_srtp_set_crypto(&s->srtp, suite, params))
592  s->srtp_enabled = 1;
593 }
594 
595  static int rtp_set_prft(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp) {
596  int64_t rtcp_time, delta_time;
597  int32_t delta_timestamp;
598 
599  AVProducerReferenceTime *prft =
600  (AVProducerReferenceTime *) av_packet_new_side_data(
601  pkt, AV_PKT_DATA_PRFT, sizeof(AVProducerReferenceTime));
602  if (!prft)
603  return AVERROR(ENOMEM);
604 
605  rtcp_time = ff_parse_ntp_time(s->last_sr.ntp_timestamp) - NTP_OFFSET_US;
606  /* Cast to int32_t to handle timestamp wraparound correctly */
607  delta_timestamp = (int32_t)(timestamp - s->last_sr.rtp_timestamp);
608  delta_time = av_rescale_q(delta_timestamp, s->st->time_base, AV_TIME_BASE_Q);
609 
610  prft->wallclock = rtcp_time + delta_time;
611  prft->flags = 24;
612  return 0;
613 }
614 
615  static int rtp_add_sr_sidedata(RTPDemuxContext *s, AVPacket *pkt) {
616  AVRTCPSenderReport *sr =
617  (AVRTCPSenderReport *) av_packet_new_side_data(
618  pkt, AV_PKT_DATA_RTCP_SR, sizeof(AVRTCPSenderReport));
619  if (!sr)
620  return AVERROR(ENOMEM);
621 
622  memcpy(sr, &s->last_sr, sizeof(AVRTCPSenderReport));
623  s->pending_sr = 0;
624  return 0;
625 }
626 
627 /**
628  * This was the second switch in rtp_parse packet.
629  * Normalizes time, if required, sets stream_index, etc.
630  */
631  static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
632 {
633  if (s->pending_sr) {
634  int ret = rtp_add_sr_sidedata(s, pkt);
635  if (ret < 0)
636  av_log(s->ic, AV_LOG_WARNING, "rtpdec: failed to add SR sidedata\n");
637  }
638 
639  if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE)
640  return; /* Timestamp already set by depacketizer */
641  if (timestamp == RTP_NOTS_VALUE)
642  return;
643 
644  if (s->last_sr.ntp_timestamp != AV_NOPTS_VALUE) {
645  if (rtp_set_prft(s, pkt, timestamp) < 0) {
646  av_log(s->ic, AV_LOG_WARNING, "rtpdec: failed to set prft");
647  }
648  }
649 
650  if (s->last_sr.ntp_timestamp != AV_NOPTS_VALUE && s->ic->nb_streams > 1) {
651  int64_t addend;
652  int32_t delta_timestamp;
653 
654  /* compute pts from timestamp with received ntp_time */
655  /* Cast to int32_t to handle timestamp wraparound correctly */
656  delta_timestamp = (int32_t)(timestamp - s->last_sr.rtp_timestamp);
657  /* convert to the PTS timebase */
658  addend = av_rescale(s->last_sr.ntp_timestamp - s->first_rtcp_ntp_time,
659  s->st->time_base.den,
660  (uint64_t) s->st->time_base.num << 32);
661  pkt->pts = s->range_start_offset + s->rtcp_ts_offset + addend +
662  delta_timestamp;
663  return;
664  }
665 
666  if (!s->base_timestamp)
667  s->base_timestamp = timestamp;
668  /* assume that the difference is INT32_MIN < x < INT32_MAX,
669  * but allow the first timestamp to exceed INT32_MAX */
670  if (!s->timestamp)
671  s->unwrapped_timestamp += timestamp;
672  else
673  s->unwrapped_timestamp += (int32_t)(timestamp - s->timestamp);
674  s->timestamp = timestamp;
675  pkt->pts = s->unwrapped_timestamp + s->range_start_offset -
676  s->base_timestamp;
677 }
678 
679  static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt,
680  const uint8_t *buf, int len)
681 {
682  unsigned int ssrc;
683  int payload_type, seq, flags = 0;
684  int ext, csrc;
685  AVStream *st;
686  uint32_t timestamp;
687  int rv = 0;
688 
689  csrc = buf[0] & 0x0f;
690  ext = buf[0] & 0x10;
691  payload_type = buf[1] & 0x7f;
692  if (buf[1] & 0x80)
693  flags |= RTP_FLAG_MARKER;
694  seq = AV_RB16(buf + 2);
695  timestamp = AV_RB32(buf + 4);
696  ssrc = AV_RB32(buf + 8);
697  /* store the ssrc in the RTPDemuxContext */
698  s->ssrc = ssrc;
699 
700  /* NOTE: we can handle only one payload type */
701  if (s->payload_type != payload_type)
702  return -1;
703 
704  st = s->st;
705  // only do something with this if all the rtp checks pass...
706  if (!rtp_valid_packet_in_sequence(&s->statistics, seq)) {
707  av_log(s->ic, AV_LOG_ERROR,
708  "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
709  payload_type, seq, ((s->seq + 1) & 0xffff));
710  return -1;
711  }
712 
713  if (buf[0] & 0x20) {
714  int padding = buf[len - 1];
715  if (len >= 12 + padding)
716  len -= padding;
717  }
718 
719  s->seq = seq;
720  len -= 12;
721  buf += 12;
722 
723  len -= 4 * csrc;
724  buf += 4 * csrc;
725  if (len < 0)
726  return AVERROR_INVALIDDATA;
727 
728  /* RFC 3550 Section 5.3.1 RTP Header Extension handling */
729  if (ext) {
730  if (len < 4)
731  return -1;
732  /* calculate the header extension length (stored as number
733  * of 32-bit words) */
734  ext = (AV_RB16(buf + 2) + 1) << 2;
735 
736  if (len < ext)
737  return -1;
738  // skip past RTP header extension
739  len -= ext;
740  buf += ext;
741  }
742 
743  if (s->handler && s->handler->parse_packet) {
744  rv = s->handler->parse_packet(s->ic, s->dynamic_protocol_context,
745  s->st, pkt, &timestamp, buf, len, seq,
746  flags);
747  } else if (st) {
748  if ((rv = av_new_packet(pkt, len)) < 0)
749  return rv;
750  memcpy(pkt->data, buf, len);
751  pkt->stream_index = st->index;
752  } else {
753  return AVERROR(EINVAL);
754  }
755 
756  // now perform timestamp things....
757  finalize_packet(s, pkt, timestamp);
758 
759  return rv;
760 }
761 
762  void ff_rtp_reset_packet_queue(RTPDemuxContext *s)
763 {
764  while (s->queue) {
765  RTPPacket *next = s->queue->next;
766  av_freep(&s->queue->buf);
767  av_freep(&s->queue);
768  s->queue = next;
769  }
770  s->seq = 0;
771  s->queue_len = 0;
772  s->prev_ret = 0;
773 }
774 
775  static int enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len)
776 {
777  uint16_t seq = AV_RB16(buf + 2);
778  RTPPacket **cur = &s->queue, *packet;
779 
780  /* Find the correct place in the queue to insert the packet */
781  while (*cur) {
782  int16_t diff = seq - (*cur)->seq;
783  if (diff < 0)
784  break;
785  cur = &(*cur)->next;
786  }
787 
788  packet = av_mallocz(sizeof(*packet));
789  if (!packet)
790  return AVERROR(ENOMEM);
791  packet->recvtime = av_gettime_relative();
792  packet->seq = seq;
793  packet->len = len;
794  packet->buf = buf;
795  packet->next = *cur;
796  *cur = packet;
797  s->queue_len++;
798 
799  return 0;
800 }
801 
802  static int has_next_packet(RTPDemuxContext *s)
803 {
804  return s->queue && s->queue->seq == (uint16_t) (s->seq + 1);
805 }
806 
807  int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
808 {
809  return s->queue ? s->queue->recvtime : 0;
810 }
811 
812  static int rtp_parse_queued_packet(RTPDemuxContext *s, AVPacket *pkt)
813 {
814  int rv;
815  RTPPacket *next;
816 
817  if (s->queue_len <= 0)
818  return -1;
819 
820  if (!has_next_packet(s)) {
821  int pkt_missed = s->queue->seq - s->seq - 1;
822 
823  if (pkt_missed < 0)
824  pkt_missed += UINT16_MAX;
825  av_log(s->ic, AV_LOG_WARNING,
826  "RTP: missed %d packets\n", pkt_missed);
827  }
828 
829  /* Parse the first packet in the queue, and dequeue it */
830  rv = rtp_parse_packet_internal(s, pkt, s->queue->buf, s->queue->len);
831  next = s->queue->next;
832  av_freep(&s->queue->buf);
833  av_freep(&s->queue);
834  s->queue = next;
835  s->queue_len--;
836  return rv;
837 }
838 
839  static int rtp_parse_one_packet(RTPDemuxContext *s, AVPacket *pkt,
840  uint8_t **bufptr, int len)
841 {
842  uint8_t *buf = bufptr ? *bufptr : NULL;
843  int flags = 0;
844  uint32_t timestamp;
845  int rv = 0;
846 
847  if (!buf) {
848  /* If parsing of the previous packet actually returned 0 or an error,
849  * there's nothing more to be parsed from that packet, but we may have
850  * indicated that we can return the next enqueued packet. */
851  if (s->prev_ret <= 0)
852  return rtp_parse_queued_packet(s, pkt);
853  /* return the next packets, if any */
854  if (s->handler && s->handler->parse_packet) {
855  /* timestamp should be overwritten by parse_packet, if not,
856  * the packet is left with pts == AV_NOPTS_VALUE */
857  timestamp = RTP_NOTS_VALUE;
858  rv = s->handler->parse_packet(s->ic, s->dynamic_protocol_context,
859  s->st, pkt, &timestamp, NULL, 0, 0,
860  flags);
861  finalize_packet(s, pkt, timestamp);
862  return rv;
863  }
864  }
865 
866  if (len < 12)
867  return -1;
868 
869  if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
870  return -1;
871  if (RTP_PT_IS_RTCP(buf[1])) {
872  return rtcp_parse_packet(s, buf, len);
873  }
874 
875  if (s->st) {
876  int64_t received = av_gettime_relative();
877  uint32_t arrival_ts = av_rescale_q(received, AV_TIME_BASE_Q,
878  s->st->time_base);
879  timestamp = AV_RB32(buf + 4);
880  // Calculate the jitter immediately, before queueing the packet
881  // into the reordering queue.
882  rtcp_update_jitter(&s->statistics, timestamp, arrival_ts);
883  }
884 
885  if ((s->seq == 0 && !s->queue) || s->queue_size <= 1) {
886  /* First packet, or no reordering */
887  return rtp_parse_packet_internal(s, pkt, buf, len);
888  } else {
889  uint16_t seq = AV_RB16(buf + 2);
890  int16_t diff = seq - s->seq;
891  if (diff < 0) {
892  /* Packet older than the previously emitted one, drop */
893  av_log(s->ic, AV_LOG_WARNING,
894  "RTP: dropping old packet received too late\n");
895  return -1;
896  } else if (diff <= 1) {
897  /* Correct packet */
898  rv = rtp_parse_packet_internal(s, pkt, buf, len);
899  return rv;
900  } else {
901  /* Still missing some packet, enqueue this one. */
902  rv = enqueue_packet(s, buf, len);
903  if (rv < 0)
904  return rv;
905  *bufptr = NULL;
906  /* Return the first enqueued packet if the queue is full,
907  * even if we're missing something */
908  if (s->queue_len >= s->queue_size) {
909  av_log(s->ic, AV_LOG_WARNING, "jitter buffer full\n");
910  return rtp_parse_queued_packet(s, pkt);
911  }
912  return -1;
913  }
914  }
915 }
916 
917 /**
918  * Parse an RTP or RTCP packet directly sent as a buffer.
919  * @param s RTP parse context.
920  * @param pkt returned packet
921  * @param bufptr pointer to the input buffer or NULL to read the next packets
922  * @param len buffer len
923  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
924  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
925  */
926  int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
927  uint8_t **bufptr, int len)
928 {
929  int rv;
930  if (s->srtp_enabled && bufptr && ff_srtp_decrypt(&s->srtp, *bufptr, &len) < 0)
931  return -1;
932  rv = rtp_parse_one_packet(s, pkt, bufptr, len);
933  s->prev_ret = rv;
934  while (rv < 0 && has_next_packet(s))
935  rv = rtp_parse_queued_packet(s, pkt);
936  return rv ? rv : has_next_packet(s);
937 }
938 
939  void ff_rtp_parse_close(RTPDemuxContext *s)
940 {
941  ff_rtp_reset_packet_queue(s);
942  ff_srtp_free(&s->srtp);
943  av_free(s);
944 }
945 
946  int ff_parse_fmtp(AVFormatContext *s,
947  AVStream *stream, PayloadContext *data, const char *p,
948  int (*parse_fmtp)(AVFormatContext *s,
949  AVStream *stream,
950  PayloadContext *data,
951  const char *attr, const char *value))
952 {
953  char attr[256];
954  char *value;
955  int res;
956  int value_size = strlen(p) + 1;
957 
958  if (!(value = av_malloc(value_size))) {
959  av_log(s, AV_LOG_ERROR, "Failed to allocate data for FMTP.\n");
960  return AVERROR(ENOMEM);
961  }
962 
963  // remove protocol identifier
964  while (*p && *p == ' ')
965  p++; // strip spaces
966  while (*p && *p != ' ')
967  p++; // eat protocol identifier
968  while (*p && *p == ' ')
969  p++; // strip trailing spaces
970 
971  while (ff_rtsp_next_attr_and_value(&p,
972  attr, sizeof(attr),
973  value, value_size)) {
974  res = parse_fmtp(s, stream, data, attr, value);
975  if (res < 0 && res != AVERROR_PATCHWELCOME) {
976  av_free(value);
977  return res;
978  }
979  }
980  av_free(value);
981  return 0;
982 }
983 
984  int ff_rtp_finalize_packet(AVPacket *pkt, AVIOContext **dyn_buf, int stream_idx)
985 {
986  int ret;
987  av_packet_unref(pkt);
988 
989  pkt->size = avio_close_dyn_buf(*dyn_buf, &pkt->data);
990  pkt->stream_index = stream_idx;
991  *dyn_buf = NULL;
992  if ((ret = av_packet_from_data(pkt, pkt->data, pkt->size)) < 0) {
993  av_freep(&pkt->data);
994  return ret;
995  }
996  return pkt->size;
997 }
flags
const SwsFlags flags[]
Definition: swscale.c:61
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:432
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:203
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
ff_h263_rfc2190_dynamic_handler
const RTPDynamicProtocolHandler ff_h263_rfc2190_dynamic_handler
Definition: rtpdec_h263_rfc2190.c:188
RTPStatistics
Definition: rtpdec.h:80
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
ff_quicktime_rtp_aud_handler
const RTPDynamicProtocolHandler ff_quicktime_rtp_aud_handler
rtp_dynamic_protocol_handler_list
static const RTPDynamicProtocolHandler *const rtp_dynamic_protocol_handler_list[]
Definition: rtpdec.c:75
ff_amr_nb_dynamic_handler
const RTPDynamicProtocolHandler ff_amr_nb_dynamic_handler
Definition: rtpdec_amr.c:185
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_h261_dynamic_handler
const RTPDynamicProtocolHandler ff_h261_dynamic_handler
Definition: rtpdec_h261.c:167
ff_rtp_send_rtcp_feedback
int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio)
Definition: rtpdec.c:470
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
RTP_VERSION
#define RTP_VERSION
Definition: rtp.h:80
parse_fmtp
static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)
Definition: rtpdec_latm.c:133
rtpdec_formats.h
ff_parse_fmtp
int ff_parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *p, int(*parse_fmtp)(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value))
Definition: rtpdec.c:946
enqueue_packet
static int enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len)
Definition: rtpdec.c:775
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:263
int64_t
long long int64_t
Definition: coverity.c:34
ffurl_write
static int ffurl_write(URLContext *h, const uint8_t *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: url.h:202
ff_hevc_dynamic_handler
const RTPDynamicProtocolHandler ff_hevc_dynamic_handler
Definition: rtpdec_hevc.c:342
l24_dynamic_handler
static const RTPDynamicProtocolHandler l24_dynamic_handler
Definition: rtpdec.c:40
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:208
av_unused
#define av_unused
Definition: attributes.h:151
AVProducerReferenceTime::wallclock
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
Definition: defs.h:335
RTP_FLAG_MARKER
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:94
AVPacket::data
uint8_t * data
Definition: packet.h:588
ff_vp8_dynamic_handler
const RTPDynamicProtocolHandler ff_vp8_dynamic_handler
Definition: rtpdec_vp8.c:279
srtp.h
data
const char data[16]
Definition: mxf.c:149
ff_g726le_24_dynamic_handler
const RTPDynamicProtocolHandler ff_g726le_24_dynamic_handler
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
ff_parse_ntp_time
uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
Parse the NTP time in micro seconds (since NTP epoch).
Definition: utils.c:284
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:404
mathematics.h
ff_av1_dynamic_handler
const RTPDynamicProtocolHandler ff_av1_dynamic_handler
Definition: rtpdec_av1.c:450
AV_PKT_DATA_RTCP_SR
@ AV_PKT_DATA_RTCP_SR
Contains the last received RTCP SR (Sender Report) information in the form of the AVRTCPSenderReport ...
Definition: packet.h:363
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
ff_rtp_check_and_send_back_rr
int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio, int count)
some rtp servers assume client is dead if they don't hear from them...
Definition: rtpdec.c:313
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
ff_h263_2000_dynamic_handler
const RTPDynamicProtocolHandler ff_h263_2000_dynamic_handler
Definition: rtpdec_h263.c:100
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_rtp_finalize_packet
int ff_rtp_finalize_packet(AVPacket *pkt, AVIOContext **dyn_buf, int stream_idx)
Close the dynamic buffer and make a packet from it.
Definition: rtpdec.c:984
AV_CODEC_ID_MP3ADU
@ AV_CODEC_ID_MP3ADU
Definition: codec_id.h:472
ff_rtp_send_punch_packets
void ff_rtp_send_punch_packets(URLContext *rtp_handle)
Send a dummy packet on both port pairs to set up the connection state in potential NAT routers,...
Definition: rtpdec.c:416
RTPDynamicProtocolHandler::enc_name
const char * enc_name
Definition: rtpdec.h:117
ff_opus_dynamic_handler
const RTPDynamicProtocolHandler ff_opus_dynamic_handler
Definition: rtpdec_opus.c:144
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:494
ff_srtp_decrypt
int ff_srtp_decrypt(struct SRTPContext *s, uint8_t *buf, int *lenptr)
Definition: srtp.c:127
ff_rtp_parse_set_crypto
void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite, const char *params)
Definition: rtpdec.c:588
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:549
ff_vc2hq_dynamic_handler
const RTPDynamicProtocolHandler ff_vc2hq_dynamic_handler
Definition: rtpdec_vc2hq.c:219
avio_close_dyn_buf
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1410
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:236
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
gsm_dynamic_handler
static const RTPDynamicProtocolHandler gsm_dynamic_handler
Definition: rtpdec.c:46
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1365
t140_dynamic_handler
static const RTPDynamicProtocolHandler t140_dynamic_handler
Definition: rtpdec.c:64
intreadwrite.h
RTCP_TX_RATIO_NUM
#define RTCP_TX_RATIO_NUM
Definition: rtp.h:84
s
#define s(width, name)
Definition: cbs_vp9.c:198
RTPPacket::next
struct RTPPacket * next
Definition: rtpdec.h:145
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
ff_rdt_live_video_handler
const RTPDynamicProtocolHandler ff_rdt_live_video_handler
ff_ilbc_dynamic_handler
const RTPDynamicProtocolHandler ff_ilbc_dynamic_handler
Definition: rtpdec_ilbc.c:69
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
ff_qdm2_dynamic_handler
const RTPDynamicProtocolHandler ff_qdm2_dynamic_handler
Definition: rtpdec_qdm2.c:302
RTCP_TX_RATIO_DEN
#define RTCP_TX_RATIO_DEN
Definition: rtp.h:85
RTP_NOTS_VALUE
#define RTP_NOTS_VALUE
Definition: rtpdec.h:41
finalize_packet
static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
This was the second switch in rtp_parse packet.
Definition: rtpdec.c:631
ff_mp4v_es_dynamic_handler
const RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler
Definition: rtpdec_mpeg4.c:360
ff_rfc4175_rtp_handler
const RTPDynamicProtocolHandler ff_rfc4175_rtp_handler
Definition: rtpdec_rfc4175.c:334
ff_dv_dynamic_handler
const RTPDynamicProtocolHandler ff_dv_dynamic_handler
Definition: rtpdec_dv.c:132
rtp_init_statistics
static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence)
Definition: rtpdec.c:224
ctx
AVFormatContext * ctx
Definition: movenc.c:49
has_next_packet
static int has_next_packet(RTPDemuxContext *s)
Definition: rtpdec.c:802
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:343
ff_mpeg_audio_robust_dynamic_handler
const RTPDynamicProtocolHandler ff_mpeg_audio_robust_dynamic_handler
Definition: rtpdec_mpa_robust.c:193
ff_rtp_handler_find_by_id
const RTPDynamicProtocolHandler * ff_rtp_handler_find_by_id(int id, enum AVMediaType codec_type)
Find a registered rtp dynamic protocol handler with a matching codec ID.
Definition: rtpdec.c:168
handler
static void handler(vbi_event *ev, void *user_data)
Definition: libzvbi-teletextdec.c:508
rtp_set_prft
static int rtp_set_prft(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
Definition: rtpdec.c:595
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:228
rtp_valid_packet_in_sequence
static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
Definition: rtpdec.c:249
ff_qt_rtp_vid_handler
const RTPDynamicProtocolHandler ff_qt_rtp_vid_handler
AVFormatContext
Format I/O context.
Definition: avformat.h:1264
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
MIN_FEEDBACK_INTERVAL
#define MIN_FEEDBACK_INTERVAL
Definition: rtpdec.c:38
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
find_missing_packets
static int find_missing_packets(RTPDemuxContext *s, uint16_t *first_missing, uint16_t *missing_mask)
Definition: rtpdec.c:440
ff_rtsp_next_attr_and_value
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
ff_mp4a_latm_dynamic_handler
const RTPDynamicProtocolHandler ff_mp4a_latm_dynamic_handler
Definition: rtpdec_latm.c:167
NULL
#define NULL
Definition: coverity.c:32
RTCP_SDES
@ RTCP_SDES
Definition: rtp.h:101
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
ff_h264_dynamic_handler
const RTPDynamicProtocolHandler ff_h264_dynamic_handler
Definition: rtpdec_h264.c:412
ff_rtp_queued_packet_time
int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
Definition: rtpdec.c:807
ff_qt_rtp_aud_handler
const RTPDynamicProtocolHandler ff_qt_rtp_aud_handler
time.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:184
RTCP_PSFB
@ RTCP_PSFB
Definition: rtp.h:105
AVProducerReferenceTime
This structure supplies correlation between a packet timestamp and a wall clock production time.
Definition: defs.h:331
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
ff_rdt_audio_handler
const RTPDynamicProtocolHandler ff_rdt_audio_handler
AVProducerReferenceTime::flags
int flags
Definition: defs.h:336
stats
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
Definition: vp9_superframe.c:34
RTP_MIN_PACKET_LENGTH
#define RTP_MIN_PACKET_LENGTH
Definition: rtpdec.h:36
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
rtpdec.h
RTCP_RR
@ RTCP_RR
Definition: rtp.h:100
AV_CODEC_ID_GSM
@ AV_CODEC_ID_GSM
as in Berlin toast format
Definition: codec_id.h:477
ff_rdt_video_handler
const RTPDynamicProtocolHandler ff_rdt_video_handler
RTPPacket
Definition: rtpdec.h:140
ff_mpeg_audio_dynamic_handler
const RTPDynamicProtocolHandler ff_mpeg_audio_dynamic_handler
Definition: rtpdec_mpeg12.c:52
suite
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test suite
Definition: build_system.txt:28
ff_rtp_parse_close
void ff_rtp_parse_close(RTPDemuxContext *s)
Definition: rtpdec.c:939
RTP_PT_IS_RTCP
#define RTP_PT_IS_RTCP(x)
Definition: rtp.h:112
realmedia_mp3_dynamic_handler
static const RTPDynamicProtocolHandler realmedia_mp3_dynamic_handler
Definition: rtpdec.c:52
ff_rtp_parse_open
RTPDemuxContext * ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, int queue_size)
open a new RTP parse context for stream 'st'.
Definition: rtpdec.c:538
av_packet_from_data
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)
Initialize a reference-counted packet from av_malloc()ed data.
Definition: packet.c:172
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVMediaType
AVMediaType
Definition: avutil.h:198
AVPacket::size
int size
Definition: packet.h:589
rtp_add_sr_sidedata
static int rtp_add_sr_sidedata(RTPDemuxContext *s, AVPacket *pkt)
Definition: rtpdec.c:615
ff_g726_16_dynamic_handler
const RTPDynamicProtocolHandler ff_g726_16_dynamic_handler
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
NTP_OFFSET_US
#define NTP_OFFSET_US
Definition: internal.h:404
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
ff_ac3_dynamic_handler
const RTPDynamicProtocolHandler ff_ac3_dynamic_handler
Definition: rtpdec_ac3.c:125
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
ff_g726le_16_dynamic_handler
const RTPDynamicProtocolHandler ff_g726le_16_dynamic_handler
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:587
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:206
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:368
ff_srtp_free
void ff_srtp_free(struct SRTPContext *s)
Definition: srtp.c:32
ff_rtp_handler_find_by_name
const RTPDynamicProtocolHandler * ff_rtp_handler_find_by_name(const char *name, enum AVMediaType codec_type)
Find a registered rtp dynamic protocol handler with the specified name.
Definition: rtpdec.c:154
AV_PKT_DATA_PRFT
@ AV_PKT_DATA_PRFT
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
Definition: packet.h:265
speex_dynamic_handler
static const RTPDynamicProtocolHandler speex_dynamic_handler
Definition: rtpdec.c:58
rtp_parse_packet_internal
static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt, const uint8_t *buf, int len)
Definition: rtpdec.c:679
ff_g726_40_dynamic_handler
const RTPDynamicProtocolHandler ff_g726_40_dynamic_handler
rtp_handler_iterate
static const RTPDynamicProtocolHandler * rtp_handler_iterate(void **opaque)
Iterate over all registered rtp dynamic protocol handlers.
Definition: rtpdec.c:143
URLContext
Definition: url.h:35
rtcp_parse_packet
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
Definition: rtpdec.c:181
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:581
ff_vorbis_dynamic_handler
const RTPDynamicProtocolHandler ff_vorbis_dynamic_handler
Definition: rtpdec_xiph.c:380
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:253
ff_rtp_parse_packet
int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Parse an RTP or RTCP packet directly sent as a buffer.
Definition: rtpdec.c:926
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
ff_mpeg_video_dynamic_handler
const RTPDynamicProtocolHandler ff_mpeg_video_dynamic_handler
Definition: rtpdec_mpeg12.c:60
RTCP_BYE
@ RTCP_BYE
Definition: rtp.h:102
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
AVRTCPSenderReport
RTCP SR (Sender Report) information.
Definition: defs.h:345
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
url.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
len
int len
Definition: vorbis_enc_data.h:426
ff_srtp_set_crypto
int ff_srtp_set_crypto(struct SRTPContext *s, const char *suite, const char *params)
Definition: srtp.c:66
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
RTPDemuxContext
Definition: rtpdec.h:148
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
ff_g726_32_dynamic_handler
const RTPDynamicProtocolHandler ff_g726_32_dynamic_handler
ff_amr_wb_dynamic_handler
const RTPDynamicProtocolHandler ff_amr_wb_dynamic_handler
Definition: rtpdec_amr.c:195
avformat.h
RTCP_RTPFB
@ RTCP_RTPFB
Definition: rtp.h:104
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: codec_id.h:573
network.h
ff_quicktime_rtp_vid_handler
const RTPDynamicProtocolHandler ff_quicktime_rtp_vid_handler
ff_mpeg4_generic_dynamic_handler
const RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler
Definition: rtpdec_mpeg4.c:369
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:750
rtp_parse_one_packet
static int rtp_parse_one_packet(RTPDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Definition: rtpdec.c:839
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: packet.c:231
rtcp_update_jitter
static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
Definition: rtpdec.c:295
RTCP_SR
@ RTCP_SR
Definition: rtp.h:99
ff_vp9_dynamic_handler
const RTPDynamicProtocolHandler ff_vp9_dynamic_handler
Definition: rtpdec_vp9.c:333
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
ff_svq3_dynamic_handler
const RTPDynamicProtocolHandler ff_svq3_dynamic_handler
Definition: rtpdec_svq3.c:109
AVPacket::stream_index
int stream_index
Definition: packet.h:590
ff_g726le_40_dynamic_handler
const RTPDynamicProtocolHandler ff_g726le_40_dynamic_handler
ff_rdt_live_audio_handler
const RTPDynamicProtocolHandler ff_rdt_live_audio_handler
ff_mpegts_dynamic_handler
const RTPDynamicProtocolHandler ff_mpegts_dynamic_handler
Definition: rtpdec_mpegts.c:92
rtp_init_sequence
static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
Definition: rtpdec.c:235
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
mem.h
ff_ms_rtp_asf_pfv_handler
const RTPDynamicProtocolHandler ff_ms_rtp_asf_pfv_handler
ff_g726le_32_dynamic_handler
const RTPDynamicProtocolHandler ff_g726le_32_dynamic_handler
RTP_SEQ_MOD
#define RTP_SEQ_MOD
Definition: rtpdec.c:222
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
ff_rtp_parse_set_dynamic_protocol
void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, const RTPDynamicProtocolHandler *handler)
Definition: rtpdec.c:581
AVPacket
This structure stores compressed data.
Definition: packet.h:565
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_jpeg_dynamic_handler
const RTPDynamicProtocolHandler ff_jpeg_dynamic_handler
Definition: rtpdec_jpeg.c:384
ff_rtp_reset_packet_queue
void ff_rtp_reset_packet_queue(RTPDemuxContext *s)
Definition: rtpdec.c:762
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:446
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_g726_24_dynamic_handler
const RTPDynamicProtocolHandler ff_g726_24_dynamic_handler
ff_qcelp_dynamic_handler
const RTPDynamicProtocolHandler ff_qcelp_dynamic_handler
Definition: rtpdec_qcelp.c:212
avstring.h
ff_h263_1998_dynamic_handler
const RTPDynamicProtocolHandler ff_h263_1998_dynamic_handler
Definition: rtpdec_h263.c:92
PayloadContext
RTP/AV1 specific private data.
Definition: rdt.c:85
rtp_parse_queued_packet
static int rtp_parse_queued_packet(RTPDemuxContext *s, AVPacket *pkt)
Definition: rtpdec.c:812
ff_theora_dynamic_handler
const RTPDynamicProtocolHandler ff_theora_dynamic_handler
Definition: rtpdec_xiph.c:370
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:350
ff_ms_rtp_asf_pfa_handler
const RTPDynamicProtocolHandler ff_ms_rtp_asf_pfa_handler
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
RTPDynamicProtocolHandler
Definition: rtpdec.h:116
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
Generated on Tue Nov 18 2025 19:23:33 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /