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