FFmpeg coverage

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