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