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

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