FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavformat/rtpenc.c
Date: 2026-04-24 19:58:39
Exec Total Coverage
Lines: 127 394 32.2%
Functions: 9 12 75.0%
Branches: 36 174 20.7%
Line Branch Exec Source
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[] = {
34 FF_RTP_FLAG_OPTS(RTPMuxContext, flags),
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_UINT, { .i64 = 0 }, 0, UINT32_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 2 static int is_supported(enum AVCodecID id)
52 {
53
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 switch(id) {
54 2 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:
60 case AV_CODEC_ID_MPEG1VIDEO:
61 case AV_CODEC_ID_MPEG2VIDEO:
62 case AV_CODEC_ID_MPEG4:
63 case AV_CODEC_ID_AAC:
64 case AV_CODEC_ID_MP2:
65 case AV_CODEC_ID_MP3:
66 case AV_CODEC_ID_PCM_ALAW:
67 case AV_CODEC_ID_PCM_MULAW:
68 case AV_CODEC_ID_PCM_S8:
69 case AV_CODEC_ID_PCM_S16BE:
70 case AV_CODEC_ID_PCM_S16LE:
71 case AV_CODEC_ID_PCM_S24BE:
72 case AV_CODEC_ID_PCM_U16BE:
73 case AV_CODEC_ID_PCM_U16LE:
74 case AV_CODEC_ID_PCM_U8:
75 case AV_CODEC_ID_MPEG2TS:
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:
82 case AV_CODEC_ID_AV1:
83 case AV_CODEC_ID_ADPCM_G722:
84 case AV_CODEC_ID_ADPCM_G726:
85 case AV_CODEC_ID_ADPCM_G726LE:
86 case AV_CODEC_ID_ILBC:
87 case AV_CODEC_ID_MJPEG:
88 case AV_CODEC_ID_SPEEX:
89 case AV_CODEC_ID_OPUS:
90 case AV_CODEC_ID_RAWVIDEO:
91 case AV_CODEC_ID_BITPACKED:
92 case AV_CODEC_ID_G728:
93 2 return 1;
94 ✗ default:
95 ✗ return 0;
96 }
97 }
98
99 2 static int rtp_write_header(AVFormatContext *s1)
100 {
101 2 RTPMuxContext *s = s1->priv_data;
102 2 int n, ret = AVERROR(EINVAL);
103 AVStream *st;
104
105
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (s1->nb_streams != 1) {
106 ✗ av_log(s1, AV_LOG_ERROR, "Only one stream supported in the RTP muxer\n");
107 ✗ return AVERROR(EINVAL);
108 }
109 2 st = s1->streams[0];
110
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (!is_supported(st->codecpar->codec_id)) {
111 ✗ av_log(s1, AV_LOG_ERROR, "Unsupported codec %s\n", avcodec_get_name(st->codecpar->codec_id));
112
113 ✗ return -1;
114 }
115
116
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (s->payload_type < 0) {
117 /* Re-validate non-dynamic payload types */
118
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (st->id < RTP_PT_PRIVATE)
119 ✗ st->id = ff_rtp_get_payload_type(s1, st->codecpar, -1);
120
121 2 s->payload_type = st->id;
122 } else {
123 /* private option takes priority */
124 ✗ st->id = s->payload_type;
125 }
126
127 2 s->base_timestamp = av_get_random_seed();
128 2 s->timestamp = s->base_timestamp;
129 2 s->cur_timestamp = 0;
130
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (!s->ssrc)
131 2 s->ssrc = av_get_random_seed();
132 2 s->first_packet = 1;
133 2 s->first_rtcp_ntp_time = ff_ntp_time();
134
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 if (s1->start_time_realtime != 0 && s1->start_time_realtime != AV_NOPTS_VALUE)
135 /* Round the NTP time to whole milliseconds. */
136 ✗ s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
137 NTP_OFFSET_US;
138 // Pick a random sequence start number, but in the lower end of the
139 // available range, so that any wraparound doesn't happen immediately.
140 // (Immediate wraparound would be an issue for SRTP.)
141
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (s->seq < 0) {
142
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (s1->flags & AVFMT_FLAG_BITEXACT) {
143 2 s->seq = 0;
144 } else
145 ✗ s->seq = av_get_random_seed() & 0x0fff;
146 } else
147 ✗ s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval
148
149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (s1->packet_size) {
150 ✗ if (s1->pb->max_packet_size)
151 ✗ s1->packet_size = FFMIN(s1->packet_size,
152 s1->pb->max_packet_size);
153 } else
154 2 s1->packet_size = s1->pb->max_packet_size;
155
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (s1->packet_size <= 12) {
156 ✗ av_log(s1, AV_LOG_ERROR, "Max packet size %u too low\n", s1->packet_size);
157 ✗ return AVERROR(EIO);
158 }
159 2 s->buf = av_malloc(s1->packet_size);
160
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!s->buf) {
161 ✗ return AVERROR(ENOMEM);
162 }
163 2 s->max_payload_size = s1->packet_size - 12;
164
165
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
166 1 avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
167 } else {
168 1 avpriv_set_pts_info(st, 32, 1, 90000);
169 }
170 2 s->buf_ptr = s->buf;
171
1/17
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✓ Branch 16 taken 2 times.
 2 switch(st->codecpar->codec_id) {
172 ✗ case AV_CODEC_ID_MP2:
173 case AV_CODEC_ID_MP3:
174 ✗ s->buf_ptr = s->buf + 4;
175 ✗ avpriv_set_pts_info(st, 32, 1, 90000);
176 ✗ break;
177 ✗ case AV_CODEC_ID_MPEG1VIDEO:
178 case AV_CODEC_ID_MPEG2VIDEO:
179 ✗ break;
180 ✗ case AV_CODEC_ID_MPEG2TS:
181 ✗ if (s->max_payload_size < TS_PACKET_SIZE) {
182 ✗ av_log(s1, AV_LOG_ERROR,
183 "RTP payload size %u too small for MPEG-TS "
184 "(minimum %d bytes required)\n",
185 s->max_payload_size, TS_PACKET_SIZE);
186 ✗ ret = AVERROR(EINVAL);
187 ✗ goto fail;
188 }
189
190 ✗ n = s->max_payload_size / TS_PACKET_SIZE;
191 ✗ s->max_payload_size = n * TS_PACKET_SIZE;
192 ✗ break;
193 ✗ case AV_CODEC_ID_DIRAC:
194 ✗ if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
195 ✗ av_log(s, AV_LOG_ERROR,
196 "Packetizing VC-2 is experimental and does not use all values "
197 "of the specification "
198 "(even though most receivers may handle it just fine). "
199 "Please set -strict experimental in order to enable it.\n");
200 ✗ ret = AVERROR_EXPERIMENTAL;
201 ✗ goto fail;
202 }
203 ✗ break;
204 ✗ case AV_CODEC_ID_H261:
205 ✗ if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
206 ✗ av_log(s, AV_LOG_ERROR,
207 "Packetizing H.261 is experimental and produces incorrect "
208 "packetization for cases where GOBs don't fit into packets "
209 "(even though most receivers may handle it just fine). "
210 "Please set -f_strict experimental in order to enable it.\n");
211 ✗ ret = AVERROR_EXPERIMENTAL;
212 ✗ goto fail;
213 }
214 ✗ break;
215 ✗ case AV_CODEC_ID_H264:
216 /* check for H.264 MP4 syntax */
217 ✗ if (st->codecpar->extradata_size > 4 && st->codecpar->extradata[0] == 1) {
218 ✗ s->nal_length_size = (st->codecpar->extradata[4] & 0x03) + 1;
219 }
220 ✗ break;
221 ✗ case AV_CODEC_ID_HEVC:
222 /* Only check for the standardized hvcC version of extradata, keeping
223 * things simple and similar to the avcC/H.264 case above, instead
224 * of trying to handle the pre-standardization versions (as in
225 * libavcodec/hevc.c). */
226 ✗ if (st->codecpar->extradata_size > 21 && st->codecpar->extradata[0] == 1) {
227 ✗ s->nal_length_size = (st->codecpar->extradata[21] & 0x03) + 1;
228 }
229 ✗ break;
230 ✗ case AV_CODEC_ID_MJPEG:
231 case AV_CODEC_ID_BITPACKED:
232 case AV_CODEC_ID_RAWVIDEO:
233 ✗ if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {
234 ✗ av_log(s1, AV_LOG_ERROR, "dimensions not set\n");
235 ✗ return AVERROR(EINVAL);
236 }
237 ✗ break;
238 ✗ case AV_CODEC_ID_VP9:
239 ✗ if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
240 ✗ av_log(s, AV_LOG_ERROR,
241 "Packetizing VP9 is experimental and its specification is "
242 "still in draft state. "
243 "Please set -strict experimental in order to enable it.\n");
244 ✗ ret = AVERROR_EXPERIMENTAL;
245 ✗ goto fail;
246 }
247 ✗ break;
248 ✗ case AV_CODEC_ID_AV1:
249 ✗ if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
250 ✗ av_log(s, AV_LOG_ERROR,
251 "Packetizing AV1 is experimental and its specification is "
252 "still in draft state. "
253 "Please set -strict experimental in order to enable it.\n");
254 ✗ ret = AVERROR_EXPERIMENTAL;
255 ✗ goto fail;
256 }
257 ✗ break;
258 ✗ case AV_CODEC_ID_VORBIS:
259 case AV_CODEC_ID_THEORA:
260 ✗ s->max_frames_per_packet = 15;
261 ✗ break;
262 ✗ case AV_CODEC_ID_ADPCM_G722:
263 /* Due to a historical error, the clock rate for G722 in RTP is
264 * 8000, even if the sample rate is 16000. See RFC 3551. */
265 ✗ avpriv_set_pts_info(st, 32, 1, 8000);
266 ✗ break;
267 ✗ case AV_CODEC_ID_OPUS:
268 ✗ if (st->codecpar->ch_layout.nb_channels > 2) {
269 ✗ av_log(s1, AV_LOG_ERROR, "Multistream opus not supported in RTP\n");
270 ✗ goto fail;
271 }
272 /* The opus RTP RFC says that all opus streams should use 48000 Hz
273 * as clock rate, since all opus sample rates can be expressed in
274 * this clock rate, and sample rate changes on the fly are supported. */
275 ✗ avpriv_set_pts_info(st, 32, 1, 48000);
276 ✗ break;
277 ✗ case AV_CODEC_ID_ILBC:
278 ✗ if (st->codecpar->block_align != 38 && st->codecpar->block_align != 50) {
279 ✗ av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
280 ✗ goto fail;
281 }
282 ✗ s->max_frames_per_packet = s->max_payload_size / st->codecpar->block_align;
283 ✗ break;
284 ✗ case AV_CODEC_ID_AMR_NB:
285 case AV_CODEC_ID_AMR_WB:
286 ✗ s->max_frames_per_packet = 50;
287 ✗ if (st->codecpar->codec_id == AV_CODEC_ID_AMR_NB)
288 ✗ n = 31;
289 else
290 ✗ n = 61;
291 /* max_header_toc_size + the largest AMR payload must fit */
292 ✗ if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
293 ✗ av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");
294 ✗ goto fail;
295 }
296 ✗ if (st->codecpar->ch_layout.nb_channels != 1) {
297 ✗ av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
298 ✗ goto fail;
299 }
300 ✗ break;
301 ✗ case AV_CODEC_ID_AAC:
302 ✗ s->max_frames_per_packet = 50;
303 ✗ break;
304 2 default:
305 2 break;
306 }
307
308 2 return 0;
309
310 ✗ fail:
311 ✗ av_freep(&s->buf);
312 ✗ return ret;
313 }
314
315 /* send an rtcp sender report packet */
316 2 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
317 {
318 2 RTPMuxContext *s = s1->priv_data;
319 uint32_t rtp_ts;
320
321 2 av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %"PRIx32"\n", s->payload_type, ntp_time, s->timestamp);
322
323 2 s->last_rtcp_ntp_time = ntp_time;
324 2 rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
325 2 s1->streams[0]->time_base) + s->base_timestamp;
326 2 avio_w8(s1->pb, RTP_VERSION << 6);
327 2 avio_w8(s1->pb, RTCP_SR);
328 2 avio_wb16(s1->pb, 6); /* length in words - 1 */
329 2 avio_wb32(s1->pb, s->ssrc);
330 2 avio_wb32(s1->pb, ntp_time / 1000000);
331 2 avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
332 2 avio_wb32(s1->pb, rtp_ts);
333 2 avio_wb32(s1->pb, s->packet_count);
334 2 avio_wb32(s1->pb, s->octet_count);
335
336
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (s->cname) {
337 ✗ int len = FFMIN(strlen(s->cname), 255);
338 ✗ avio_w8(s1->pb, (RTP_VERSION << 6) + 1);
339 ✗ avio_w8(s1->pb, RTCP_SDES);
340 ✗ avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */
341
342 ✗ avio_wb32(s1->pb, s->ssrc);
343 ✗ avio_w8(s1->pb, 0x01); /* CNAME */
344 ✗ avio_w8(s1->pb, len);
345 ✗ avio_write(s1->pb, s->cname, len);
346 ✗ avio_w8(s1->pb, 0); /* END */
347 ✗ for (len = (7 + len) % 4; len % 4; len++)
348 ✗ avio_w8(s1->pb, 0);
349 }
350
351
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (bye) {
352 ✗ avio_w8(s1->pb, (RTP_VERSION << 6) | 1);
353 ✗ avio_w8(s1->pb, RTCP_BYE);
354 ✗ avio_wb16(s1->pb, 1); /* length in words - 1 */
355 ✗ avio_wb32(s1->pb, s->ssrc);
356 }
357
358 2 avio_flush(s1->pb);
359 2 }
360
361 /* send an rtp packet. sequence number is incremented, but the caller
362 must update the timestamp itself */
363 263 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
364 {
365 263 RTPMuxContext *s = s1->priv_data;
366
367 263 av_log(s1, AV_LOG_TRACE, "rtp_send_data size=%d\n", len);
368
369 /* build the RTP header */
370 263 avio_w8(s1->pb, RTP_VERSION << 6);
371 263 avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
372 263 avio_wb16(s1->pb, s->seq);
373 263 avio_wb32(s1->pb, s->timestamp);
374 263 avio_wb32(s1->pb, s->ssrc);
375
376 263 avio_write(s1->pb, buf1, len);
377 263 avio_flush(s1->pb);
378
379 263 s->seq = (s->seq + 1) & 0xffff;
380 263 s->octet_count += len;
381 263 s->packet_count++;
382 263 }
383
384 /* send an integer number of samples and compute time stamp and fill
385 the rtp send buffer before sending. */
386 11 static int rtp_send_samples(AVFormatContext *s1,
387 const uint8_t *buf1, int size, int sample_size_bits)
388 {
389 11 RTPMuxContext *s = s1->priv_data;
390 int len, max_packet_size, n;
391 /* Calculate the number of bytes to get samples aligned on a byte border */
392 11 int aligned_samples_size = sample_size_bits/av_gcd(sample_size_bits, 8);
393
394 11 max_packet_size = (s->max_payload_size / aligned_samples_size) * aligned_samples_size;
395 /* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */
396
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
 11 if ((sample_size_bits % 8) == 0 && ((8 * size) % sample_size_bits) != 0)
397 ✗ return AVERROR(EINVAL);
398 11 n = 0;
399
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 11 times.
 44 while (size > 0) {
400 33 s->buf_ptr = s->buf;
401 33 len = FFMIN(max_packet_size, size);
402
403 /* copy data */
404 33 memcpy(s->buf_ptr, buf1, len);
405 33 s->buf_ptr += len;
406 33 buf1 += len;
407 33 size -= len;
408 33 s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits;
409 33 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
410 33 n += (s->buf_ptr - s->buf);
411 }
412 11 return 0;
413 }
414
415 ✗ static void rtp_send_mpegaudio(AVFormatContext *s1,
416 const uint8_t *buf1, int size)
417 {
418 ✗ RTPMuxContext *s = s1->priv_data;
419 int len, count, max_packet_size;
420
421 ✗ max_packet_size = s->max_payload_size;
422
423 /* test if we must flush because not enough space */
424 ✗ len = (s->buf_ptr - s->buf);
425 ✗ if ((len + size) > max_packet_size) {
426 ✗ if (len > 4) {
427 ✗ ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
428 ✗ s->buf_ptr = s->buf + 4;
429 }
430 }
431 ✗ if (s->buf_ptr == s->buf + 4) {
432 ✗ s->timestamp = s->cur_timestamp;
433 }
434
435 /* add the packet */
436 ✗ if (size > max_packet_size) {
437 /* big packet: fragment */
438 ✗ count = 0;
439 ✗ while (size > 0) {
440 ✗ len = max_packet_size - 4;
441 ✗ if (len > size)
442 ✗ len = size;
443 /* build fragmented packet */
444 ✗ s->buf[0] = 0;
445 ✗ s->buf[1] = 0;
446 ✗ s->buf[2] = count >> 8;
447 ✗ s->buf[3] = count;
448 ✗ memcpy(s->buf + 4, buf1, len);
449 ✗ ff_rtp_send_data(s1, s->buf, len + 4, 0);
450 ✗ size -= len;
451 ✗ buf1 += len;
452 ✗ count += len;
453 }
454 } else {
455 ✗ if (s->buf_ptr == s->buf + 4) {
456 /* no fragmentation possible */
457 ✗ s->buf[0] = 0;
458 ✗ s->buf[1] = 0;
459 ✗ s->buf[2] = 0;
460 ✗ s->buf[3] = 0;
461 }
462 ✗ memcpy(s->buf_ptr, buf1, size);
463 ✗ s->buf_ptr += size;
464 }
465 ✗ }
466
467 25 static void rtp_send_raw(AVFormatContext *s1,
468 const uint8_t *buf1, int size)
469 {
470 25 RTPMuxContext *s = s1->priv_data;
471 int len, max_packet_size;
472
473 25 max_packet_size = s->max_payload_size;
474
475
2/2
✓ Branch 0 taken 230 times.
✓ Branch 1 taken 25 times.
 255 while (size > 0) {
476 230 len = max_packet_size;
477
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 205 times.
 230 if (len > size)
478 25 len = size;
479
480 230 s->timestamp = s->cur_timestamp;
481 230 ff_rtp_send_data(s1, buf1, len, (len == size));
482
483 230 buf1 += len;
484 230 size -= len;
485 }
486 25 }
487
488 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
489 ✗ static void rtp_send_mpegts_raw(AVFormatContext *s1,
490 const uint8_t *buf1, int size)
491 {
492 ✗ RTPMuxContext *s = s1->priv_data;
493 int len, out_len;
494
495 ✗ s->timestamp = s->cur_timestamp;
496 ✗ while (size >= TS_PACKET_SIZE) {
497 ✗ len = s->max_payload_size - (s->buf_ptr - s->buf);
498 ✗ if (len > size)
499 ✗ len = size;
500 ✗ memcpy(s->buf_ptr, buf1, len);
501 ✗ buf1 += len;
502 ✗ size -= len;
503 ✗ s->buf_ptr += len;
504
505 ✗ out_len = s->buf_ptr - s->buf;
506 ✗ if (out_len >= s->max_payload_size) {
507 ✗ ff_rtp_send_data(s1, s->buf, out_len, 0);
508 ✗ s->buf_ptr = s->buf;
509 }
510 }
511 ✗ }
512
513 ✗ static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
514 {
515 ✗ RTPMuxContext *s = s1->priv_data;
516 ✗ AVStream *st = s1->streams[0];
517 ✗ int frame_duration = av_get_audio_frame_duration2(st->codecpar, 0);
518 ✗ int frame_size = st->codecpar->block_align;
519 ✗ int frames = size / frame_size;
520
521 ✗ while (frames > 0) {
522 ✗ if (s->num_frames > 0 &&
523 ✗ av_compare_ts(s->cur_timestamp - s->timestamp, st->time_base,
524 ✗ s1->max_delay, AV_TIME_BASE_Q) >= 0) {
525 ✗ ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
526 ✗ s->num_frames = 0;
527 }
528
529 ✗ if (!s->num_frames) {
530 ✗ s->buf_ptr = s->buf;
531 ✗ s->timestamp = s->cur_timestamp;
532 }
533 ✗ memcpy(s->buf_ptr, buf, frame_size);
534 ✗ frames--;
535 ✗ s->num_frames++;
536 ✗ s->buf_ptr += frame_size;
537 ✗ buf += frame_size;
538 ✗ s->cur_timestamp += frame_duration;
539
540 ✗ if (s->num_frames == s->max_frames_per_packet) {
541 ✗ ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
542 ✗ s->num_frames = 0;
543 }
544 }
545 ✗ return 0;
546 }
547
548 36 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
549 {
550 36 RTPMuxContext *s = s1->priv_data;
551 36 AVStream *st = s1->streams[0];
552 int rtcp_bytes;
553 36 int size= pkt->size;
554
555 36 av_log(s1, AV_LOG_TRACE, "%d: write len=%d\n", pkt->stream_index, size);
556
557 36 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
558 RTCP_TX_RATIO_DEN;
559
4/4
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 33 times.
✓ Branch 3 taken 1 times.
 36 if ((s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
560
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 33 times.
 33 (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) &&
561
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 !(s->flags & FF_RTP_FLAG_SKIP_RTCP)) {
562 2 rtcp_send_sr(s1, ff_ntp_time(), 0);
563 2 s->last_octet_count = s->octet_count;
564 2 s->first_packet = 0;
565 }
566 36 s->cur_timestamp = s->base_timestamp + pkt->pts;
567
568
2/25
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✓ Branch 24 taken 25 times.
 36 switch(st->codecpar->codec_id) {
569 11 case AV_CODEC_ID_PCM_MULAW:
570 case AV_CODEC_ID_PCM_ALAW:
571 case AV_CODEC_ID_PCM_U8:
572 case AV_CODEC_ID_PCM_S8:
573 11 return rtp_send_samples(s1, pkt->data, size, 8 * st->codecpar->ch_layout.nb_channels);
574 ✗ case AV_CODEC_ID_PCM_U16BE:
575 case AV_CODEC_ID_PCM_U16LE:
576 case AV_CODEC_ID_PCM_S16BE:
577 case AV_CODEC_ID_PCM_S16LE:
578 ✗ return rtp_send_samples(s1, pkt->data, size, 16 * st->codecpar->ch_layout.nb_channels);
579 ✗ case AV_CODEC_ID_PCM_S24BE:
580 ✗ return rtp_send_samples(s1, pkt->data, size, 24 * st->codecpar->ch_layout.nb_channels);
581 ✗ case AV_CODEC_ID_ADPCM_G722:
582 /* The actual sample size is half a byte per sample, but since the
583 * stream clock rate is 8000 Hz while the sample rate is 16000 Hz,
584 * the correct parameter for send_samples_bits is 8 bits per stream
585 * clock. */
586 ✗ return rtp_send_samples(s1, pkt->data, size, 8 * st->codecpar->ch_layout.nb_channels);
587 ✗ case AV_CODEC_ID_ADPCM_G726:
588 case AV_CODEC_ID_ADPCM_G726LE:
589 ✗ return rtp_send_samples(s1, pkt->data, size,
590 ✗ st->codecpar->bits_per_coded_sample * st->codecpar->ch_layout.nb_channels);
591 ✗ case AV_CODEC_ID_MP2:
592 case AV_CODEC_ID_MP3:
593 ✗ rtp_send_mpegaudio(s1, pkt->data, size);
594 ✗ break;
595 ✗ case AV_CODEC_ID_MPEG1VIDEO:
596 case AV_CODEC_ID_MPEG2VIDEO:
597 ✗ ff_rtp_send_mpegvideo(s1, pkt->data, size);
598 ✗ break;
599 ✗ case AV_CODEC_ID_AAC:
600 ✗ if (s->flags & FF_RTP_FLAG_MP4A_LATM)
601 ✗ ff_rtp_send_latm(s1, pkt->data, size);
602 else
603 ✗ ff_rtp_send_aac(s1, pkt->data, size);
604 ✗ break;
605 ✗ case AV_CODEC_ID_AMR_NB:
606 case AV_CODEC_ID_AMR_WB:
607 ✗ ff_rtp_send_amr(s1, pkt->data, size);
608 ✗ break;
609 ✗ case AV_CODEC_ID_AV1:
610 ✗ ff_rtp_send_av1(s1, pkt->data, size, (pkt->flags & AV_PKT_FLAG_KEY) ? 1 : 0);
611 ✗ break;
612 ✗ case AV_CODEC_ID_MPEG2TS:
613 ✗ rtp_send_mpegts_raw(s1, pkt->data, size);
614 ✗ break;
615 ✗ case AV_CODEC_ID_DIRAC:
616 ✗ ff_rtp_send_vc2hq(s1, pkt->data, size, st->codecpar->field_order != AV_FIELD_PROGRESSIVE ? 1 : 0);
617 ✗ break;
618 ✗ case AV_CODEC_ID_H264:
619 ✗ ff_rtp_send_h264_hevc(s1, pkt->data, size);
620 ✗ break;
621 ✗ case AV_CODEC_ID_H261:
622 ✗ ff_rtp_send_h261(s1, pkt->data, size);
623 ✗ break;
624 ✗ case AV_CODEC_ID_H263:
625 ✗ if (s->flags & FF_RTP_FLAG_RFC2190) {
626 size_t mb_info_size;
627 const uint8_t *mb_info =
628 ✗ av_packet_get_side_data(pkt, AV_PKT_DATA_H263_MB_INFO,
629 &mb_info_size);
630 ✗ ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size);
631 ✗ break;
632 }
633 /* Fallthrough */
634 case AV_CODEC_ID_H263P:
635 ✗ ff_rtp_send_h263(s1, pkt->data, size);
636 ✗ break;
637 ✗ case AV_CODEC_ID_HEVC:
638 ✗ ff_rtp_send_h264_hevc(s1, pkt->data, size);
639 ✗ break;
640 ✗ case AV_CODEC_ID_VORBIS:
641 case AV_CODEC_ID_THEORA:
642 ✗ ff_rtp_send_xiph(s1, pkt->data, size);
643 ✗ break;
644 ✗ case AV_CODEC_ID_VP8:
645 ✗ ff_rtp_send_vp8(s1, pkt->data, size);
646 ✗ break;
647 ✗ case AV_CODEC_ID_VP9:
648 ✗ ff_rtp_send_vp9(s1, pkt->data, size);
649 ✗ break;
650 ✗ case AV_CODEC_ID_ILBC:
651 ✗ rtp_send_ilbc(s1, pkt->data, size);
652 ✗ break;
653 ✗ case AV_CODEC_ID_MJPEG:
654 ✗ ff_rtp_send_jpeg(s1, pkt->data, size);
655 ✗ break;
656 ✗ case AV_CODEC_ID_BITPACKED:
657 case AV_CODEC_ID_RAWVIDEO: {
658 ✗ int interlaced = st->codecpar->field_order != AV_FIELD_PROGRESSIVE;
659
660 ✗ ff_rtp_send_raw_rfc4175(s1, pkt->data, size, interlaced, 0);
661 ✗ if (interlaced)
662 ✗ ff_rtp_send_raw_rfc4175(s1, pkt->data, size, interlaced, 1);
663 ✗ break;
664 }
665 ✗ case AV_CODEC_ID_OPUS:
666 ✗ if (size > s->max_payload_size) {
667 ✗ av_log(s1, AV_LOG_ERROR,
668 "Packet size %d too large for max RTP payload size %d\n",
669 size, s->max_payload_size);
670 ✗ return AVERROR(EINVAL);
671 }
672 /* Intentional fallthrough */
673 default:
674 /* better than nothing : send the codec raw data */
675 25 rtp_send_raw(s1, pkt->data, size);
676 25 break;
677 }
678 25 return 0;
679 }
680
681 2 static int rtp_write_trailer(AVFormatContext *s1)
682 {
683 2 RTPMuxContext *s = s1->priv_data;
684
685 /* If the caller closes and recreates ->pb, this might actually
686 * be NULL here even if it was successfully allocated at the start. */
687
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 if (s1->pb && (s->flags & FF_RTP_FLAG_SEND_BYE))
688 ✗ rtcp_send_sr(s1, ff_ntp_time(), 1);
689
690 2 return 0;
691 }
692
693 2 static void rtp_deinit(AVFormatContext *s1)
694 {
695 2 RTPMuxContext *s = s1->priv_data;
696
697 2 av_freep(&s->buf);
698 2 }
699
700 const FFOutputFormat ff_rtp_muxer = {
701 .p.name = "rtp",
702 .p.long_name = NULL_IF_CONFIG_SMALL("RTP output"),
703 .priv_data_size = sizeof(RTPMuxContext),
704 .p.audio_codec = AV_CODEC_ID_PCM_MULAW,
705 .p.video_codec = AV_CODEC_ID_MPEG4,
706 .write_header = rtp_write_header,
707 .write_packet = rtp_write_packet,
708 .write_trailer = rtp_write_trailer,
709 .deinit = rtp_deinit,
710 .p.priv_class = &rtp_muxer_class,
711 .p.flags = AVFMT_NODIMENSIONS | AVFMT_TS_NONSTRICT,
712 };
713