FFmpeg
rtpenc.c
Go to the documentation of this file.
1 /*
2  * RTP output 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 "avformat.h"
23 #include "mpegts.h"
24 #include "internal.h"
25 #include "libavutil/mathematics.h"
26 #include "libavutil/random_seed.h"
27 #include "libavutil/opt.h"
28 
29 #include "rtpenc.h"
30 
31 static const AVOption options[] = {
33  { "payload_type", "Specify RTP payload type", offsetof(RTPMuxContext, payload_type), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 127, AV_OPT_FLAG_ENCODING_PARAM },
34  { "ssrc", "Stream identifier", offsetof(RTPMuxContext, ssrc), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
35  { "cname", "CNAME to include in RTCP SR packets", offsetof(RTPMuxContext, cname), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
36  { "seq", "Starting sequence number", offsetof(RTPMuxContext, seq), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 65535, AV_OPT_FLAG_ENCODING_PARAM },
37  { NULL },
38 };
39 
40 static const AVClass rtp_muxer_class = {
41  .class_name = "RTP muxer",
42  .item_name = av_default_item_name,
43  .option = options,
44  .version = LIBAVUTIL_VERSION_INT,
45 };
46 
47 #define RTCP_SR_SIZE 28
48 
49 static int is_supported(enum AVCodecID id)
50 {
51  switch(id) {
52  case AV_CODEC_ID_DIRAC:
53  case AV_CODEC_ID_H261:
54  case AV_CODEC_ID_H263:
55  case AV_CODEC_ID_H263P:
56  case AV_CODEC_ID_H264:
57  case AV_CODEC_ID_HEVC:
60  case AV_CODEC_ID_MPEG4:
61  case AV_CODEC_ID_AAC:
62  case AV_CODEC_ID_MP2:
63  case AV_CODEC_ID_MP3:
66  case AV_CODEC_ID_PCM_S8:
72  case AV_CODEC_ID_PCM_U8:
74  case AV_CODEC_ID_AMR_NB:
75  case AV_CODEC_ID_AMR_WB:
76  case AV_CODEC_ID_VORBIS:
77  case AV_CODEC_ID_THEORA:
78  case AV_CODEC_ID_VP8:
79  case AV_CODEC_ID_VP9:
83  case AV_CODEC_ID_ILBC:
84  case AV_CODEC_ID_MJPEG:
85  case AV_CODEC_ID_SPEEX:
86  case AV_CODEC_ID_OPUS:
89  return 1;
90  default:
91  return 0;
92  }
93 }
94 
96 {
97  RTPMuxContext *s = s1->priv_data;
98  int n, ret = AVERROR(EINVAL);
99  AVStream *st;
100 
101  if (s1->nb_streams != 1) {
102  av_log(s1, AV_LOG_ERROR, "Only one stream supported in the RTP muxer\n");
103  return AVERROR(EINVAL);
104  }
105  st = s1->streams[0];
106  if (!is_supported(st->codecpar->codec_id)) {
107  av_log(s1, AV_LOG_ERROR, "Unsupported codec %s\n", avcodec_get_name(st->codecpar->codec_id));
108 
109  return -1;
110  }
111 
112  if (s->payload_type < 0) {
113  /* Re-validate non-dynamic payload types */
114  if (st->id < RTP_PT_PRIVATE)
115  st->id = ff_rtp_get_payload_type(s1, st->codecpar, -1);
116 
117  s->payload_type = st->id;
118  } else {
119  /* private option takes priority */
120  st->id = s->payload_type;
121  }
122 
123  s->base_timestamp = av_get_random_seed();
124  s->timestamp = s->base_timestamp;
125  s->cur_timestamp = 0;
126  if (!s->ssrc)
127  s->ssrc = av_get_random_seed();
128  s->first_packet = 1;
129  s->first_rtcp_ntp_time = ff_ntp_time();
130  if (s1->start_time_realtime != 0 && s1->start_time_realtime != AV_NOPTS_VALUE)
131  /* Round the NTP time to whole milliseconds. */
132  s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
134  // Pick a random sequence start number, but in the lower end of the
135  // available range, so that any wraparound doesn't happen immediately.
136  // (Immediate wraparound would be an issue for SRTP.)
137  if (s->seq < 0) {
138  if (s1->flags & AVFMT_FLAG_BITEXACT) {
139  s->seq = 0;
140  } else
141  s->seq = av_get_random_seed() & 0x0fff;
142  } else
143  s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval
144 
145  if (s1->packet_size) {
146  if (s1->pb->max_packet_size)
147  s1->packet_size = FFMIN(s1->packet_size,
148  s1->pb->max_packet_size);
149  } else
150  s1->packet_size = s1->pb->max_packet_size;
151  if (s1->packet_size <= 12) {
152  av_log(s1, AV_LOG_ERROR, "Max packet size %u too low\n", s1->packet_size);
153  return AVERROR(EIO);
154  }
155  s->buf = av_malloc(s1->packet_size);
156  if (!s->buf) {
157  return AVERROR(ENOMEM);
158  }
159  s->max_payload_size = s1->packet_size - 12;
160 
161  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
162  avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
163  } else {
164  avpriv_set_pts_info(st, 32, 1, 90000);
165  }
166  s->buf_ptr = s->buf;
167  switch(st->codecpar->codec_id) {
168  case AV_CODEC_ID_MP2:
169  case AV_CODEC_ID_MP3:
170  s->buf_ptr = s->buf + 4;
171  avpriv_set_pts_info(st, 32, 1, 90000);
172  break;
175  break;
176  case AV_CODEC_ID_MPEG2TS:
177  n = s->max_payload_size / TS_PACKET_SIZE;
178  if (n < 1)
179  n = 1;
180  s->max_payload_size = n * TS_PACKET_SIZE;
181  break;
182  case AV_CODEC_ID_DIRAC:
183  if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
185  "Packetizing VC-2 is experimental and does not use all values "
186  "of the specification "
187  "(even though most receivers may handle it just fine). "
188  "Please set -strict experimental in order to enable it.\n");
190  goto fail;
191  }
192  break;
193  case AV_CODEC_ID_H261:
194  if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
196  "Packetizing H.261 is experimental and produces incorrect "
197  "packetization for cases where GOBs don't fit into packets "
198  "(even though most receivers may handle it just fine). "
199  "Please set -f_strict experimental in order to enable it.\n");
201  goto fail;
202  }
203  break;
204  case AV_CODEC_ID_H264:
205  /* check for H.264 MP4 syntax */
206  if (st->codecpar->extradata_size > 4 && st->codecpar->extradata[0] == 1) {
207  s->nal_length_size = (st->codecpar->extradata[4] & 0x03) + 1;
208  }
209  break;
210  case AV_CODEC_ID_HEVC:
211  /* Only check for the standardized hvcC version of extradata, keeping
212  * things simple and similar to the avcC/H.264 case above, instead
213  * of trying to handle the pre-standardization versions (as in
214  * libavcodec/hevc.c). */
215  if (st->codecpar->extradata_size > 21 && st->codecpar->extradata[0] == 1) {
216  s->nal_length_size = (st->codecpar->extradata[21] & 0x03) + 1;
217  }
218  break;
219  case AV_CODEC_ID_VP9:
220  if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
222  "Packetizing VP9 is experimental and its specification is "
223  "still in draft state. "
224  "Please set -strict experimental in order to enable it.\n");
226  goto fail;
227  }
228  break;
229  case AV_CODEC_ID_VORBIS:
230  case AV_CODEC_ID_THEORA:
231  s->max_frames_per_packet = 15;
232  break;
234  /* Due to a historical error, the clock rate for G722 in RTP is
235  * 8000, even if the sample rate is 16000. See RFC 3551. */
236  avpriv_set_pts_info(st, 32, 1, 8000);
237  break;
238  case AV_CODEC_ID_OPUS:
239  if (st->codecpar->ch_layout.nb_channels > 2) {
240  av_log(s1, AV_LOG_ERROR, "Multistream opus not supported in RTP\n");
241  goto fail;
242  }
243  /* The opus RTP RFC says that all opus streams should use 48000 Hz
244  * as clock rate, since all opus sample rates can be expressed in
245  * this clock rate, and sample rate changes on the fly are supported. */
246  avpriv_set_pts_info(st, 32, 1, 48000);
247  break;
248  case AV_CODEC_ID_ILBC:
249  if (st->codecpar->block_align != 38 && st->codecpar->block_align != 50) {
250  av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
251  goto fail;
252  }
253  s->max_frames_per_packet = s->max_payload_size / st->codecpar->block_align;
254  break;
255  case AV_CODEC_ID_AMR_NB:
256  case AV_CODEC_ID_AMR_WB:
257  s->max_frames_per_packet = 50;
259  n = 31;
260  else
261  n = 61;
262  /* max_header_toc_size + the largest AMR payload must fit */
263  if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
264  av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");
265  goto fail;
266  }
267  if (st->codecpar->ch_layout.nb_channels != 1) {
268  av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
269  goto fail;
270  }
271  break;
272  case AV_CODEC_ID_AAC:
273  s->max_frames_per_packet = 50;
274  break;
275  default:
276  break;
277  }
278 
279  return 0;
280 
281 fail:
282  av_freep(&s->buf);
283  return ret;
284 }
285 
286 /* send an rtcp sender report packet */
287 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
288 {
289  RTPMuxContext *s = s1->priv_data;
290  uint32_t rtp_ts;
291 
292  av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %"PRIx32"\n", s->payload_type, ntp_time, s->timestamp);
293 
294  s->last_rtcp_ntp_time = ntp_time;
295  rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
296  s1->streams[0]->time_base) + s->base_timestamp;
297  avio_w8(s1->pb, RTP_VERSION << 6);
298  avio_w8(s1->pb, RTCP_SR);
299  avio_wb16(s1->pb, 6); /* length in words - 1 */
300  avio_wb32(s1->pb, s->ssrc);
301  avio_wb32(s1->pb, ntp_time / 1000000);
302  avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
303  avio_wb32(s1->pb, rtp_ts);
304  avio_wb32(s1->pb, s->packet_count);
305  avio_wb32(s1->pb, s->octet_count);
306 
307  if (s->cname) {
308  int len = FFMIN(strlen(s->cname), 255);
309  avio_w8(s1->pb, (RTP_VERSION << 6) + 1);
310  avio_w8(s1->pb, RTCP_SDES);
311  avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */
312 
313  avio_wb32(s1->pb, s->ssrc);
314  avio_w8(s1->pb, 0x01); /* CNAME */
315  avio_w8(s1->pb, len);
316  avio_write(s1->pb, s->cname, len);
317  avio_w8(s1->pb, 0); /* END */
318  for (len = (7 + len) % 4; len % 4; len++)
319  avio_w8(s1->pb, 0);
320  }
321 
322  if (bye) {
323  avio_w8(s1->pb, (RTP_VERSION << 6) | 1);
324  avio_w8(s1->pb, RTCP_BYE);
325  avio_wb16(s1->pb, 1); /* length in words - 1 */
326  avio_wb32(s1->pb, s->ssrc);
327  }
328 
329  avio_flush(s1->pb);
330 }
331 
332 /* send an rtp packet. sequence number is incremented, but the caller
333  must update the timestamp itself */
334 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
335 {
336  RTPMuxContext *s = s1->priv_data;
337 
338  av_log(s1, AV_LOG_TRACE, "rtp_send_data size=%d\n", len);
339 
340  /* build the RTP header */
341  avio_w8(s1->pb, RTP_VERSION << 6);
342  avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
343  avio_wb16(s1->pb, s->seq);
344  avio_wb32(s1->pb, s->timestamp);
345  avio_wb32(s1->pb, s->ssrc);
346 
347  avio_write(s1->pb, buf1, len);
348  avio_flush(s1->pb);
349 
350  s->seq = (s->seq + 1) & 0xffff;
351  s->octet_count += len;
352  s->packet_count++;
353 }
354 
355 /* send an integer number of samples and compute time stamp and fill
356  the rtp send buffer before sending. */
358  const uint8_t *buf1, int size, int sample_size_bits)
359 {
360  RTPMuxContext *s = s1->priv_data;
361  int len, max_packet_size, n;
362  /* Calculate the number of bytes to get samples aligned on a byte border */
363  int aligned_samples_size = sample_size_bits/av_gcd(sample_size_bits, 8);
364 
365  max_packet_size = (s->max_payload_size / aligned_samples_size) * aligned_samples_size;
366  /* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */
367  if ((sample_size_bits % 8) == 0 && ((8 * size) % sample_size_bits) != 0)
368  return AVERROR(EINVAL);
369  n = 0;
370  while (size > 0) {
371  s->buf_ptr = s->buf;
372  len = FFMIN(max_packet_size, size);
373 
374  /* copy data */
375  memcpy(s->buf_ptr, buf1, len);
376  s->buf_ptr += len;
377  buf1 += len;
378  size -= len;
379  s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits;
380  ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
381  n += (s->buf_ptr - s->buf);
382  }
383  return 0;
384 }
385 
387  const uint8_t *buf1, int size)
388 {
389  RTPMuxContext *s = s1->priv_data;
390  int len, count, max_packet_size;
391 
392  max_packet_size = s->max_payload_size;
393 
394  /* test if we must flush because not enough space */
395  len = (s->buf_ptr - s->buf);
396  if ((len + size) > max_packet_size) {
397  if (len > 4) {
398  ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
399  s->buf_ptr = s->buf + 4;
400  }
401  }
402  if (s->buf_ptr == s->buf + 4) {
403  s->timestamp = s->cur_timestamp;
404  }
405 
406  /* add the packet */
407  if (size > max_packet_size) {
408  /* big packet: fragment */
409  count = 0;
410  while (size > 0) {
411  len = max_packet_size - 4;
412  if (len > size)
413  len = size;
414  /* build fragmented packet */
415  s->buf[0] = 0;
416  s->buf[1] = 0;
417  s->buf[2] = count >> 8;
418  s->buf[3] = count;
419  memcpy(s->buf + 4, buf1, len);
420  ff_rtp_send_data(s1, s->buf, len + 4, 0);
421  size -= len;
422  buf1 += len;
423  count += len;
424  }
425  } else {
426  if (s->buf_ptr == s->buf + 4) {
427  /* no fragmentation possible */
428  s->buf[0] = 0;
429  s->buf[1] = 0;
430  s->buf[2] = 0;
431  s->buf[3] = 0;
432  }
433  memcpy(s->buf_ptr, buf1, size);
434  s->buf_ptr += size;
435  }
436 }
437 
439  const uint8_t *buf1, int size)
440 {
441  RTPMuxContext *s = s1->priv_data;
442  int len, max_packet_size;
443 
444  max_packet_size = s->max_payload_size;
445 
446  while (size > 0) {
447  len = max_packet_size;
448  if (len > size)
449  len = size;
450 
451  s->timestamp = s->cur_timestamp;
452  ff_rtp_send_data(s1, buf1, len, (len == size));
453 
454  buf1 += len;
455  size -= len;
456  }
457 }
458 
459 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
461  const uint8_t *buf1, int size)
462 {
463  RTPMuxContext *s = s1->priv_data;
464  int len, out_len;
465 
466  s->timestamp = s->cur_timestamp;
467  while (size >= TS_PACKET_SIZE) {
468  len = s->max_payload_size - (s->buf_ptr - s->buf);
469  if (len > size)
470  len = size;
471  memcpy(s->buf_ptr, buf1, len);
472  buf1 += len;
473  size -= len;
474  s->buf_ptr += len;
475 
476  out_len = s->buf_ptr - s->buf;
477  if (out_len >= s->max_payload_size) {
478  ff_rtp_send_data(s1, s->buf, out_len, 0);
479  s->buf_ptr = s->buf;
480  }
481  }
482 }
483 
484 static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
485 {
486  RTPMuxContext *s = s1->priv_data;
487  AVStream *st = s1->streams[0];
488  int frame_duration = av_get_audio_frame_duration2(st->codecpar, 0);
489  int frame_size = st->codecpar->block_align;
490  int frames = size / frame_size;
491 
492  while (frames > 0) {
493  if (s->num_frames > 0 &&
494  av_compare_ts(s->cur_timestamp - s->timestamp, st->time_base,
495  s1->max_delay, AV_TIME_BASE_Q) >= 0) {
496  ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
497  s->num_frames = 0;
498  }
499 
500  if (!s->num_frames) {
501  s->buf_ptr = s->buf;
502  s->timestamp = s->cur_timestamp;
503  }
504  memcpy(s->buf_ptr, buf, frame_size);
505  frames--;
506  s->num_frames++;
507  s->buf_ptr += frame_size;
508  buf += frame_size;
509  s->cur_timestamp += frame_duration;
510 
511  if (s->num_frames == s->max_frames_per_packet) {
512  ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
513  s->num_frames = 0;
514  }
515  }
516  return 0;
517 }
518 
520 {
521  RTPMuxContext *s = s1->priv_data;
522  AVStream *st = s1->streams[0];
523  int rtcp_bytes;
524  int size= pkt->size;
525 
526  av_log(s1, AV_LOG_TRACE, "%d: write len=%d\n", pkt->stream_index, size);
527 
528  rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
530  if ((s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
531  (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) &&
532  !(s->flags & FF_RTP_FLAG_SKIP_RTCP)) {
533  rtcp_send_sr(s1, ff_ntp_time(), 0);
534  s->last_octet_count = s->octet_count;
535  s->first_packet = 0;
536  }
537  s->cur_timestamp = s->base_timestamp + pkt->pts;
538 
539  switch(st->codecpar->codec_id) {
542  case AV_CODEC_ID_PCM_U8:
543  case AV_CODEC_ID_PCM_S8:
553  /* The actual sample size is half a byte per sample, but since the
554  * stream clock rate is 8000 Hz while the sample rate is 16000 Hz,
555  * the correct parameter for send_samples_bits is 8 bits per stream
556  * clock. */
560  return rtp_send_samples(s1, pkt->data, size,
562  case AV_CODEC_ID_MP2:
563  case AV_CODEC_ID_MP3:
565  break;
569  break;
570  case AV_CODEC_ID_AAC:
571  if (s->flags & FF_RTP_FLAG_MP4A_LATM)
573  else
575  break;
576  case AV_CODEC_ID_AMR_NB:
577  case AV_CODEC_ID_AMR_WB:
579  break;
580  case AV_CODEC_ID_MPEG2TS:
582  break;
583  case AV_CODEC_ID_DIRAC:
585  break;
586  case AV_CODEC_ID_H264:
588  break;
589  case AV_CODEC_ID_H261:
591  break;
592  case AV_CODEC_ID_H263:
593  if (s->flags & FF_RTP_FLAG_RFC2190) {
594  size_t mb_info_size;
595  const uint8_t *mb_info =
597  &mb_info_size);
598  ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size);
599  break;
600  }
601  /* Fallthrough */
602  case AV_CODEC_ID_H263P:
604  break;
605  case AV_CODEC_ID_HEVC:
607  break;
608  case AV_CODEC_ID_VORBIS:
609  case AV_CODEC_ID_THEORA:
611  break;
612  case AV_CODEC_ID_VP8:
614  break;
615  case AV_CODEC_ID_VP9:
617  break;
618  case AV_CODEC_ID_ILBC:
620  break;
621  case AV_CODEC_ID_MJPEG:
623  break;
625  case AV_CODEC_ID_RAWVIDEO: {
627 
629  if (interlaced)
631  break;
632  }
633  case AV_CODEC_ID_OPUS:
634  if (size > s->max_payload_size) {
636  "Packet size %d too large for max RTP payload size %d\n",
637  size, s->max_payload_size);
638  return AVERROR(EINVAL);
639  }
640  /* Intentional fallthrough */
641  default:
642  /* better than nothing : send the codec raw data */
644  break;
645  }
646  return 0;
647 }
648 
650 {
651  RTPMuxContext *s = s1->priv_data;
652 
653  /* If the caller closes and recreates ->pb, this might actually
654  * be NULL here even if it was successfully allocated at the start. */
655  if (s1->pb && (s->flags & FF_RTP_FLAG_SEND_BYE))
656  rtcp_send_sr(s1, ff_ntp_time(), 1);
657  av_freep(&s->buf);
658 
659  return 0;
660 }
661 
663  .name = "rtp",
664  .long_name = NULL_IF_CONFIG_SMALL("RTP output"),
665  .priv_data_size = sizeof(RTPMuxContext),
666  .audio_codec = AV_CODEC_ID_PCM_MULAW,
667  .video_codec = AV_CODEC_ID_MPEG4,
671  .priv_class = &rtp_muxer_class,
673 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:317
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:75
ff_rtp_send_aac
void ff_rtp_send_aac(AVFormatContext *s1, const uint8_t *buff, int size)
Definition: rtpenc_aac.c:27
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:74
rtp_write_header
static int rtp_write_header(AVFormatContext *s1)
Definition: rtpenc.c:95
ff_ntp_time
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:258
FF_RTP_FLAG_MP4A_LATM
#define FF_RTP_FLAG_MP4A_LATM
Definition: rtpenc.h:68
AVOutputFormat::name
const char * name
Definition: avformat.h:510
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
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
ff_rtp_send_jpeg
void ff_rtp_send_jpeg(AVFormatContext *s1, const uint8_t *buff, int size)
Definition: rtpenc_jpeg.c:28
mpegts.h
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1305
ff_rtp_send_h263_rfc2190
void ff_rtp_send_h263_rfc2190(AVFormatContext *s1, const uint8_t *buf1, int size, const uint8_t *mb_info, int mb_info_size)
Definition: rtpenc_h263_rfc2190.c:101
ff_rtp_send_h261
void ff_rtp_send_h261(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition: rtpenc_h261.c:39
RTP_VERSION
#define RTP_VERSION
Definition: rtp.h:80
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:166
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:63
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:409
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:384
ff_rtp_send_data
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
Definition: rtpenc.c:334
mathematics.h
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
FF_RTP_FLAG_RFC2190
#define FF_RTP_FLAG_RFC2190
Definition: rtpenc.h:69
FF_RTP_FLAG_OPTS
#define FF_RTP_FLAG_OPTS(ctx, fieldname)
Definition: rtpenc.h:74
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:410
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:53
av_get_random_seed
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
av_get_audio_frame_duration2
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:832
ff_rtp_send_mpegvideo
void ff_rtp_send_mpegvideo(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition: rtpenc_mpv.c:29
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:697
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:461
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:318
fail
#define fail()
Definition: checkasm.h:131
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
rtp_write_trailer
static int rtp_write_trailer(AVFormatContext *s1)
Definition: rtpenc.c:649
ff_rtp_send_latm
void ff_rtp_send_latm(AVFormatContext *s1, const uint8_t *buff, int size)
Definition: rtpenc_latm.c:25
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:427
ff_rtp_send_raw_rfc4175
void ff_rtp_send_raw_rfc4175(AVFormatContext *s1, const uint8_t *buf, int size, int interlaced, int field)
Definition: rtpenc_rfc4175.c:24
FF_RTP_FLAG_SKIP_RTCP
#define FF_RTP_FLAG_SKIP_RTCP
Definition: rtpenc.h:70
rtp_send_ilbc
static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
Definition: rtpenc.c:484
is_supported
static int is_supported(enum AVCodecID id)
Definition: rtpenc.c:49
options
static const AVOption options[]
Definition: rtpenc.c:31
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:321
ff_rtp_muxer
const AVOutputFormat ff_rtp_muxer
Definition: rtpenc.c:662
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
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:367
RTCP_TX_RATIO_NUM
#define RTCP_TX_RATIO_NUM
Definition: rtp.h:84
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:281
frame_size
int frame_size
Definition: mxfenc.c:2201
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:218
s1
#define s1
Definition: regdef.h:38
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:426
RTCP_TX_RATIO_DEN
#define RTCP_TX_RATIO_DEN
Definition: rtp.h:85
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:323
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:320
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:252
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:324
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
RTP_PT_PRIVATE
#define RTP_PT_PRIVATE
Definition: rtp.h:79
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:978
NULL
#define NULL
Definition: coverity.c:32
RTCP_SDES
@ RTCP_SDES
Definition: rtp.h:101
rtp_send_raw
static void rtp_send_raw(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition: rtpenc.c:438
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:100
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_CODEC_ID_MPEG2TS
@ AV_CODEC_ID_MPEG2TS
FAKE codec to indicate a raw MPEG-2 TS stream (only used by libavformat)
Definition: codec_id.h:571
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:210
RTPMuxContext
Definition: rtpenc.h:27
rtp_muxer_class
static const AVClass rtp_muxer_class
Definition: rtpenc.c:40
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:51
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:79
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:428
rtp_send_samples
static int rtp_send_samples(AVFormatContext *s1, const uint8_t *buf1, int size, int sample_size_bits)
Definition: rtpenc.c:357
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:54
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
NTP_OFFSET_US
#define NTP_OFFSET_US
Definition: internal.h:467
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:486
AV_PKT_DATA_H263_MB_INFO
@ AV_PKT_DATA_H263_MB_INFO
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
Definition: packet.h:94
rtp_send_mpegts_raw
static void rtp_send_mpegts_raw(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition: rtpenc.c:460
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
AV_CODEC_ID_BITPACKED
@ AV_CODEC_ID_BITPACKED
Definition: codec_id.h:280
RTCP_SR_SIZE
#define RTCP_SR_SIZE
Definition: rtpenc.c:47
rtcp_send_sr
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
Definition: rtpenc.c:287
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:447
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
interlaced
uint8_t interlaced
Definition: mxfenc.c:2042
AVOutputFormat
Definition: avformat.h:509
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:251
AV_CODEC_ID_THEORA
@ AV_CODEC_ID_THEORA
Definition: codec_id.h:80
ff_rtp_send_vp8
void ff_rtp_send_vp8(AVFormatContext *s1, const uint8_t *buff, int size)
Definition: rtpenc_vp8.c:26
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:184
FF_RTP_FLAG_SEND_BYE
#define FF_RTP_FLAG_SEND_BYE
Definition: rtpenc.h:72
RTCP_BYE
@ RTCP_BYE
Definition: rtp.h:102
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:224
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_rtp_send_vp9
void ff_rtp_send_vp9(AVFormatContext *s1, const uint8_t *buff, int size)
Definition: rtpenc_vp9.c:26
len
int len
Definition: vorbis_enc_data.h:426
ff_rtp_send_vc2hq
void ff_rtp_send_vc2hq(AVFormatContext *s1, const uint8_t *buf, int size, int interlaced)
Definition: rtpenc_vc2hq.c:102
rtpenc.h
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:142
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:491
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:962
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1348
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
avformat.h
ff_rtp_send_h264_hevc
void ff_rtp_send_h264_hevc(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition: rtpenc_h264_hevc.c:180
ff_rtp_send_amr
void ff_rtp_send_amr(AVFormatContext *s1, const uint8_t *buff, int size)
Packetize AMR frames into RTP packets according to RFC 3267, in octet-aligned mode.
Definition: rtpenc_amr.c:30
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:69
random_seed.h
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:391
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
ff_rtp_send_h263
void ff_rtp_send_h263(AVFormatContext *s1, const uint8_t *buf1, int size)
Packetize H.263 frames into RTP packets according to RFC 4629.
Definition: rtpenc_h263.c:43
RTCP_SR
@ RTCP_SR
Definition: rtp.h:99
AVPacket::stream_index
int stream_index
Definition: packet.h:376
rtp_write_packet
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: rtpenc.c:519
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:103
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:322
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:39
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_CODEC_ID_ILBC
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:485
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:319
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:190
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
TS_PACKET_SIZE
#define TS_PACKET_SIZE
Definition: mpegts.h:29
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:431
ff_rtp_send_xiph
void ff_rtp_send_xiph(AVFormatContext *s1, const uint8_t *buff, int size)
Packetize Xiph frames into RTP according to RFC 5215 (Vorbis) and the Theora RFC draft.
Definition: rtpenc_xiph.c:33
write_packet
static int write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: v4l2enc.c:92
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
rtp_send_mpegaudio
static void rtp_send_mpegaudio(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition: rtpenc.c:386
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:330
mb_info
Definition: cinepakenc.c:88
ff_rtp_get_payload_type
int ff_rtp_get_payload_type(const AVFormatContext *fmt, const AVCodecParameters *par, int idx)
Return the payload type for a given stream used in the given format context.
Definition: rtp.c:93