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