FFmpeg coverage

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