3 * Copyright (c) 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
25 #include "libavutil/mathematics.h"
26 #include "libavutil/random_seed.h"
27 #include "libavutil/opt.h"
31 static const AVOption options
[] = {
32 FF_RTP_FLAG_OPTS(RTPMuxContext
, flags
),
33 { "payload_type", "Specify RTP payload type", offsetof(RTPMuxContext
, payload_type
), AV_OPT_TYPE_INT
, {.i64
= -1 }, -1, 127, AV_OPT_FLAG_ENCODING_PARAM
},
34 { "ssrc", "Stream identifier", offsetof(RTPMuxContext
, ssrc
), AV_OPT_TYPE_INT
, { .i64
= 0 }, INT_MIN
, INT_MAX
, AV_OPT_FLAG_ENCODING_PARAM
},
35 { "cname", "CNAME to include in RTCP SR packets", offsetof(RTPMuxContext
, cname
), AV_OPT_TYPE_STRING
, { .str
= NULL
}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM
},
36 { "seq", "Starting sequence number", offsetof(RTPMuxContext
, seq
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 65535, AV_OPT_FLAG_ENCODING_PARAM
},
40 static const AVClass rtp_muxer_class
= {
41 .class_name
= "RTP muxer",
42 .item_name
= av_default_item_name
,
44 .version
= LIBAVUTIL_VERSION_INT
,
47 #define RTCP_SR_SIZE 28
49 static int is_supported(enum AVCodecID id
)
52 case AV_CODEC_ID_H261
:
53 case AV_CODEC_ID_H263
:
54 case AV_CODEC_ID_H263P
:
55 case AV_CODEC_ID_H264
:
56 case AV_CODEC_ID_MPEG1VIDEO
:
57 case AV_CODEC_ID_MPEG2VIDEO
:
58 case AV_CODEC_ID_MPEG4
:
62 case AV_CODEC_ID_PCM_ALAW
:
63 case AV_CODEC_ID_PCM_MULAW
:
64 case AV_CODEC_ID_PCM_S8
:
65 case AV_CODEC_ID_PCM_S16BE
:
66 case AV_CODEC_ID_PCM_S16LE
:
67 case AV_CODEC_ID_PCM_U16BE
:
68 case AV_CODEC_ID_PCM_U16LE
:
69 case AV_CODEC_ID_PCM_U8
:
70 case AV_CODEC_ID_MPEG2TS
:
71 case AV_CODEC_ID_AMR_NB
:
72 case AV_CODEC_ID_AMR_WB
:
73 case AV_CODEC_ID_VORBIS
:
74 case AV_CODEC_ID_THEORA
:
76 case AV_CODEC_ID_ADPCM_G722
:
77 case AV_CODEC_ID_ADPCM_G726
:
78 case AV_CODEC_ID_ILBC
:
79 case AV_CODEC_ID_MJPEG
:
80 case AV_CODEC_ID_SPEEX
:
81 case AV_CODEC_ID_OPUS
:
88 static int rtp_write_header(AVFormatContext
*s1
)
90 RTPMuxContext
*s
= s1
->priv_data
;
94 if (s1
->nb_streams
!= 1) {
95 av_log(s1
, AV_LOG_ERROR
, "Only one stream supported in the RTP muxer\n");
96 return AVERROR(EINVAL
);
99 if (!is_supported(st
->codec
->codec_id
)) {
100 av_log(s1
, AV_LOG_ERROR
, "Unsupported codec %s\n", avcodec_get_name(st
->codec
->codec_id
));
105 if (s
->payload_type
< 0) {
106 /* Re-validate non-dynamic payload types */
107 if (st
->id
< RTP_PT_PRIVATE
)
108 st
->id
= ff_rtp_get_payload_type(s1
, st
->codec
, -1);
110 s
->payload_type
= st
->id
;
112 /* private option takes priority */
113 st
->id
= s
->payload_type
;
116 s
->base_timestamp
= av_get_random_seed();
117 s
->timestamp
= s
->base_timestamp
;
118 s
->cur_timestamp
= 0;
120 s
->ssrc
= av_get_random_seed();
122 s
->first_rtcp_ntp_time
= ff_ntp_time();
123 if (s1
->start_time_realtime
!= 0 && s1
->start_time_realtime
!= AV_NOPTS_VALUE
)
124 /* Round the NTP time to whole milliseconds. */
125 s
->first_rtcp_ntp_time
= (s1
->start_time_realtime
/ 1000) * 1000 +
127 // Pick a random sequence start number, but in the lower end of the
128 // available range, so that any wraparound doesn't happen immediately.
129 // (Immediate wraparound would be an issue for SRTP.)
131 if (s1
->flags
& AVFMT_FLAG_BITEXACT
) {
134 s
->seq
= av_get_random_seed() & 0x0fff;
136 s
->seq
&= 0xffff; // Use the given parameter, wrapped to the right interval
138 if (s1
->packet_size
) {
139 if (s1
->pb
->max_packet_size
)
140 s1
->packet_size
= FFMIN(s1
->packet_size
,
141 s1
->pb
->max_packet_size
);
143 s1
->packet_size
= s1
->pb
->max_packet_size
;
144 if (s1
->packet_size
<= 12) {
145 av_log(s1
, AV_LOG_ERROR
, "Max packet size %d too low\n", s1
->packet_size
);
148 s
->buf
= av_malloc(s1
->packet_size
);
150 return AVERROR(ENOMEM
);
152 s
->max_payload_size
= s1
->packet_size
- 12;
154 s
->max_frames_per_packet
= 0;
155 if (s1
->max_delay
> 0) {
156 if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
157 int frame_size
= av_get_audio_frame_duration(st
->codec
, 0);
159 frame_size
= st
->codec
->frame_size
;
160 if (frame_size
== 0) {
161 av_log(s1
, AV_LOG_ERROR
, "Cannot respect max delay: frame size = 0\n");
163 s
->max_frames_per_packet
=
164 av_rescale_q_rnd(s1
->max_delay
,
166 (AVRational
){ frame_size
, st
->codec
->sample_rate
},
170 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
171 /* FIXME: We should round down here... */
172 if (st
->avg_frame_rate
.num
> 0 && st
->avg_frame_rate
.den
> 0) {
173 s
->max_frames_per_packet
= av_rescale_q(s1
->max_delay
,
174 (AVRational
){1, 1000000},
175 av_inv_q(st
->avg_frame_rate
));
177 s
->max_frames_per_packet
= 1;
181 avpriv_set_pts_info(st
, 32, 1, 90000);
182 switch(st
->codec
->codec_id
) {
183 case AV_CODEC_ID_MP2
:
184 case AV_CODEC_ID_MP3
:
185 s
->buf_ptr
= s
->buf
+ 4;
187 case AV_CODEC_ID_MPEG1VIDEO
:
188 case AV_CODEC_ID_MPEG2VIDEO
:
190 case AV_CODEC_ID_MPEG2TS
:
191 n
= s
->max_payload_size
/ TS_PACKET_SIZE
;
194 s
->max_payload_size
= n
* TS_PACKET_SIZE
;
197 case AV_CODEC_ID_H264
:
198 /* check for H.264 MP4 syntax */
199 if (st
->codec
->extradata_size
> 4 && st
->codec
->extradata
[0] == 1) {
200 s
->nal_length_size
= (st
->codec
->extradata
[4] & 0x03) + 1;
203 case AV_CODEC_ID_VORBIS
:
204 case AV_CODEC_ID_THEORA
:
205 if (!s
->max_frames_per_packet
) s
->max_frames_per_packet
= 15;
206 s
->max_frames_per_packet
= av_clip(s
->max_frames_per_packet
, 1, 15);
207 s
->max_payload_size
-= 6; // ident+frag+tdt/vdt+pkt_num+pkt_length
210 case AV_CODEC_ID_ADPCM_G722
:
211 /* Due to a historical error, the clock rate for G722 in RTP is
212 * 8000, even if the sample rate is 16000. See RFC 3551. */
213 avpriv_set_pts_info(st
, 32, 1, 8000);
215 case AV_CODEC_ID_OPUS
:
216 if (st
->codec
->channels
> 2) {
217 av_log(s1
, AV_LOG_ERROR
, "Multistream opus not supported in RTP\n");
220 /* The opus RTP RFC says that all opus streams should use 48000 Hz
221 * as clock rate, since all opus sample rates can be expressed in
222 * this clock rate, and sample rate changes on the fly are supported. */
223 avpriv_set_pts_info(st
, 32, 1, 48000);
225 case AV_CODEC_ID_ILBC
:
226 if (st
->codec
->block_align
!= 38 && st
->codec
->block_align
!= 50) {
227 av_log(s1
, AV_LOG_ERROR
, "Incorrect iLBC block size specified\n");
230 if (!s
->max_frames_per_packet
)
231 s
->max_frames_per_packet
= 1;
232 s
->max_frames_per_packet
= FFMIN(s
->max_frames_per_packet
,
233 s
->max_payload_size
/ st
->codec
->block_align
);
235 case AV_CODEC_ID_AMR_NB
:
236 case AV_CODEC_ID_AMR_WB
:
237 if (!s
->max_frames_per_packet
)
238 s
->max_frames_per_packet
= 12;
239 if (st
->codec
->codec_id
== AV_CODEC_ID_AMR_NB
)
243 /* max_header_toc_size + the largest AMR payload must fit */
244 if (1 + s
->max_frames_per_packet
+ n
> s
->max_payload_size
) {
245 av_log(s1
, AV_LOG_ERROR
, "RTP max payload size too small for AMR\n");
248 if (st
->codec
->channels
!= 1) {
249 av_log(s1
, AV_LOG_ERROR
, "Only mono is supported\n");
252 case AV_CODEC_ID_AAC
:
256 if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
257 avpriv_set_pts_info(st
, 32, 1, st
->codec
->sample_rate
);
267 return AVERROR(EINVAL
);
270 /* send an rtcp sender report packet */
271 static void rtcp_send_sr(AVFormatContext
*s1
, int64_t ntp_time
, int bye
)
273 RTPMuxContext
*s
= s1
->priv_data
;
276 av_dlog(s1
, "RTCP: %02x %"PRIx64
" %x\n", s
->payload_type
, ntp_time
, s
->timestamp
);
278 s
->last_rtcp_ntp_time
= ntp_time
;
279 rtp_ts
= av_rescale_q(ntp_time
- s
->first_rtcp_ntp_time
, (AVRational
){1, 1000000},
280 s1
->streams
[0]->time_base
) + s
->base_timestamp
;
281 avio_w8(s1
->pb
, RTP_VERSION
<< 6);
282 avio_w8(s1
->pb
, RTCP_SR
);
283 avio_wb16(s1
->pb
, 6); /* length in words - 1 */
284 avio_wb32(s1
->pb
, s
->ssrc
);
285 avio_wb64(s1
->pb
, NTP_TO_RTP_FORMAT(ntp_time
));
286 avio_wb32(s1
->pb
, rtp_ts
);
287 avio_wb32(s1
->pb
, s
->packet_count
);
288 avio_wb32(s1
->pb
, s
->octet_count
);
291 int len
= FFMIN(strlen(s
->cname
), 255);
292 avio_w8(s1
->pb
, (RTP_VERSION
<< 6) + 1);
293 avio_w8(s1
->pb
, RTCP_SDES
);
294 avio_wb16(s1
->pb
, (7 + len
+ 3) / 4); /* length in words - 1 */
296 avio_wb32(s1
->pb
, s
->ssrc
);
297 avio_w8(s1
->pb
, 0x01); /* CNAME */
298 avio_w8(s1
->pb
, len
);
299 avio_write(s1
->pb
, s
->cname
, len
);
300 avio_w8(s1
->pb
, 0); /* END */
301 for (len
= (7 + len
) % 4; len
% 4; len
++)
306 avio_w8(s1
->pb
, (RTP_VERSION
<< 6) | 1);
307 avio_w8(s1
->pb
, RTCP_BYE
);
308 avio_wb16(s1
->pb
, 1); /* length in words - 1 */
309 avio_wb32(s1
->pb
, s
->ssrc
);
315 /* send an rtp packet. sequence number is incremented, but the caller
316 must update the timestamp itself */
317 void ff_rtp_send_data(AVFormatContext
*s1
, const uint8_t *buf1
, int len
, int m
)
319 RTPMuxContext
*s
= s1
->priv_data
;
321 av_dlog(s1
, "rtp_send_data size=%d\n", len
);
323 /* build the RTP header */
324 avio_w8(s1
->pb
, RTP_VERSION
<< 6);
325 avio_w8(s1
->pb
, (s
->payload_type
& 0x7f) | ((m
& 0x01) << 7));
326 avio_wb16(s1
->pb
, s
->seq
);
327 avio_wb32(s1
->pb
, s
->timestamp
);
328 avio_wb32(s1
->pb
, s
->ssrc
);
330 avio_write(s1
->pb
, buf1
, len
);
333 s
->seq
= (s
->seq
+ 1) & 0xffff;
334 s
->octet_count
+= len
;
338 /* send an integer number of samples and compute time stamp and fill
339 the rtp send buffer before sending. */
340 static int rtp_send_samples(AVFormatContext
*s1
,
341 const uint8_t *buf1
, int size
, int sample_size_bits
)
343 RTPMuxContext
*s
= s1
->priv_data
;
344 int len
, max_packet_size
, n
;
345 /* Calculate the number of bytes to get samples aligned on a byte border */
346 int aligned_samples_size
= sample_size_bits
/av_gcd(sample_size_bits
, 8);
348 max_packet_size
= (s
->max_payload_size
/ aligned_samples_size
) * aligned_samples_size
;
349 /* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */
350 if ((sample_size_bits
% 8) == 0 && ((8 * size
) % sample_size_bits
) != 0)
351 return AVERROR(EINVAL
);
355 len
= FFMIN(max_packet_size
, size
);
358 memcpy(s
->buf_ptr
, buf1
, len
);
362 s
->timestamp
= s
->cur_timestamp
+ n
* 8 / sample_size_bits
;
363 ff_rtp_send_data(s1
, s
->buf
, s
->buf_ptr
- s
->buf
, 0);
364 n
+= (s
->buf_ptr
- s
->buf
);
369 static void rtp_send_mpegaudio(AVFormatContext
*s1
,
370 const uint8_t *buf1
, int size
)
372 RTPMuxContext
*s
= s1
->priv_data
;
373 int len
, count
, max_packet_size
;
375 max_packet_size
= s
->max_payload_size
;
377 /* test if we must flush because not enough space */
378 len
= (s
->buf_ptr
- s
->buf
);
379 if ((len
+ size
) > max_packet_size
) {
381 ff_rtp_send_data(s1
, s
->buf
, s
->buf_ptr
- s
->buf
, 0);
382 s
->buf_ptr
= s
->buf
+ 4;
385 if (s
->buf_ptr
== s
->buf
+ 4) {
386 s
->timestamp
= s
->cur_timestamp
;
390 if (size
> max_packet_size
) {
391 /* big packet: fragment */
394 len
= max_packet_size
- 4;
397 /* build fragmented packet */
400 s
->buf
[2] = count
>> 8;
402 memcpy(s
->buf
+ 4, buf1
, len
);
403 ff_rtp_send_data(s1
, s
->buf
, len
+ 4, 0);
409 if (s
->buf_ptr
== s
->buf
+ 4) {
410 /* no fragmentation possible */
416 memcpy(s
->buf_ptr
, buf1
, size
);
421 static void rtp_send_raw(AVFormatContext
*s1
,
422 const uint8_t *buf1
, int size
)
424 RTPMuxContext
*s
= s1
->priv_data
;
425 int len
, max_packet_size
;
427 max_packet_size
= s
->max_payload_size
;
430 len
= max_packet_size
;
434 s
->timestamp
= s
->cur_timestamp
;
435 ff_rtp_send_data(s1
, buf1
, len
, (len
== size
));
442 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
443 static void rtp_send_mpegts_raw(AVFormatContext
*s1
,
444 const uint8_t *buf1
, int size
)
446 RTPMuxContext
*s
= s1
->priv_data
;
449 while (size
>= TS_PACKET_SIZE
) {
450 len
= s
->max_payload_size
- (s
->buf_ptr
- s
->buf
);
453 memcpy(s
->buf_ptr
, buf1
, len
);
458 out_len
= s
->buf_ptr
- s
->buf
;
459 if (out_len
>= s
->max_payload_size
) {
460 ff_rtp_send_data(s1
, s
->buf
, out_len
, 0);
466 static int rtp_send_ilbc(AVFormatContext
*s1
, const uint8_t *buf
, int size
)
468 RTPMuxContext
*s
= s1
->priv_data
;
469 AVStream
*st
= s1
->streams
[0];
470 int frame_duration
= av_get_audio_frame_duration(st
->codec
, 0);
471 int frame_size
= st
->codec
->block_align
;
472 int frames
= size
/ frame_size
;
475 int n
= FFMIN(s
->max_frames_per_packet
- s
->num_frames
, frames
);
477 if (!s
->num_frames
) {
479 s
->timestamp
= s
->cur_timestamp
;
481 memcpy(s
->buf_ptr
, buf
, n
* frame_size
);
484 s
->buf_ptr
+= n
* frame_size
;
485 buf
+= n
* frame_size
;
486 s
->cur_timestamp
+= n
* frame_duration
;
488 if (s
->num_frames
== s
->max_frames_per_packet
) {
489 ff_rtp_send_data(s1
, s
->buf
, s
->buf_ptr
- s
->buf
, 1);
496 static int rtp_write_packet(AVFormatContext
*s1
, AVPacket
*pkt
)
498 RTPMuxContext
*s
= s1
->priv_data
;
499 AVStream
*st
= s1
->streams
[0];
503 av_dlog(s1
, "%d: write len=%d\n", pkt
->stream_index
, size
);
505 rtcp_bytes
= ((s
->octet_count
- s
->last_octet_count
) * RTCP_TX_RATIO_NUM
) /
507 if ((s
->first_packet
|| ((rtcp_bytes
>= RTCP_SR_SIZE
) &&
508 (ff_ntp_time() - s
->last_rtcp_ntp_time
> 5000000))) &&
509 !(s
->flags
& FF_RTP_FLAG_SKIP_RTCP
)) {
510 rtcp_send_sr(s1
, ff_ntp_time(), 0);
511 s
->last_octet_count
= s
->octet_count
;
514 s
->cur_timestamp
= s
->base_timestamp
+ pkt
->pts
;
516 switch(st
->codec
->codec_id
) {
517 case AV_CODEC_ID_PCM_MULAW
:
518 case AV_CODEC_ID_PCM_ALAW
:
519 case AV_CODEC_ID_PCM_U8
:
520 case AV_CODEC_ID_PCM_S8
:
521 return rtp_send_samples(s1
, pkt
->data
, size
, 8 * st
->codec
->channels
);
522 case AV_CODEC_ID_PCM_U16BE
:
523 case AV_CODEC_ID_PCM_U16LE
:
524 case AV_CODEC_ID_PCM_S16BE
:
525 case AV_CODEC_ID_PCM_S16LE
:
526 return rtp_send_samples(s1
, pkt
->data
, size
, 16 * st
->codec
->channels
);
527 case AV_CODEC_ID_ADPCM_G722
:
528 /* The actual sample size is half a byte per sample, but since the
529 * stream clock rate is 8000 Hz while the sample rate is 16000 Hz,
530 * the correct parameter for send_samples_bits is 8 bits per stream
532 return rtp_send_samples(s1
, pkt
->data
, size
, 8 * st
->codec
->channels
);
533 case AV_CODEC_ID_ADPCM_G726
:
534 return rtp_send_samples(s1
, pkt
->data
, size
,
535 st
->codec
->bits_per_coded_sample
* st
->codec
->channels
);
536 case AV_CODEC_ID_MP2
:
537 case AV_CODEC_ID_MP3
:
538 rtp_send_mpegaudio(s1
, pkt
->data
, size
);
540 case AV_CODEC_ID_MPEG1VIDEO
:
541 case AV_CODEC_ID_MPEG2VIDEO
:
542 ff_rtp_send_mpegvideo(s1
, pkt
->data
, size
);
544 case AV_CODEC_ID_AAC
:
545 if (s
->flags
& FF_RTP_FLAG_MP4A_LATM
)
546 ff_rtp_send_latm(s1
, pkt
->data
, size
);
548 ff_rtp_send_aac(s1
, pkt
->data
, size
);
550 case AV_CODEC_ID_AMR_NB
:
551 case AV_CODEC_ID_AMR_WB
:
552 ff_rtp_send_amr(s1
, pkt
->data
, size
);
554 case AV_CODEC_ID_MPEG2TS
:
555 rtp_send_mpegts_raw(s1
, pkt
->data
, size
);
557 case AV_CODEC_ID_H264
:
558 ff_rtp_send_h264(s1
, pkt
->data
, size
);
560 case AV_CODEC_ID_H261
:
561 ff_rtp_send_h261(s1
, pkt
->data
, size
);
563 case AV_CODEC_ID_H263
:
564 if (s
->flags
& FF_RTP_FLAG_RFC2190
) {
565 int mb_info_size
= 0;
566 const uint8_t *mb_info
=
567 av_packet_get_side_data(pkt
, AV_PKT_DATA_H263_MB_INFO
,
570 av_log(s1
, AV_LOG_ERROR
, "failed to allocate side data\n");
571 return AVERROR(ENOMEM
);
573 ff_rtp_send_h263_rfc2190(s1
, pkt
->data
, size
, mb_info
, mb_info_size
);
577 case AV_CODEC_ID_H263P
:
578 ff_rtp_send_h263(s1
, pkt
->data
, size
);
580 case AV_CODEC_ID_VORBIS
:
581 case AV_CODEC_ID_THEORA
:
582 ff_rtp_send_xiph(s1
, pkt
->data
, size
);
584 case AV_CODEC_ID_VP8
:
585 ff_rtp_send_vp8(s1
, pkt
->data
, size
);
587 case AV_CODEC_ID_ILBC
:
588 rtp_send_ilbc(s1
, pkt
->data
, size
);
590 case AV_CODEC_ID_MJPEG
:
591 ff_rtp_send_jpeg(s1
, pkt
->data
, size
);
593 case AV_CODEC_ID_OPUS
:
594 if (size
> s
->max_payload_size
) {
595 av_log(s1
, AV_LOG_ERROR
,
596 "Packet size %d too large for max RTP payload size %d\n",
597 size
, s
->max_payload_size
);
598 return AVERROR(EINVAL
);
600 /* Intentional fallthrough */
602 /* better than nothing : send the codec raw data */
603 rtp_send_raw(s1
, pkt
->data
, size
);
609 static int rtp_write_trailer(AVFormatContext
*s1
)
611 RTPMuxContext
*s
= s1
->priv_data
;
613 /* If the caller closes and recreates ->pb, this might actually
614 * be NULL here even if it was successfully allocated at the start. */
615 if (s1
->pb
&& (s
->flags
& FF_RTP_FLAG_SEND_BYE
))
616 rtcp_send_sr(s1
, ff_ntp_time(), 1);
622 AVOutputFormat ff_rtp_muxer
= {
624 .long_name
= NULL_IF_CONFIG_SMALL("RTP output"),
625 .priv_data_size
= sizeof(RTPMuxContext
),
626 .audio_codec
= AV_CODEC_ID_PCM_MULAW
,
627 .video_codec
= AV_CODEC_ID_MPEG4
,
628 .write_header
= rtp_write_header
,
629 .write_packet
= rtp_write_packet
,
630 .write_trailer
= rtp_write_trailer
,
631 .priv_class
= &rtp_muxer_class
,