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