FFmpeg
Loading...
Searching...
No Matches
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"
24#include "mpegts.h"
25#include "internal.h"
26#include "mux.h"
28#include "libavutil/mem.h"
30#include "libavutil/opt.h"
31
32#include "rtpenc.h"
33
34static const AVOption options[] = {
36 { "payload_type", "Specify RTP payload type", offsetof(RTPMuxContext, payload_type), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 127, AV_OPT_FLAG_ENCODING_PARAM },
37 { "ssrc", "Stream identifier", offsetof(RTPMuxContext, ssrc), AV_OPT_TYPE_UINT, { .i64 = 0 }, 0, UINT32_MAX, AV_OPT_FLAG_ENCODING_PARAM },
38 { "cname", "CNAME to include in RTCP SR packets", offsetof(RTPMuxContext, cname), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
39 { "seq", "Starting sequence number", offsetof(RTPMuxContext, seq), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 65535, AV_OPT_FLAG_ENCODING_PARAM },
40 { NULL },
41};
42
43static const AVClass rtp_muxer_class = {
44 .class_name = "RTP muxer",
45 .item_name = av_default_item_name,
46 .option = options,
47 .version = LIBAVUTIL_VERSION_INT,
48};
49
50#define RTCP_SR_SIZE 28
51
99
101{
103 int n, ret = AVERROR(EINVAL);
104 int payload_header_size = 0;
105 AVStream *st;
106
107 if (s1->nb_streams != 1) {
108 av_log(s1, AV_LOG_ERROR, "Only one stream supported in the RTP muxer\n");
109 return AVERROR(EINVAL);
110 }
111 st = s1->streams[0];
112 if (!is_supported(st->codecpar->codec_id)) {
113 av_log(s1, AV_LOG_ERROR, "Unsupported codec %s\n", avcodec_get_name(st->codecpar->codec_id));
114
115 return -1;
116 }
117
118 if (s->payload_type < 0) {
119 /* Re-validate non-dynamic payload types */
120 if (st->id < RTP_PT_PRIVATE)
121 st->id = ff_rtp_get_payload_type(s1, st->codecpar, -1);
122
123 s->payload_type = st->id;
124 } else {
125 /* private option takes priority */
126 st->id = s->payload_type;
127 }
128
129 s->base_timestamp = av_get_random_seed();
130 s->timestamp = s->base_timestamp;
131 s->cur_timestamp = 0;
132 if (!s->ssrc)
133 s->ssrc = av_get_random_seed();
134 s->first_packet = 1;
135 s->first_rtcp_ntp_time = ff_ntp_time();
137 /* Round the NTP time to whole milliseconds. */
138 s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
140 // Pick a random sequence start number, but in the lower end of the
141 // available range, so that any wraparound doesn't happen immediately.
142 // (Immediate wraparound would be an issue for SRTP.)
143 if (s->seq < 0) {
144 if (s1->flags & AVFMT_FLAG_BITEXACT) {
145 s->seq = 0;
146 } else
147 s->seq = av_get_random_seed() & 0x0fff;
148 } else
149 s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval
150
151 if (s1->packet_size) {
152 if (s1->pb->max_packet_size)
153 s1->packet_size = FFMIN(s1->packet_size,
154 s1->pb->max_packet_size);
155 } else
156 s1->packet_size = s1->pb->max_packet_size;
157 if (s1->packet_size <= 12) {
158 av_log(s1, AV_LOG_ERROR, "Max packet size %u too low\n", s1->packet_size);
159 return AVERROR(EIO);
160 }
161 s->buf = av_malloc(s1->packet_size);
162 if (!s->buf) {
163 return AVERROR(ENOMEM);
164 }
165 s->max_payload_size = s1->packet_size - 12;
166
169 } else {
170 avpriv_set_pts_info(st, 32, 1, 90000);
171 }
172 s->buf_ptr = s->buf;
173 switch(st->codecpar->codec_id) {
174 case AV_CODEC_ID_MP2:
175 case AV_CODEC_ID_MP3:
176 s->buf_ptr = s->buf + 4;
177 payload_header_size = 4;
178 avpriv_set_pts_info(st, 32, 1, 90000);
179 break;
182 payload_header_size = 4;
183 break;
185 if (s->max_payload_size < TS_PACKET_SIZE) {
187 "RTP payload size %u too small for MPEG-TS "
188 "(minimum %d bytes required)\n",
189 s->max_payload_size, TS_PACKET_SIZE);
190 ret = AVERROR(EINVAL);
191 goto fail;
192 }
193
194 n = s->max_payload_size / TS_PACKET_SIZE;
195 s->max_payload_size = n * TS_PACKET_SIZE;
196 break;
200 "Packetizing VC-2 is experimental and does not use all values "
201 "of the specification "
202 "(even though most receivers may handle it just fine). "
203 "Please set -strict experimental in order to enable it.\n");
205 goto fail;
206 }
207 payload_header_size = 20;
208 break;
209 case AV_CODEC_ID_H263:
210 if (s->flags & FF_RTP_FLAG_RFC2190) {
211 payload_header_size = 8;
212 break;
213 }
216 payload_header_size = 2;
217 break;
218 case AV_CODEC_ID_H261:
221 "Packetizing H.261 is experimental and produces incorrect "
222 "packetization for cases where GOBs don't fit into packets "
223 "(even though most receivers may handle it just fine). "
224 "Please set -f_strict experimental in order to enable it.\n");
226 goto fail;
227 }
228 payload_header_size = 4;
229 break;
230 case AV_CODEC_ID_H264:
231 /* check for H.264 MP4 syntax */
232 if (st->codecpar->extradata_size > 4 && st->codecpar->extradata[0] == 1) {
233 s->nal_length_size = (st->codecpar->extradata[4] & 0x03) + 1;
234 }
235 payload_header_size = 2;
236 break;
237 case AV_CODEC_ID_HEVC:
238 /* Only check for the standardized hvcC version of extradata, keeping
239 * things simple and similar to the avcC/H.264 case above, instead
240 * of trying to handle the pre-standardization versions (as in
241 * libavcodec/hevc.c). */
242 if (st->codecpar->extradata_size > 21 && st->codecpar->extradata[0] == 1) {
243 s->nal_length_size = (st->codecpar->extradata[21] & 0x03) + 1;
244 }
245 payload_header_size = 3;
246 break;
247 case AV_CODEC_ID_VP8:
248 payload_header_size = 4;
249 break;
252 if (st->codecpar->width > 32767 || st->codecpar->height > 32767) {
253 av_log(s1, AV_LOG_ERROR, "dimensions %dx%d too large for RFC 4175\n",
254 st->codecpar->width, st->codecpar->height);
255 return AVERROR(EINVAL);
256 }
259 if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {
260 av_log(s1, AV_LOG_ERROR, "dimensions not set\n");
261 return AVERROR(EINVAL);
262 }
263 break;
264 case AV_CODEC_ID_VP9:
267 "Packetizing VP9 is experimental and its specification is "
268 "still in draft state. "
269 "Please set -strict experimental in order to enable it.\n");
271 goto fail;
272 }
273 payload_header_size = 1;
274 break;
275 case AV_CODEC_ID_AV1:
278 "Packetizing AV1 is experimental and its specification is "
279 "still in draft state. "
280 "Please set -strict experimental in order to enable it.\n");
282 goto fail;
283 }
284 payload_header_size = 3;
285 break;
288 s->max_frames_per_packet = 15;
289 break;
291 /* Due to a historical error, the clock rate for G722 in RTP is
292 * 8000, even if the sample rate is 16000. See RFC 3551. */
293 avpriv_set_pts_info(st, 32, 1, 8000);
294 break;
295 case AV_CODEC_ID_OPUS:
296 if (st->codecpar->ch_layout.nb_channels > 2) {
297 av_log(s1, AV_LOG_ERROR, "Multistream opus not supported in RTP\n");
298 goto fail;
299 }
300 /* The opus RTP RFC says that all opus streams should use 48000 Hz
301 * as clock rate, since all opus sample rates can be expressed in
302 * this clock rate, and sample rate changes on the fly are supported. */
303 avpriv_set_pts_info(st, 32, 1, 48000);
304 break;
305 case AV_CODEC_ID_ILBC:
306 if (st->codecpar->block_align != 38 && st->codecpar->block_align != 50) {
307 av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
308 goto fail;
309 }
310 s->max_frames_per_packet = s->max_payload_size / st->codecpar->block_align;
311 if (!s->max_frames_per_packet) {
312 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for iLBC\n");
313 goto fail;
314 }
315 break;
318 s->max_frames_per_packet = 50;
320 n = 31;
321 else
322 n = 61;
323 /* max_header_toc_size + the largest AMR payload must fit */
324 if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
325 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");
326 goto fail;
327 }
328 if (st->codecpar->ch_layout.nb_channels != 1) {
329 av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
330 goto fail;
331 }
332 break;
333 case AV_CODEC_ID_AAC:
334 s->max_frames_per_packet = 50;
335 if (!(s->flags & FF_RTP_FLAG_MP4A_LATM))
336 payload_header_size = 4;
337 break;
338 default:
339 break;
340 }
341
342 if (s->max_payload_size <= payload_header_size) {
343 av_log(s1, AV_LOG_ERROR, "Max packet size %u too low for a %d byte payload header\n",
344 s1->packet_size, payload_header_size);
345 goto fail;
346 }
347
348 return 0;
349
350fail:
351 av_freep(&s->buf);
352 return ret;
353}
354
355/* send an rtcp sender report packet */
356static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
357{
359 uint32_t rtp_ts;
360
361 av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %"PRIx32"\n", s->payload_type, ntp_time, s->timestamp);
362
363 s->last_rtcp_ntp_time = ntp_time;
364 rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
365 s1->streams[0]->time_base) + s->base_timestamp;
366 avio_w8(s1->pb, RTP_VERSION << 6);
367 avio_w8(s1->pb, RTCP_SR);
368 avio_wb16(s1->pb, 6); /* length in words - 1 */
369 avio_wb32(s1->pb, s->ssrc);
370 avio_wb32(s1->pb, ntp_time / 1000000);
371 avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
372 avio_wb32(s1->pb, rtp_ts);
373 avio_wb32(s1->pb, s->packet_count);
374 avio_wb32(s1->pb, s->octet_count);
375
376 if (s->cname) {
377 int len = FFMIN(strlen(s->cname), 255);
378 avio_w8(s1->pb, (RTP_VERSION << 6) + 1);
379 avio_w8(s1->pb, RTCP_SDES);
380 avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */
381
382 avio_wb32(s1->pb, s->ssrc);
383 avio_w8(s1->pb, 0x01); /* CNAME */
384 avio_w8(s1->pb, len);
385 avio_write(s1->pb, s->cname, len);
386 avio_w8(s1->pb, 0); /* END */
387 for (len = (7 + len) % 4; len % 4; len++)
388 avio_w8(s1->pb, 0);
389 }
390
391 if (bye) {
392 avio_w8(s1->pb, (RTP_VERSION << 6) | 1);
393 avio_w8(s1->pb, RTCP_BYE);
394 avio_wb16(s1->pb, 1); /* length in words - 1 */
395 avio_wb32(s1->pb, s->ssrc);
396 }
397
398 avio_flush(s1->pb);
399}
400
401/* send an rtp packet. sequence number is incremented, but the caller
402 must update the timestamp itself */
403void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
404{
406
407 av_log(s1, AV_LOG_TRACE, "rtp_send_data size=%d\n", len);
408
409 /* build the RTP header */
410 avio_w8(s1->pb, RTP_VERSION << 6);
411 avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
412 avio_wb16(s1->pb, s->seq);
413 avio_wb32(s1->pb, s->timestamp);
414 avio_wb32(s1->pb, s->ssrc);
415
416 avio_write(s1->pb, buf1, len);
417 avio_flush(s1->pb);
418
419 s->seq = (s->seq + 1) & 0xffff;
420 if (!s->seq)
421 s->seq_high++;
422 s->octet_count += len;
423 s->packet_count++;
424}
425
426/* send an integer number of samples and compute time stamp and fill
427 the rtp send buffer before sending. */
429 const uint8_t *buf1, int size, int bits_per_sample)
430{
432 int nb_channels = s1->streams[0]->codecpar->ch_layout.nb_channels;
433 int len, max_packet_size, n;
434
435 if (bits_per_sample <= 0 || nb_channels <= 0 ||
436 nb_channels > INT_MAX / bits_per_sample) {
437 av_log(s1, AV_LOG_ERROR, "Invalid sample size %d or channel count %d\n",
438 bits_per_sample, nb_channels);
439 return AVERROR(EINVAL);
440 }
441 int sample_size_bits = bits_per_sample * nb_channels;
442 /* Calculate the number of bytes to get samples aligned on a byte border */
443 int aligned_samples_size = sample_size_bits/av_gcd(sample_size_bits, 8);
444
445 max_packet_size = (s->max_payload_size / aligned_samples_size) * aligned_samples_size;
446 if (!max_packet_size) {
447 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for %d byte samples\n",
448 aligned_samples_size);
449 return AVERROR(EINVAL);
450 }
451 /* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */
452 if ((sample_size_bits % 8) == 0 && ((8 * size) % sample_size_bits) != 0)
453 return AVERROR(EINVAL);
454 n = 0;
455 while (size > 0) {
456 s->buf_ptr = s->buf;
457 len = FFMIN(max_packet_size, size);
458
459 /* copy data */
460 memcpy(s->buf_ptr, buf1, len);
461 s->buf_ptr += len;
462 buf1 += len;
463 size -= len;
464 s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits;
465 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
466 n += (s->buf_ptr - s->buf);
467 }
468 return 0;
469}
470
472 const uint8_t *buf1, int size)
473{
475 int len, count, max_packet_size;
476
477 max_packet_size = s->max_payload_size;
478
479 /* test if we must flush because not enough space */
480 len = (s->buf_ptr - s->buf);
481 if ((len + size) > max_packet_size) {
482 if (len > 4) {
483 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
484 s->buf_ptr = s->buf + 4;
485 }
486 }
487 if (s->buf_ptr == s->buf + 4) {
488 s->timestamp = s->cur_timestamp;
489 }
490
491 /* add the packet */
492 if (size > max_packet_size - 4) {
493 /* big packet: fragment */
494 count = 0;
495 while (size > 0) {
496 len = max_packet_size - 4;
497 if (len > size)
498 len = size;
499 /* build fragmented packet */
500 s->buf[0] = 0;
501 s->buf[1] = 0;
502 s->buf[2] = count >> 8;
503 s->buf[3] = count;
504 memcpy(s->buf + 4, buf1, len);
505 ff_rtp_send_data(s1, s->buf, len + 4, 0);
506 size -= len;
507 buf1 += len;
508 count += len;
509 }
510 } else {
511 if (s->buf_ptr == s->buf + 4) {
512 /* no fragmentation possible */
513 s->buf[0] = 0;
514 s->buf[1] = 0;
515 s->buf[2] = 0;
516 s->buf[3] = 0;
517 }
518 memcpy(s->buf_ptr, buf1, size);
519 s->buf_ptr += size;
520 }
521}
522
524 const uint8_t *buf1, int size)
525{
527 int len, max_packet_size;
528
529 max_packet_size = s->max_payload_size;
530
531 while (size > 0) {
532 len = max_packet_size;
533 if (len > size)
534 len = size;
535
536 s->timestamp = s->cur_timestamp;
537 ff_rtp_send_data(s1, buf1, len, (len == size));
538
539 buf1 += len;
540 size -= len;
541 }
542}
543
544/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
546 const uint8_t *buf1, int size)
547{
549 int len, out_len;
550
551 s->timestamp = s->cur_timestamp;
552 while (size >= TS_PACKET_SIZE) {
553 len = s->max_payload_size - (s->buf_ptr - s->buf);
554 if (len > size)
555 len = size;
556 memcpy(s->buf_ptr, buf1, len);
557 buf1 += len;
558 size -= len;
559 s->buf_ptr += len;
560
561 out_len = s->buf_ptr - s->buf;
562 if (out_len >= s->max_payload_size) {
563 ff_rtp_send_data(s1, s->buf, out_len, 0);
564 s->buf_ptr = s->buf;
565 }
566 }
567}
568
569static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
570{
572 AVStream *st = s1->streams[0];
573 int frame_duration = av_get_audio_frame_duration2(st->codecpar, 0);
575 int frames = size / frame_size;
576
577 while (frames > 0) {
578 if (s->num_frames > 0 &&
579 av_compare_ts(s->cur_timestamp - s->timestamp, st->time_base,
580 s1->max_delay, AV_TIME_BASE_Q) >= 0) {
581 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
582 s->num_frames = 0;
583 }
584
585 if (!s->num_frames) {
586 s->buf_ptr = s->buf;
587 s->timestamp = s->cur_timestamp;
588 }
589 memcpy(s->buf_ptr, buf, frame_size);
590 frames--;
591 s->num_frames++;
592 s->buf_ptr += frame_size;
593 buf += frame_size;
594 s->cur_timestamp += frame_duration;
595
596 if (s->num_frames == s->max_frames_per_packet) {
597 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
598 s->num_frames = 0;
599 }
600 }
601 return 0;
602}
603
605{
607 AVStream *st = s1->streams[0];
608 int rtcp_bytes;
609 int size= pkt->size;
610
611 av_log(s1, AV_LOG_TRACE, "%d: write len=%d\n", pkt->stream_index, size);
612
613 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
615 if ((s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
616 (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) &&
617 !(s->flags & FF_RTP_FLAG_SKIP_RTCP)) {
618 rtcp_send_sr(s1, ff_ntp_time(), 0);
619 s->last_octet_count = s->octet_count;
620 s->first_packet = 0;
621 }
622 s->cur_timestamp = s->base_timestamp + pkt->pts;
623
624 switch(st->codecpar->codec_id) {
629 return rtp_send_samples(s1, pkt->data, size, 8);
634 return rtp_send_samples(s1, pkt->data, size, 16);
636 return rtp_send_samples(s1, pkt->data, size, 24);
638 /* The actual sample size is half a byte per sample, but since the
639 * stream clock rate is 8000 Hz while the sample rate is 16000 Hz,
640 * the correct parameter for send_samples_bits is 8 bits per stream
641 * clock. */
642 return rtp_send_samples(s1, pkt->data, size, 8);
645 return rtp_send_samples(s1, pkt->data, size, st->codecpar->bits_per_coded_sample);
646 case AV_CODEC_ID_MP2:
647 case AV_CODEC_ID_MP3:
648 rtp_send_mpegaudio(s1, pkt->data, size);
649 break;
652 ff_rtp_send_mpegvideo(s1, pkt->data, size);
653 break;
654 case AV_CODEC_ID_AAC: {
655 const uint8_t *aac_frame = pkt->data;
656
657 /* skip ADTS header, if present */
658 if (!st->codecpar->extradata_size) {
659 if (size < 7) {
660 av_log(s1, AV_LOG_ERROR, "AAC packet too small for ADTS header\n");
661 break;
662 }
663 aac_frame += 7;
664 size -= 7;
665 }
666 if (s->flags & FF_RTP_FLAG_MP4A_LATM)
667 ff_rtp_send_latm(s1, aac_frame, size);
668 else
669 ff_rtp_send_aac(s1, aac_frame, size);
670 break;
671 }
674 ff_rtp_send_amr(s1, pkt->data, size);
675 break;
676 case AV_CODEC_ID_AV1:
677 ff_rtp_send_av1(s1, pkt->data, size, (pkt->flags & AV_PKT_FLAG_KEY) ? 1 : 0);
678 break;
680 rtp_send_mpegts_raw(s1, pkt->data, size);
681 break;
684 break;
685 case AV_CODEC_ID_H264:
686 ff_rtp_send_h264_hevc(s1, pkt->data, size);
687 break;
688 case AV_CODEC_ID_H261:
689 ff_rtp_send_h261(s1, pkt->data, size);
690 break;
691 case AV_CODEC_ID_H263:
692 if (s->flags & FF_RTP_FLAG_RFC2190) {
693 size_t mb_info_size;
694 const uint8_t *mb_info =
696 &mb_info_size);
697 ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size);
698 break;
699 }
702 ff_rtp_send_h263(s1, pkt->data, size);
703 break;
704 case AV_CODEC_ID_HEVC:
705 ff_rtp_send_h264_hevc(s1, pkt->data, size);
706 break;
709 ff_rtp_send_xiph(s1, pkt->data, size);
710 break;
711 case AV_CODEC_ID_VP8:
712 ff_rtp_send_vp8(s1, pkt->data, size);
713 break;
714 case AV_CODEC_ID_VP9:
715 ff_rtp_send_vp9(s1, pkt->data, size);
716 break;
717 case AV_CODEC_ID_ILBC:
718 rtp_send_ilbc(s1, pkt->data, size);
719 break;
721 ff_rtp_send_jpeg(s1, pkt->data, size);
722 break;
726
728 if (interlaced)
730 break;
731 }
732 case AV_CODEC_ID_OPUS:
733 if (size > s->max_payload_size) {
735 "Packet size %d too large for max RTP payload size %d\n",
736 size, s->max_payload_size);
737 return AVERROR(EINVAL);
738 }
740 default:
741 /* better than nothing : send the codec raw data */
742 rtp_send_raw(s1, pkt->data, size);
743 break;
744 }
745 return 0;
746}
747
749{
751
752 /* If the caller closes and recreates ->pb, this might actually
753 * be NULL here even if it was successfully allocated at the start. */
754 if (s1->pb && (s->flags & FF_RTP_FLAG_SEND_BYE))
755 rtcp_send_sr(s1, ff_ntp_time(), 1);
756
757 return 0;
758}
759
761{
763
764 av_freep(&s->buf);
765}
766
768 .p.name = "rtp",
769 .p.long_name = NULL_IF_CONFIG_SMALL("RTP output"),
770 .priv_data_size = sizeof(RTPMuxContext),
771 .p.audio_codec = AV_CODEC_ID_PCM_MULAW,
772 .p.video_codec = AV_CODEC_ID_MPEG4,
773 .write_header = rtp_write_header,
774 .write_packet = rtp_write_packet,
775 .write_trailer = rtp_write_trailer,
776 .deinit = rtp_deinit,
777 .p.priv_class = &rtp_muxer_class,
779};
const FFOutputFormat ff_rtp_muxer
Definition rtpenc.c:767
static int frames
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:865
Main libavformat public API header.
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition avformat.h:504
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition avformat.h:1570
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition avformat.h:509
void avio_w8(AVIOContext *s, int b)
Definition aviobuf.c:184
void avio_wb32(AVIOContext *s, unsigned int val)
Definition aviobuf.c:368
void avio_wb16(AVIOContext *s, unsigned int val)
Definition aviobuf.c:446
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition aviobuf.c:206
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition aviobuf.c:228
#define flags(name, subs,...)
Definition cbs_h264.c:74
#define s(width, name)
Definition cbs_vp9.c:198
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition defs.h:62
@ AV_FIELD_PROGRESSIVE
Definition defs.h:229
static AVPacket * pkt
int ret
Definition ffplay.c:391
static const uint8_t frame_size[4]
Definition g723_1.h:222
#define fail
Definition test.h:479
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
Definition opt.h:351
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition opt.h:258
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition opt.h:275
@ AV_OPT_TYPE_UINT
Underlying C type is unsigned int.
Definition opt.h:334
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition utils.c:421
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition codec_id.h:47
@ AV_CODEC_ID_DIRAC
Definition codec_id.h:166
@ AV_CODEC_ID_MPEG2TS
FAKE codec to indicate a raw MPEG-2 TS stream (only used by libavformat)
Definition codec_id.h:622
@ AV_CODEC_ID_PCM_S24BE
Definition codec_id.h:346
@ AV_CODEC_ID_VORBIS
Definition codec_id.h:464
@ AV_CODEC_ID_H261
Definition codec_id.h:53
@ AV_CODEC_ID_RAWVIDEO
Definition codec_id.h:63
@ AV_CODEC_ID_PCM_U8
Definition codec_id.h:338
@ AV_CODEC_ID_PCM_S16LE
Definition codec_id.h:333
@ AV_CODEC_ID_ADPCM_G722
Definition codec_id.h:402
@ AV_CODEC_ID_H264
Definition codec_id.h:77
@ AV_CODEC_ID_G728
Definition codec_id.h:566
@ AV_CODEC_ID_PCM_S16BE
Definition codec_id.h:334
@ AV_CODEC_ID_BITPACKED
Definition codec_id.h:276
@ AV_CODEC_ID_ADPCM_G726LE
Definition codec_id.h:409
@ AV_CODEC_ID_PCM_S8
Definition codec_id.h:337
@ AV_CODEC_ID_AV1
Definition codec_id.h:275
@ AV_CODEC_ID_VP8
Definition codec_id.h:190
@ AV_CODEC_ID_PCM_ALAW
Definition codec_id.h:340
@ AV_CODEC_ID_AMR_NB
Definition codec_id.h:440
@ AV_CODEC_ID_THEORA
Definition codec_id.h:80
@ AV_CODEC_ID_PCM_U16BE
Definition codec_id.h:336
@ AV_CODEC_ID_MP2
Definition codec_id.h:459
@ AV_CODEC_ID_HEVC
Definition codec_id.h:223
@ AV_CODEC_ID_ADPCM_G726
Definition codec_id.h:385
@ AV_CODEC_ID_AAC
Definition codec_id.h:461
@ AV_CODEC_ID_H263
Definition codec_id.h:54
@ AV_CODEC_ID_AMR_WB
Definition codec_id.h:441
@ AV_CODEC_ID_MPEG4
Definition codec_id.h:62
@ AV_CODEC_ID_MJPEG
Definition codec_id.h:57
@ AV_CODEC_ID_SPEEX
Definition codec_id.h:494
@ AV_CODEC_ID_ILBC
Definition codec_id.h:518
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition codec_id.h:460
@ AV_CODEC_ID_VP9
Definition codec_id.h:217
@ AV_CODEC_ID_MPEG1VIDEO
Definition codec_id.h:51
@ AV_CODEC_ID_H263P
Definition codec_id.h:69
@ AV_CODEC_ID_OPUS
Definition codec_id.h:519
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition codec_id.h:52
@ AV_CODEC_ID_PCM_U16LE
Definition codec_id.h:335
@ AV_CODEC_ID_PCM_MULAW
Definition codec_id.h:339
@ 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
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition packet.h:657
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
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition error.h:74
#define AVERROR(e)
Definition error.h:45
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition log.h:236
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
const char * av_default_item_name(void *ptr)
Return the context name.
Definition log.c:247
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.
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition mathematics.c:37
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
@ AVMEDIA_TYPE_AUDIO
Definition avutil.h:201
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition avutil.h:247
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition avutil.h:263
#define LIBAVUTIL_VERSION_INT
Definition version.h:85
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
Definition utils.c:834
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition utils.c:257
#define NTP_OFFSET_US
Definition internal.h:447
Macro definitions for various function/variable attributes.
#define av_fallthrough
Definition attributes.h:67
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:97
#define FFMIN(a, b)
Definition macros.h:49
Memory handling functions.
#define TS_PACKET_SIZE
Definition mpegts.h:29
uint8_t interlaced
Definition mxfenc.c:2337
#define av_malloc(s)
Definition ops_static.c:52
AVOptions.
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
#define RTP_VERSION
Definition rtp.h:80
@ RTCP_SR
Definition rtp.h:99
@ RTCP_SDES
Definition rtp.h:101
@ RTCP_BYE
Definition rtp.h:102
#define RTP_PT_PRIVATE
Definition rtp.h:79
#define RTCP_TX_RATIO_NUM
Definition rtp.h:84
#define RTCP_TX_RATIO_DEN
Definition rtp.h:85
static int is_supported(enum AVCodecID id)
Definition rtpenc.c:52
static void rtp_send_mpegaudio(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition rtpenc.c:471
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
Definition rtpenc.c:356
static int rtp_send_samples(AVFormatContext *s1, const uint8_t *buf1, int size, int bits_per_sample)
Definition rtpenc.c:428
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition rtpenc.c:604
static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
Definition rtpenc.c:569
static void rtp_deinit(AVFormatContext *s1)
Definition rtpenc.c:760
static int rtp_write_header(AVFormatContext *s1)
Definition rtpenc.c:100
static const AVClass rtp_muxer_class
Definition rtpenc.c:43
static void rtp_send_mpegts_raw(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition rtpenc.c:545
static int rtp_write_trailer(AVFormatContext *s1)
Definition rtpenc.c:748
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
Definition rtpenc.c:403
#define RTCP_SR_SIZE
Definition rtpenc.c:50
static void rtp_send_raw(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition rtpenc.c:523
void ff_rtp_send_h263_rfc2190(AVFormatContext *s1, const uint8_t *buf1, int size, const uint8_t *mb_info, int mb_info_size)
void ff_rtp_send_h264_hevc(AVFormatContext *s1, const uint8_t *buf1, int size)
void ff_rtp_send_vp9(AVFormatContext *s1, const uint8_t *buff, int size)
Definition rtpenc_vp9.c:26
void ff_rtp_send_vp8(AVFormatContext *s1, const uint8_t *buff, int size)
Definition rtpenc_vp8.c:26
#define FF_RTP_FLAG_OPTS(ctx, fieldname)
Definition rtpenc.h:75
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
void ff_rtp_send_raw_rfc4175(AVFormatContext *s1, const uint8_t *buf, int size, int interlaced, int field)
void ff_rtp_send_jpeg(AVFormatContext *s1, const uint8_t *buff, int size)
Definition rtpenc_jpeg.c:28
void ff_rtp_send_aac(AVFormatContext *s1, const uint8_t *buff, int size)
Definition rtpenc_aac.c:27
void ff_rtp_send_mpegvideo(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition rtpenc_mpv.c:29
#define FF_RTP_FLAG_MP4A_LATM
Definition rtpenc.h:69
void ff_rtp_send_av1(AVFormatContext *s1, const uint8_t *buf1, int size, int is_keyframe)
Definition rtpenc_av1.c:42
#define FF_RTP_FLAG_SEND_BYE
Definition rtpenc.h:73
#define FF_RTP_FLAG_RFC2190
Definition rtpenc.h:70
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
void ff_rtp_send_h261(AVFormatContext *s1, const uint8_t *buf1, int size)
Definition rtpenc_h261.c:39
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
#define FF_RTP_FLAG_SKIP_RTCP
Definition rtpenc.h:71
void ff_rtp_send_vc2hq(AVFormatContext *s1, const uint8_t *buf, int size, int interlaced)
void ff_rtp_send_latm(AVFormatContext *s1, const uint8_t *buff, int size)
Definition rtpenc_latm.c:25
int nb_channels
Number of channels in this layout.
Describe the class of an AVClass context structure.
Definition log.h:76
int extradata_size
Size of the extradata content in bytes.
Definition codec_par.h:75
enum AVFieldOrder field_order
The order of the fields in interlaced video.
Definition codec_par.h:182
int height
The height of the video frame in pixels.
Definition codec_par.h:150
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition codec_par.h:113
AVChannelLayout ch_layout
The channel layout and number of channels.
Definition codec_par.h:207
int width
The width of the video frame in pixels.
Definition codec_par.h:143
enum AVMediaType codec_type
General type of the encoded data.
Definition codec_par.h:53
int block_align
The number of bytes per coded audio frame, required by some formats.
Definition codec_par.h:221
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition codec_par.h:71
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition codec_par.h:57
int sample_rate
The number of audio samples per second.
Definition codec_par.h:213
Format I/O context.
Definition avformat.h:1401
unsigned int packet_size
Definition avformat.h:1546
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition avformat.h:1457
AVIOContext * pb
I/O context.
Definition avformat.h:1443
int flags
Flags modifying the (de)muxer behaviour.
Definition avformat.h:1553
int strict_std_compliance
Allow non-standard and experimental extension.
Definition avformat.h:1776
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:1662
void * priv_data
Format private data.
Definition avformat.h:1429
AVStream ** streams
A list of all streams in the file.
Definition avformat.h:1469
int max_packet_size
Definition avio.h:241
AVOption.
Definition opt.h:428
This structure stores compressed data.
Definition packet.h:587
Rational number (pair of numerator and denominator).
Definition rational.h:58
Stream structure.
Definition avformat.h:768
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition avformat.h:791
int id
Format-specific stream ID.
Definition avformat.h:780
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition avformat.h:807
#define av_freep(p)
#define av_log(a,...)
int size
int len