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