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 "avformat.h"
28 #include "network.h"
29 #include "srtp.h"
30 #include "url.h"
31 #include "rtpdec.h"
32 #include "rtpdec_formats.h"
33 
34 #define MIN_FEEDBACK_INTERVAL 200000 /* 200 ms in us */
35 
37  .enc_name = "L24",
38  .codec_type = AVMEDIA_TYPE_AUDIO,
39  .codec_id = AV_CODEC_ID_PCM_S24BE,
40 };
41 
43  .enc_name = "GSM",
44  .codec_type = AVMEDIA_TYPE_AUDIO,
45  .codec_id = AV_CODEC_ID_GSM,
46 };
47 
49  .enc_name = "X-MP3-draft-00",
50  .codec_type = AVMEDIA_TYPE_AUDIO,
51  .codec_id = AV_CODEC_ID_MP3ADU,
52 };
53 
55  .enc_name = "speex",
56  .codec_type = AVMEDIA_TYPE_AUDIO,
57  .codec_id = AV_CODEC_ID_SPEEX,
58 };
59 
61  .enc_name = "opus",
62  .codec_type = AVMEDIA_TYPE_AUDIO,
63  .codec_id = AV_CODEC_ID_OPUS,
64 };
65 
67  .enc_name = "t140",
68  .codec_type = AVMEDIA_TYPE_SUBTITLE,
69  .codec_id = AV_CODEC_ID_TEXT,
70 };
71 
76 
78  /* rtp */
127  /* rdt */
132  NULL,
133 };
134 
136 {
137  uintptr_t i = (uintptr_t)*opaque;
138  const RTPDynamicProtocolHandler *r = rtp_dynamic_protocol_handler_list[i];
139 
140  if (r)
141  *opaque = (void*)(i + 1);
142 
143  return r;
144 }
145 
147  enum AVMediaType codec_type)
148 {
149  void *i = 0;
151  while (handler = ff_rtp_handler_iterate(&i)) {
152  if (handler->enc_name &&
153  !av_strcasecmp(name, handler->enc_name) &&
154  codec_type == handler->codec_type)
155  return handler;
156  }
157  return NULL;
158 }
159 
161  enum AVMediaType codec_type)
162 {
163  void *i = 0;
165  while (handler = ff_rtp_handler_iterate(&i)) {
166  if (handler->static_payload_id && handler->static_payload_id == id &&
167  codec_type == handler->codec_type)
168  return handler;
169  }
170  return NULL;
171 }
172 
173 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf,
174  int len)
175 {
176  int payload_len;
177  while (len >= 4) {
178  payload_len = FFMIN(len, (AV_RB16(buf + 2) + 1) * 4);
179 
180  switch (buf[1]) {
181  case RTCP_SR:
182  if (payload_len < 20) {
183  av_log(s->ic, AV_LOG_ERROR, "Invalid RTCP SR packet length\n");
184  return AVERROR_INVALIDDATA;
185  }
186 
188  s->last_rtcp_ntp_time = AV_RB64(buf + 8);
189  s->last_rtcp_timestamp = AV_RB32(buf + 16);
192  if (!s->base_timestamp)
195  }
196 
197  break;
198  case RTCP_BYE:
199  return -RTCP_BYE;
200  }
201 
202  buf += payload_len;
203  len -= payload_len;
204  }
205  return -1;
206 }
207 
208 #define RTP_SEQ_MOD (1 << 16)
209 
210 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence)
211 {
212  memset(s, 0, sizeof(RTPStatistics));
213  s->max_seq = base_sequence;
214  s->probation = 1;
215 }
216 
217 /*
218  * Called whenever there is a large jump in sequence numbers,
219  * or when they get out of probation...
220  */
221 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
222 {
223  s->max_seq = seq;
224  s->cycles = 0;
225  s->base_seq = seq - 1;
226  s->bad_seq = RTP_SEQ_MOD + 1;
227  s->received = 0;
228  s->expected_prior = 0;
229  s->received_prior = 0;
230  s->jitter = 0;
231  s->transit = 0;
232 }
233 
234 /* Returns 1 if we should handle this packet. */
235 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
236 {
237  uint16_t udelta = seq - s->max_seq;
238  const int MAX_DROPOUT = 3000;
239  const int MAX_MISORDER = 100;
240  const int MIN_SEQUENTIAL = 2;
241 
242  /* source not valid until MIN_SEQUENTIAL packets with sequence
243  * seq. numbers have been received */
244  if (s->probation) {
245  if (seq == s->max_seq + 1) {
246  s->probation--;
247  s->max_seq = seq;
248  if (s->probation == 0) {
249  rtp_init_sequence(s, seq);
250  s->received++;
251  return 1;
252  }
253  } else {
254  s->probation = MIN_SEQUENTIAL - 1;
255  s->max_seq = seq;
256  }
257  } else if (udelta < MAX_DROPOUT) {
258  // in order, with permissible gap
259  if (seq < s->max_seq) {
260  // sequence number wrapped; count another 64k cycles
261  s->cycles += RTP_SEQ_MOD;
262  }
263  s->max_seq = seq;
264  } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
265  // sequence made a large jump...
266  if (seq == s->bad_seq) {
267  /* two sequential packets -- assume that the other side
268  * restarted without telling us; just resync. */
269  rtp_init_sequence(s, seq);
270  } else {
271  s->bad_seq = (seq + 1) & (RTP_SEQ_MOD - 1);
272  return 0;
273  }
274  } else {
275  // duplicate or reordered packet...
276  }
277  s->received++;
278  return 1;
279 }
280 
281 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp,
282  uint32_t arrival_timestamp)
283 {
284  // Most of this is pretty straight from RFC 3550 appendix A.8
285  uint32_t transit = arrival_timestamp - sent_timestamp;
286  uint32_t prev_transit = s->transit;
287  int32_t d = transit - prev_transit;
288  // Doing the FFABS() call directly on the "transit - prev_transit"
289  // expression doesn't work, since it's an unsigned expression. Doing the
290  // transit calculation in unsigned is desired though, since it most
291  // probably will need to wrap around.
292  d = FFABS(d);
293  s->transit = transit;
294  if (!prev_transit)
295  return;
296  s->jitter += d - (int32_t) ((s->jitter + 8) >> 4);
297 }
298 
300  AVIOContext *avio, int count)
301 {
302  AVIOContext *pb;
303  uint8_t *buf;
304  int len;
305  int rtcp_bytes;
307  uint32_t lost;
308  uint32_t extended_max;
309  uint32_t expected_interval;
310  uint32_t received_interval;
311  int32_t lost_interval;
312  uint32_t expected;
313  uint32_t fraction;
314 
315  if ((!fd && !avio) || (count < 1))
316  return -1;
317 
318  /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
319  /* XXX: MPEG pts hardcoded. RTCP send every 0.5 seconds */
320  s->octet_count += count;
321  rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
323  rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
324  if (rtcp_bytes < 28)
325  return -1;
327 
328  if (!fd)
329  pb = avio;
330  else if (avio_open_dyn_buf(&pb) < 0)
331  return -1;
332 
333  // Receiver Report
334  avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
335  avio_w8(pb, RTCP_RR);
336  avio_wb16(pb, 7); /* length in words - 1 */
337  // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
338  avio_wb32(pb, s->ssrc + 1);
339  avio_wb32(pb, s->ssrc); // server SSRC
340  // some placeholders we should really fill...
341  // RFC 1889/p64
342  extended_max = stats->cycles + stats->max_seq;
343  expected = extended_max - stats->base_seq;
344  lost = expected - stats->received;
345  lost = FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
346  expected_interval = expected - stats->expected_prior;
347  stats->expected_prior = expected;
348  received_interval = stats->received - stats->received_prior;
349  stats->received_prior = stats->received;
350  lost_interval = expected_interval - received_interval;
351  if (expected_interval == 0 || lost_interval <= 0)
352  fraction = 0;
353  else
354  fraction = (lost_interval << 8) / expected_interval;
355 
356  fraction = (fraction << 24) | lost;
357 
358  avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
359  avio_wb32(pb, extended_max); /* max sequence received */
360  avio_wb32(pb, stats->jitter >> 4); /* jitter */
361 
363  avio_wb32(pb, 0); /* last SR timestamp */
364  avio_wb32(pb, 0); /* delay since last SR */
365  } else {
366  uint32_t middle_32_bits = s->last_rtcp_ntp_time >> 16; // this is valid, right? do we need to handle 64 bit values special?
367  uint32_t delay_since_last = av_rescale(av_gettime_relative() - s->last_rtcp_reception_time,
368  65536, AV_TIME_BASE);
369 
370  avio_wb32(pb, middle_32_bits); /* last SR timestamp */
371  avio_wb32(pb, delay_since_last); /* delay since last SR */
372  }
373 
374  // CNAME
375  avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
376  avio_w8(pb, RTCP_SDES);
377  len = strlen(s->hostname);
378  avio_wb16(pb, (7 + len + 3) / 4); /* length in words - 1 */
379  avio_wb32(pb, s->ssrc + 1);
380  avio_w8(pb, 0x01);
381  avio_w8(pb, len);
382  avio_write(pb, s->hostname, len);
383  avio_w8(pb, 0); /* END */
384  // padding
385  for (len = (7 + len) % 4; len % 4; len++)
386  avio_w8(pb, 0);
387 
388  avio_flush(pb);
389  if (!fd)
390  return 0;
391  len = avio_close_dyn_buf(pb, &buf);
392  if ((len > 0) && buf) {
393  int av_unused result;
394  av_log(s->ic, AV_LOG_TRACE, "sending %d bytes of RR\n", len);
395  result = ffurl_write(fd, buf, len);
396  av_log(s->ic, AV_LOG_TRACE, "result from ffurl_write: %d\n", result);
397  av_free(buf);
398  }
399  return 0;
400 }
401 
403 {
404  AVIOContext *pb;
405  uint8_t *buf;
406  int len;
407 
408  /* Send a small RTP packet */
409  if (avio_open_dyn_buf(&pb) < 0)
410  return;
411 
412  avio_w8(pb, (RTP_VERSION << 6));
413  avio_w8(pb, 0); /* Payload type */
414  avio_wb16(pb, 0); /* Seq */
415  avio_wb32(pb, 0); /* Timestamp */
416  avio_wb32(pb, 0); /* SSRC */
417 
418  len = avio_close_dyn_buf(pb, &buf);
419  if ((len > 0) && buf)
420  ffurl_write(rtp_handle, buf, len);
421  av_free(buf);
422 
423  /* Send a minimal RTCP RR */
424  if (avio_open_dyn_buf(&pb) < 0)
425  return;
426 
427  avio_w8(pb, (RTP_VERSION << 6));
428  avio_w8(pb, RTCP_RR); /* receiver report */
429  avio_wb16(pb, 1); /* length in words - 1 */
430  avio_wb32(pb, 0); /* our own SSRC */
431 
432  len = avio_close_dyn_buf(pb, &buf);
433  if ((len > 0) && buf)
434  ffurl_write(rtp_handle, buf, len);
435  av_free(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 
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 &&
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 &&
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 /**
533  * open a new RTP parse context for stream 'st'. 'st' can be NULL for
534  * MPEG-2 TS streams.
535  */
537  int payload_type, int queue_size)
538 {
540 
541  s = av_mallocz(sizeof(RTPDemuxContext));
542  if (!s)
543  return NULL;
544  s->payload_type = payload_type;
547  s->ic = s1;
548  s->st = st;
549  s->queue_size = queue_size;
550 
551  av_log(s->ic, AV_LOG_VERBOSE, "setting jitter buffer size to %d\n",
552  s->queue_size);
553 
555  if (st) {
556  switch (st->codecpar->codec_id) {
558  /* According to RFC 3551, the stream clock rate is 8000
559  * even if the sample rate is 16000. */
560  if (st->codecpar->sample_rate == 8000)
561  st->codecpar->sample_rate = 16000;
562  break;
563  default:
564  break;
565  }
566  }
567  // needed to send back RTCP RR in RTSP sessions
568  gethostname(s->hostname, sizeof(s->hostname));
569  return s;
570 }
571 
574 {
576  s->handler = handler;
577 }
578 
580  const char *params)
581 {
582  if (!ff_srtp_set_crypto(&s->srtp, suite, params))
583  s->srtp_enabled = 1;
584 }
585 
586 /**
587  * This was the second switch in rtp_parse packet.
588  * Normalizes time, if required, sets stream_index, etc.
589  */
590 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
591 {
592  if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE)
593  return; /* Timestamp already set by depacketizer */
594  if (timestamp == RTP_NOTS_VALUE)
595  return;
596 
597  if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE && s->ic->nb_streams > 1) {
598  int64_t addend;
599  int delta_timestamp;
600 
601  /* compute pts from timestamp with received ntp_time */
602  delta_timestamp = timestamp - s->last_rtcp_timestamp;
603  /* convert to the PTS timebase */
605  s->st->time_base.den,
606  (uint64_t) s->st->time_base.num << 32);
607  pkt->pts = s->range_start_offset + s->rtcp_ts_offset + addend +
608  delta_timestamp;
609  return;
610  }
611 
612  if (!s->base_timestamp)
613  s->base_timestamp = timestamp;
614  /* assume that the difference is INT32_MIN < x < INT32_MAX,
615  * but allow the first timestamp to exceed INT32_MAX */
616  if (!s->timestamp)
617  s->unwrapped_timestamp += timestamp;
618  else
619  s->unwrapped_timestamp += (int32_t)(timestamp - s->timestamp);
620  s->timestamp = timestamp;
622  s->base_timestamp;
623 }
624 
626  const uint8_t *buf, int len)
627 {
628  unsigned int ssrc;
629  int payload_type, seq, flags = 0;
630  int ext, csrc;
631  AVStream *st;
632  uint32_t timestamp;
633  int rv = 0;
634 
635  csrc = buf[0] & 0x0f;
636  ext = buf[0] & 0x10;
637  payload_type = buf[1] & 0x7f;
638  if (buf[1] & 0x80)
639  flags |= RTP_FLAG_MARKER;
640  seq = AV_RB16(buf + 2);
641  timestamp = AV_RB32(buf + 4);
642  ssrc = AV_RB32(buf + 8);
643  /* store the ssrc in the RTPDemuxContext */
644  s->ssrc = ssrc;
645 
646  /* NOTE: we can handle only one payload type */
647  if (s->payload_type != payload_type)
648  return -1;
649 
650  st = s->st;
651  // only do something with this if all the rtp checks pass...
652  if (!rtp_valid_packet_in_sequence(&s->statistics, seq)) {
653  av_log(s->ic, AV_LOG_ERROR,
654  "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
655  payload_type, seq, ((s->seq + 1) & 0xffff));
656  return -1;
657  }
658 
659  if (buf[0] & 0x20) {
660  int padding = buf[len - 1];
661  if (len >= 12 + padding)
662  len -= padding;
663  }
664 
665  s->seq = seq;
666  len -= 12;
667  buf += 12;
668 
669  len -= 4 * csrc;
670  buf += 4 * csrc;
671  if (len < 0)
672  return AVERROR_INVALIDDATA;
673 
674  /* RFC 3550 Section 5.3.1 RTP Header Extension handling */
675  if (ext) {
676  if (len < 4)
677  return -1;
678  /* calculate the header extension length (stored as number
679  * of 32-bit words) */
680  ext = (AV_RB16(buf + 2) + 1) << 2;
681 
682  if (len < ext)
683  return -1;
684  // skip past RTP header extension
685  len -= ext;
686  buf += ext;
687  }
688 
689  if (s->handler && s->handler->parse_packet) {
691  s->st, pkt, &timestamp, buf, len, seq,
692  flags);
693  } else if (st) {
694  if ((rv = av_new_packet(pkt, len)) < 0)
695  return rv;
696  memcpy(pkt->data, buf, len);
697  pkt->stream_index = st->index;
698  } else {
699  return AVERROR(EINVAL);
700  }
701 
702  // now perform timestamp things....
703  finalize_packet(s, pkt, timestamp);
704 
705  return rv;
706 }
707 
709 {
710  while (s->queue) {
711  RTPPacket *next = s->queue->next;
712  av_freep(&s->queue->buf);
713  av_freep(&s->queue);
714  s->queue = next;
715  }
716  s->seq = 0;
717  s->queue_len = 0;
718  s->prev_ret = 0;
719 }
720 
721 static int enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len)
722 {
723  uint16_t seq = AV_RB16(buf + 2);
724  RTPPacket **cur = &s->queue, *packet;
725 
726  /* Find the correct place in the queue to insert the packet */
727  while (*cur) {
728  int16_t diff = seq - (*cur)->seq;
729  if (diff < 0)
730  break;
731  cur = &(*cur)->next;
732  }
733 
734  packet = av_mallocz(sizeof(*packet));
735  if (!packet)
736  return AVERROR(ENOMEM);
737  packet->recvtime = av_gettime_relative();
738  packet->seq = seq;
739  packet->len = len;
740  packet->buf = buf;
741  packet->next = *cur;
742  *cur = packet;
743  s->queue_len++;
744 
745  return 0;
746 }
747 
749 {
750  return s->queue && s->queue->seq == (uint16_t) (s->seq + 1);
751 }
752 
754 {
755  return s->queue ? s->queue->recvtime : 0;
756 }
757 
759 {
760  int rv;
761  RTPPacket *next;
762 
763  if (s->queue_len <= 0)
764  return -1;
765 
766  if (!has_next_packet(s))
768  "RTP: missed %d packets\n", s->queue->seq - s->seq - 1);
769 
770  /* Parse the first packet in the queue, and dequeue it */
771  rv = rtp_parse_packet_internal(s, pkt, s->queue->buf, s->queue->len);
772  next = s->queue->next;
773  av_freep(&s->queue->buf);
774  av_freep(&s->queue);
775  s->queue = next;
776  s->queue_len--;
777  return rv;
778 }
779 
781  uint8_t **bufptr, int len)
782 {
783  uint8_t *buf = bufptr ? *bufptr : NULL;
784  int flags = 0;
785  uint32_t timestamp;
786  int rv = 0;
787 
788  if (!buf) {
789  /* If parsing of the previous packet actually returned 0 or an error,
790  * there's nothing more to be parsed from that packet, but we may have
791  * indicated that we can return the next enqueued packet. */
792  if (s->prev_ret <= 0)
793  return rtp_parse_queued_packet(s, pkt);
794  /* return the next packets, if any */
795  if (s->handler && s->handler->parse_packet) {
796  /* timestamp should be overwritten by parse_packet, if not,
797  * the packet is left with pts == AV_NOPTS_VALUE */
798  timestamp = RTP_NOTS_VALUE;
800  s->st, pkt, &timestamp, NULL, 0, 0,
801  flags);
802  finalize_packet(s, pkt, timestamp);
803  return rv;
804  }
805  }
806 
807  if (len < 12)
808  return -1;
809 
810  if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
811  return -1;
812  if (RTP_PT_IS_RTCP(buf[1])) {
813  return rtcp_parse_packet(s, buf, len);
814  }
815 
816  if (s->st) {
817  int64_t received = av_gettime_relative();
818  uint32_t arrival_ts = av_rescale_q(received, AV_TIME_BASE_Q,
819  s->st->time_base);
820  timestamp = AV_RB32(buf + 4);
821  // Calculate the jitter immediately, before queueing the packet
822  // into the reordering queue.
823  rtcp_update_jitter(&s->statistics, timestamp, arrival_ts);
824  }
825 
826  if ((s->seq == 0 && !s->queue) || s->queue_size <= 1) {
827  /* First packet, or no reordering */
828  return rtp_parse_packet_internal(s, pkt, buf, len);
829  } else {
830  uint16_t seq = AV_RB16(buf + 2);
831  int16_t diff = seq - s->seq;
832  if (diff < 0) {
833  /* Packet older than the previously emitted one, drop */
835  "RTP: dropping old packet received too late\n");
836  return -1;
837  } else if (diff <= 1) {
838  /* Correct packet */
839  rv = rtp_parse_packet_internal(s, pkt, buf, len);
840  return rv;
841  } else {
842  /* Still missing some packet, enqueue this one. */
843  rv = enqueue_packet(s, buf, len);
844  if (rv < 0)
845  return rv;
846  *bufptr = NULL;
847  /* Return the first enqueued packet if the queue is full,
848  * even if we're missing something */
849  if (s->queue_len >= s->queue_size) {
850  av_log(s->ic, AV_LOG_WARNING, "jitter buffer full\n");
851  return rtp_parse_queued_packet(s, pkt);
852  }
853  return -1;
854  }
855  }
856 }
857 
858 /**
859  * Parse an RTP or RTCP packet directly sent as a buffer.
860  * @param s RTP parse context.
861  * @param pkt returned packet
862  * @param bufptr pointer to the input buffer or NULL to read the next packets
863  * @param len buffer len
864  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
865  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
866  */
868  uint8_t **bufptr, int len)
869 {
870  int rv;
871  if (s->srtp_enabled && bufptr && ff_srtp_decrypt(&s->srtp, *bufptr, &len) < 0)
872  return -1;
873  rv = rtp_parse_one_packet(s, pkt, bufptr, len);
874  s->prev_ret = rv;
875  while (rv < 0 && has_next_packet(s))
876  rv = rtp_parse_queued_packet(s, pkt);
877  return rv ? rv : has_next_packet(s);
878 }
879 
881 {
883  ff_srtp_free(&s->srtp);
884  av_free(s);
885 }
886 
888  AVStream *stream, PayloadContext *data, const char *p,
889  int (*parse_fmtp)(AVFormatContext *s,
890  AVStream *stream,
891  PayloadContext *data,
892  const char *attr, const char *value))
893 {
894  char attr[256];
895  char *value;
896  int res;
897  int value_size = strlen(p) + 1;
898 
899  if (!(value = av_malloc(value_size))) {
900  av_log(s, AV_LOG_ERROR, "Failed to allocate data for FMTP.\n");
901  return AVERROR(ENOMEM);
902  }
903 
904  // remove protocol identifier
905  while (*p && *p == ' ')
906  p++; // strip spaces
907  while (*p && *p != ' ')
908  p++; // eat protocol identifier
909  while (*p && *p == ' ')
910  p++; // strip trailing spaces
911 
912  while (ff_rtsp_next_attr_and_value(&p,
913  attr, sizeof(attr),
914  value, value_size)) {
915  res = parse_fmtp(s, stream, data, attr, value);
916  if (res < 0 && res != AVERROR_PATCHWELCOME) {
917  av_free(value);
918  return res;
919  }
920  }
921  av_free(value);
922  return 0;
923 }
924 
925 int ff_rtp_finalize_packet(AVPacket *pkt, AVIOContext **dyn_buf, int stream_idx)
926 {
927  int ret;
928  av_init_packet(pkt);
929 
930  pkt->size = avio_close_dyn_buf(*dyn_buf, &pkt->data);
931  pkt->stream_index = stream_idx;
932  *dyn_buf = NULL;
933  if ((ret = av_packet_from_data(pkt, pkt->data, pkt->size)) < 0) {
934  av_freep(&pkt->data);
935  return ret;
936  }
937  return pkt->size;
938 }
int queue_size
The size of queue, or 0 if reordering is disabled.
Definition: rtpdec.h:173
#define NULL
Definition: coverity.c:32
void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite, const char *params)
Definition: rtpdec.c:579
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVFormatContext * ic
Definition: rtpdec.h:150
uint16_t seq
Definition: rtpdec.h:154
const RTPDynamicProtocolHandler ff_amr_nb_dynamic_handler
Definition: rtpdec_amr.c:185
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:402
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1414
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
const RTPDynamicProtocolHandler ff_qt_rtp_aud_handler
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
Definition: rtpdec.c:281
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:423
int payload_type
Definition: rtpdec.h:152
int64_t range_start_offset
Definition: rtpdec.h:158
const RTPDynamicProtocolHandler ff_ms_rtp_asf_pfv_handler
int prev_ret
Fields for packet reordering.
Definition: rtpdec.h:170
RTP/JPEG specific private data.
Definition: rdt.c:83
int64_t last_feedback_time
Definition: rtpdec.h:187
unsigned int last_octet_count
Definition: rtpdec.h:186
static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt, const uint8_t *buf, int len)
Definition: rtpdec.c:625
const RTPDynamicProtocolHandler ff_g726le_32_dynamic_handler
RTPPacket * queue
A sorted queue of buffered packets not yet returned.
Definition: rtpdec.h:171
#define RTP_VERSION
Definition: rtp.h:78
static int parse_fmtp(AVFormatContext *s, AVStream *stream, PayloadContext *data, const char *attr, const char *value)
Definition: rtpdec_latm.c:130
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:877
int size
Definition: packet.h:364
#define RTCP_TX_RATIO_NUM
Definition: rtp.h:82
const RTPDynamicProtocolHandler * handler
Definition: rtpdec.h:190
enum AVMediaType codec_type
Definition: rtp.c:37
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
Definition: rtpdec.c:173
const RTPDynamicProtocolHandler ff_rfc4175_rtp_handler
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static RTPDynamicProtocolHandler l24_dynamic_handler
Definition: rtpdec.c:36
static AVPacket pkt
uint64_t last_rtcp_ntp_time
Definition: rtpdec.h:177
uint32_t cycles
shifted count of sequence number cycles
Definition: rtpdec.h:81
#define RTCP_TX_RATIO_DEN
Definition: rtp.h:83
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:87
static RTPDynamicProtocolHandler speex_dynamic_handler
Definition: rtpdec.c:54
RTPDynamicProtocolHandler ff_rdt_video_handler
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1369
static int find_missing_packets(RTPDemuxContext *s, uint16_t *first_missing, uint16_t *missing_mask)
Definition: rtpdec.c:438
enum AVMediaType codec_type
Definition: rtpdec.h:117
RTPDemuxContext * ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, int queue_size)
open a new RTP parse context for stream &#39;st&#39;.
Definition: rtpdec.c:536
PayloadContext * dynamic_protocol_context
Definition: rtpdec.h:191
Format I/O context.
Definition: avformat.h:1351
uint64_t first_rtcp_ntp_time
Definition: rtpdec.h:179
static RTPDynamicProtocolHandler gsm_dynamic_handler
Definition: rtpdec.c:42
uint32_t base_seq
base sequence number
Definition: rtpdec.h:82
void ff_srtp_free(struct SRTPContext *s)
Definition: srtp.c:31
uint8_t
#define av_malloc(s)
int(* need_keyframe)(PayloadContext *context)
Definition: rtpdec.h:136
const RTPDynamicProtocolHandler ff_g726le_40_dynamic_handler
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
void ff_rtp_reset_packet_queue(RTPDemuxContext *s)
Definition: rtpdec.c:708
const RTPDynamicProtocolHandler ff_vp9_dynamic_handler
Definition: rtpdec_vp9.c:333
const RTPDynamicProtocolHandler ff_quicktime_rtp_aud_handler
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int len
Definition: rtpdec.h:144
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:155
static void handler(vbi_event *ev, void *user_data)
int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
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:87
uint8_t * data
Definition: packet.h:363
const RTPDynamicProtocolHandler ff_mp4a_latm_dynamic_handler
Definition: rtpdec_latm.c:164
Definition: rtp.h:99
static int rtp_parse_queued_packet(RTPDemuxContext *s, AVPacket *pkt)
Definition: rtpdec.c:758
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
const RTPDynamicProtocolHandler ff_h263_2000_dynamic_handler
Definition: rtpdec_h263.c:100
const RTPDynamicProtocolHandler ff_jpeg_dynamic_handler
Definition: rtpdec_jpeg.c:382
const RTPDynamicProtocolHandler ff_qdm2_dynamic_handler
Definition: rtpdec_qdm2.c:303
char hostname[256]
Definition: rtpdec.h:161
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
const RTPDynamicProtocolHandler ff_hevc_dynamic_handler
Definition: rtpdec_hevc.c:343
uint32_t expected_prior
packets expected in last interval
Definition: rtpdec.h:86
const RTPDynamicProtocolHandler ff_mp4v_es_dynamic_handler
Definition: rtpdec_mpeg4.c:349
#define av_log(a,...)
const RTPDynamicProtocolHandler * ff_rtp_handler_iterate(void **opaque)
Iterate over all registered rtp dynamic protocol handlers.
Definition: rtpdec.c:135
static const RTPDynamicProtocolHandler * rtp_dynamic_protocol_handler_list[]
Definition: rtpdec.c:77
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
int srtp_enabled
Definition: rtpdec.h:163
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
const RTPDynamicProtocolHandler ff_vorbis_dynamic_handler
Definition: rtpdec_xiph.c:379
const RTPDynamicProtocolHandler ff_ms_rtp_asf_pfa_handler
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
uint16_t seq
Definition: rtpdec.h:142
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:93
RTPDynamicProtocolHandler ff_rdt_live_video_handler
const RTPDynamicProtocolHandler ff_amr_wb_dynamic_handler
Definition: rtpdec_amr.c:195
Definition: rtp.h:103
const RTPDynamicProtocolHandler ff_ilbc_dynamic_handler
Definition: rtpdec_ilbc.c:69
int probation
sequence packets till source is valid
Definition: rtpdec.h:84
const RTPDynamicProtocolHandler ff_mpeg_audio_dynamic_handler
Definition: rtpdec_mpeg12.c:52
static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
Definition: rtpdec.c:221
const char * r
Definition: vf_curves.c:114
GLenum GLint * params
Definition: opengl_enc.c:113
#define RTP_SEQ_MOD
Definition: rtpdec.c:208
void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, const RTPDynamicProtocolHandler *handler)
Definition: rtpdec.c:572
GLsizei count
Definition: opengl_enc.c:108
DynamicPayloadPacketHandlerProc parse_packet
Parse handler for this dynamic packet.
Definition: rtpdec.h:135
int64_t rtcp_ts_offset
Definition: rtpdec.h:181
uint32_t timestamp
Definition: rtpdec.h:155
uint32_t transit
relative transit time for previous packet
Definition: rtpdec.h:88
uint32_t jitter
estimated jitter.
Definition: rtpdec.h:89
int queue_len
The number of packets in queue.
Definition: rtpdec.h:172
const RTPDynamicProtocolHandler ff_g726le_16_dynamic_handler
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
int ff_srtp_decrypt(struct SRTPContext *s, uint8_t *buf, int *lenptr)
Definition: srtp.c:126
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
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
Definition: rtp.h:98
const RTPDynamicProtocolHandler ff_qcelp_dynamic_handler
Definition: rtpdec_qcelp.c:212
const RTPDynamicProtocolHandler ff_g726_16_dynamic_handler
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd, AVIOContext *avio)
Definition: rtpdec.c:468
Stream structure.
Definition: avformat.h:876
uint32_t received
packets received
Definition: rtpdec.h:85
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int64_t last_rtcp_reception_time
Definition: rtpdec.h:178
const RTPDynamicProtocolHandler ff_mpegts_dynamic_handler
Definition: rtpdec_mpegts.c:92
RTPDynamicProtocolHandler ff_rdt_audio_handler
const RTPDynamicProtocolHandler ff_g726le_24_dynamic_handler
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
Definition: rtp.h:100
static int rtp_parse_one_packet(RTPDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len)
Definition: rtpdec.c:780
int64_t unwrapped_timestamp
Definition: rtpdec.h:157
uint32_t last_rtcp_timestamp
Definition: rtpdec.h:180
static int has_next_packet(RTPDemuxContext *s)
Definition: rtpdec.c:748
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:203
const RTPDynamicProtocolHandler ff_qt_rtp_vid_handler
const RTPDynamicProtocolHandler ff_mpeg_video_dynamic_handler
Definition: rtpdec_mpeg12.c:60
unsigned int octet_count
Definition: rtpdec.h:185
Definition: url.h:38
RTPStatistics statistics
Statistics for this stream (used by RTCP receiver reports)
Definition: rtpdec.h:167
uint32_t received_prior
packets received in last interval
Definition: rtpdec.h:87
const RTPDynamicProtocolHandler ff_g726_24_dynamic_handler
uint32_t bad_seq
last bad sequence number + 1
Definition: rtpdec.h:83
const RTPDynamicProtocolHandler ff_theora_dynamic_handler
Definition: rtpdec_xiph.c:369
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:245
AVMediaType
Definition: avutil.h:199
int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s)
Definition: rtpdec.c:753
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&#39;t hear from them...
Definition: rtpdec.c:299
#define s1
Definition: regdef.h:38
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:887
static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
This was the second switch in rtp_parse packet.
Definition: rtpdec.c:590
uint16_t max_seq
highest sequence number seen
Definition: rtpdec.h:80
const char * enc_name
Definition: rtpdec.h:116
uint8_t * buf
Definition: rtpdec.h:143
#define RTP_PT_IS_RTCP(x)
Definition: rtp.h:110
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:465
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
#define flags(name, subs,...)
Definition: cbs_av1.c:560
int sample_rate
Audio only.
Definition: codec_par.h:170
const RTPDynamicProtocolHandler ff_svq3_dynamic_handler
Definition: rtpdec_svq3.c:109
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:87
Main libavformat public API header.
const RTPDynamicProtocolHandler ff_h263_rfc2190_dynamic_handler
struct RTPPacket * next
Definition: rtpdec.h:146
uint32_t ssrc
Definition: rtpdec.h:153
static RTPDynamicProtocolHandler realmedia_mp3_dynamic_handler
Definition: rtpdec.c:48
const RTPDynamicProtocolHandler ff_vc2hq_dynamic_handler
Definition: rtpdec_vc2hq.c:219
int64_t recvtime
Definition: rtpdec.h:145
const RTPDynamicProtocolHandler ff_g726_32_dynamic_handler
raw UTF-8 text
Definition: codec_id.h:515
const RTPDynamicProtocolHandler ff_h261_dynamic_handler
Definition: rtpdec_h261.c:165
const RTPDynamicProtocolHandler ff_quicktime_rtp_vid_handler
const RTPDynamicProtocolHandler ff_mpeg4_generic_dynamic_handler
Definition: rtpdec_mpeg4.c:358
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
int den
Denominator.
Definition: rational.h:60
Definition: rtp.h:97
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:925
uint32_t base_timestamp
Definition: rtpdec.h:156
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define av_free(p)
as in Berlin toast format
Definition: codec_id.h:432
int len
const RTPDynamicProtocolHandler ff_h264_dynamic_handler
Definition: rtpdec_h264.c:411
const RTPDynamicProtocolHandler ff_g726_40_dynamic_handler
int ff_srtp_set_crypto(struct SRTPContext *s, const char *suite, const char *params)
Definition: srtp.c:65
const RTPDynamicProtocolHandler ff_dv_dynamic_handler
Definition: rtpdec_dv.c:134
void ff_rtp_parse_close(RTPDemuxContext *s)
Definition: rtpdec.c:880
static RTPDynamicProtocolHandler t140_dynamic_handler
Definition: rtpdec.c:66
const RTPDynamicProtocolHandler ff_h263_1998_dynamic_handler
Definition: rtpdec_h263.c:92
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
and forward the result(frame or status change) to the corresponding input.If nothing is possible
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:387
#define RTP_NOTS_VALUE
Definition: rtpdec.h:40
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:1
static int enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len)
Definition: rtpdec.c:721
#define av_freep(p)
unbuffered private I/O API
static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence)
Definition: rtpdec.c:210
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
RTPDynamicProtocolHandler ff_rdt_live_audio_handler
static RTPDynamicProtocolHandler opus_dynamic_handler
Definition: rtpdec.c:60
int stream_index
Definition: packet.h:365
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
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
int32_t rv
Definition: input.c:405
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:867
AVStream * st
Definition: rtpdec.h:151
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:160
This structure stores compressed data.
Definition: packet.h:340
const RTPDynamicProtocolHandler ff_ac3_dynamic_handler
Definition: rtpdec_ac3.c:125
static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
Definition: rtpdec.c:235
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
const RTPDynamicProtocolHandler ff_vp8_dynamic_handler
Definition: rtpdec_vp8.c:279
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:146
#define MIN_FEEDBACK_INTERVAL
Definition: rtpdec.c:34
#define av_unused
Definition: attributes.h:131
struct SRTPContext srtp
Definition: rtpdec.h:164
const char * name
Definition: opengl_enc.c:102
const RTPDynamicProtocolHandler ff_mpeg_audio_robust_dynamic_handler