FFmpeg coverage

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