83a0d387 |
/*
* RTP output format |
406792e7 |
* Copyright (c) 2002 Fabrice Bellard |
83a0d387 |
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ |
245976da |
|
83a0d387 |
#include "avformat.h"
#include "mpegts.h" |
594a9aeb |
#include "internal.h" |
0ebcdf5c |
#include "libavutil/mathematics.h" |
4c1202f7 |
#include "libavutil/random_seed.h" |
08321228 |
#include "libavutil/opt.h" |
83a0d387 |
|
302879cb |
#include "rtpenc.h" |
83a0d387 |
|
08321228 |
static const AVOption options[] = { |
5354a904 |
FF_RTP_FLAG_OPTS(RTPMuxContext, flags), |
e6153f17 |
{ "payload_type", "Specify RTP payload type", offsetof(RTPMuxContext, payload_type), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 127, AV_OPT_FLAG_ENCODING_PARAM },
{ "ssrc", "Stream identifier", offsetof(RTPMuxContext, ssrc), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM }, |
3b2e8d1d |
{ "cname", "CNAME to include in RTCP SR packets", offsetof(RTPMuxContext, cname), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM }, |
ab587f39 |
{ "seq", "Starting sequence number", offsetof(RTPMuxContext, seq), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 65535, AV_OPT_FLAG_ENCODING_PARAM }, |
08321228 |
{ NULL },
};
static const AVClass rtp_muxer_class = {
.class_name = "RTP muxer",
.item_name = av_default_item_name,
.option = options,
.version = LIBAVUTIL_VERSION_INT,
};
|
83a0d387 |
#define RTCP_SR_SIZE 28
|
36ef5369 |
static int is_supported(enum AVCodecID id) |
0766c3ee |
{
switch(id) { |
f591b7b5 |
case AV_CODEC_ID_DIRAC: |
50a4d5cf |
case AV_CODEC_ID_H261: |
36ef5369 |
case AV_CODEC_ID_H263:
case AV_CODEC_ID_H263P:
case AV_CODEC_ID_H264: |
6821a5a4 |
case AV_CODEC_ID_HEVC: |
36ef5369 |
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
case AV_CODEC_ID_MPEG4:
case AV_CODEC_ID_AAC:
case AV_CODEC_ID_MP2:
case AV_CODEC_ID_MP3:
case AV_CODEC_ID_PCM_ALAW:
case AV_CODEC_ID_PCM_MULAW:
case AV_CODEC_ID_PCM_S8:
case AV_CODEC_ID_PCM_S16BE:
case AV_CODEC_ID_PCM_S16LE: |
75bd0109 |
case AV_CODEC_ID_PCM_S24BE: |
36ef5369 |
case AV_CODEC_ID_PCM_U16BE:
case AV_CODEC_ID_PCM_U16LE:
case AV_CODEC_ID_PCM_U8:
case AV_CODEC_ID_MPEG2TS:
case AV_CODEC_ID_AMR_NB:
case AV_CODEC_ID_AMR_WB:
case AV_CODEC_ID_VORBIS:
case AV_CODEC_ID_THEORA:
case AV_CODEC_ID_VP8: |
668fb1cb |
case AV_CODEC_ID_VP9: |
36ef5369 |
case AV_CODEC_ID_ADPCM_G722:
case AV_CODEC_ID_ADPCM_G726: |
2386cfc1 |
case AV_CODEC_ID_ADPCM_G726LE: |
36ef5369 |
case AV_CODEC_ID_ILBC: |
cee1950b |
case AV_CODEC_ID_MJPEG: |
490ae95a |
case AV_CODEC_ID_SPEEX: |
c136a813 |
case AV_CODEC_ID_OPUS: |
0766c3ee |
return 1;
default:
return 0;
}
}
|
83a0d387 |
static int rtp_write_header(AVFormatContext *s1)
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
a505c0d7 |
int n, ret = AVERROR(EINVAL); |
83a0d387 |
AVStream *st;
|
ada4e362 |
if (s1->nb_streams != 1) {
av_log(s1, AV_LOG_ERROR, "Only one stream supported in the RTP muxer\n");
return AVERROR(EINVAL);
} |
83a0d387 |
st = s1->streams[0]; |
9200514a |
if (!is_supported(st->codecpar->codec_id)) { |
6f69f7a8 |
av_log(s1, AV_LOG_ERROR, "Unsupported codec %s\n", avcodec_get_name(st->codecpar->codec_id)); |
0766c3ee |
return -1;
} |
83a0d387 |
|
8034130e |
if (s->payload_type < 0) {
/* Re-validate non-dynamic payload types */
if (st->id < RTP_PT_PRIVATE) |
9200514a |
st->id = ff_rtp_get_payload_type(s1, st->codecpar, -1); |
8034130e |
s->payload_type = st->id;
} else {
/* private option takes priority */
st->id = s->payload_type;
}
|
576fb48e |
s->base_timestamp = av_get_random_seed(); |
83a0d387 |
s->timestamp = s->base_timestamp;
s->cur_timestamp = 0; |
2dcb21a9 |
if (!s->ssrc)
s->ssrc = av_get_random_seed(); |
83a0d387 |
s->first_packet = 1; |
594a9aeb |
s->first_rtcp_ntp_time = ff_ntp_time(); |
3f3229cd |
if (s1->start_time_realtime != 0 && s1->start_time_realtime != AV_NOPTS_VALUE) |
b1d55e5e |
/* Round the NTP time to whole milliseconds. */
s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
NTP_OFFSET_US; |
ab587f39 |
// Pick a random sequence start number, but in the lower end of the
// available range, so that any wraparound doesn't happen immediately.
// (Immediate wraparound would be an issue for SRTP.) |
9774251c |
if (s->seq < 0) { |
0323a55c |
if (s1->flags & AVFMT_FLAG_BITEXACT) { |
9774251c |
s->seq = 0;
} else
s->seq = av_get_random_seed() & 0x0fff;
} else |
ab587f39 |
s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval |
83a0d387 |
|
316e724f |
if (s1->packet_size) { |
ba605cef |
if (s1->pb->max_packet_size) |
316e724f |
s1->packet_size = FFMIN(s1->packet_size,
s1->pb->max_packet_size); |
ba605cef |
} else |
316e724f |
s1->packet_size = s1->pb->max_packet_size;
if (s1->packet_size <= 12) { |
1263b203 |
av_log(s1, AV_LOG_ERROR, "Max packet size %u too low\n", s1->packet_size); |
83a0d387 |
return AVERROR(EIO); |
ba83ac4c |
} |
316e724f |
s->buf = av_malloc(s1->packet_size); |
f929ab05 |
if (!s->buf) { |
d3536678 |
return AVERROR(ENOMEM);
} |
316e724f |
s->max_payload_size = s1->packet_size - 12; |
83a0d387 |
|
9200514a |
if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate); |
f8c01257 |
} else {
avpriv_set_pts_info(st, 32, 1, 90000);
}
s->buf_ptr = s->buf; |
9200514a |
switch(st->codecpar->codec_id) { |
36ef5369 |
case AV_CODEC_ID_MP2:
case AV_CODEC_ID_MP3: |
83a0d387 |
s->buf_ptr = s->buf + 4; |
f8c01257 |
avpriv_set_pts_info(st, 32, 1, 90000); |
83a0d387 |
break; |
36ef5369 |
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO: |
83a0d387 |
break; |
36ef5369 |
case AV_CODEC_ID_MPEG2TS: |
83a0d387 |
n = s->max_payload_size / TS_PACKET_SIZE;
if (n < 1)
n = 1;
s->max_payload_size = n * TS_PACKET_SIZE;
break; |
f591b7b5 |
case AV_CODEC_ID_DIRAC:
if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
av_log(s, AV_LOG_ERROR,
"Packetizing VC-2 is experimental and does not use all values "
"of the specification "
"(even though most receivers may handle it just fine). "
"Please set -strict experimental in order to enable it.\n");
ret = AVERROR_EXPERIMENTAL;
goto fail;
}
break; |
a505c0d7 |
case AV_CODEC_ID_H261:
if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
av_log(s, AV_LOG_ERROR, |
41ed7ab4 |
"Packetizing H.261 is experimental and produces incorrect " |
a505c0d7 |
"packetization for cases where GOBs don't fit into packets "
"(even though most receivers may handle it just fine). "
"Please set -f_strict experimental in order to enable it.\n");
ret = AVERROR_EXPERIMENTAL;
goto fail;
}
break; |
36ef5369 |
case AV_CODEC_ID_H264: |
8b889b34 |
/* check for H.264 MP4 syntax */ |
9200514a |
if (st->codecpar->extradata_size > 4 && st->codecpar->extradata[0] == 1) {
s->nal_length_size = (st->codecpar->extradata[4] & 0x03) + 1; |
8b889b34 |
}
break; |
6821a5a4 |
case AV_CODEC_ID_HEVC: |
ddf5fb71 |
/* Only check for the standardized hvcC version of extradata, keeping |
41ed7ab4 |
* things simple and similar to the avcC/H.264 case above, instead |
ddf5fb71 |
* of trying to handle the pre-standardization versions (as in
* libavcodec/hevc.c). */ |
9200514a |
if (st->codecpar->extradata_size > 21 && st->codecpar->extradata[0] == 1) {
s->nal_length_size = (st->codecpar->extradata[21] & 0x03) + 1; |
6821a5a4 |
}
break; |
668fb1cb |
case AV_CODEC_ID_VP9:
if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
av_log(s, AV_LOG_ERROR,
"Packetizing VP9 is experimental and its specification is "
"still in draft state. "
"Please set -strict experimental in order to enable it.\n");
ret = AVERROR_EXPERIMENTAL;
goto fail;
}
break; |
36ef5369 |
case AV_CODEC_ID_VORBIS:
case AV_CODEC_ID_THEORA: |
4f6cd883 |
s->max_frames_per_packet = 15; |
f8c01257 |
break; |
36ef5369 |
case AV_CODEC_ID_ADPCM_G722: |
0048a2a8 |
/* Due to a historical error, the clock rate for G722 in RTP is
* 8000, even if the sample rate is 16000. See RFC 3551. */ |
c3f9ebf7 |
avpriv_set_pts_info(st, 32, 1, 8000); |
0048a2a8 |
break; |
c136a813 |
case AV_CODEC_ID_OPUS: |
9200514a |
if (st->codecpar->channels > 2) { |
c136a813 |
av_log(s1, AV_LOG_ERROR, "Multistream opus not supported in RTP\n");
goto fail;
}
/* The opus RTP RFC says that all opus streams should use 48000 Hz
* as clock rate, since all opus sample rates can be expressed in
* this clock rate, and sample rate changes on the fly are supported. */
avpriv_set_pts_info(st, 32, 1, 48000);
break; |
36ef5369 |
case AV_CODEC_ID_ILBC: |
9200514a |
if (st->codecpar->block_align != 38 && st->codecpar->block_align != 50) { |
579fd87b |
av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");
goto fail;
} |
9200514a |
s->max_frames_per_packet = s->max_payload_size / st->codecpar->block_align; |
f8c01257 |
break; |
36ef5369 |
case AV_CODEC_ID_AMR_NB:
case AV_CODEC_ID_AMR_WB: |
4f6cd883 |
s->max_frames_per_packet = 50; |
9200514a |
if (st->codecpar->codec_id == AV_CODEC_ID_AMR_NB) |
08e696c0 |
n = 31;
else
n = 61;
/* max_header_toc_size + the largest AMR payload must fit */
if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n"); |
e9ef88fb |
goto fail; |
08e696c0 |
} |
9200514a |
if (st->codecpar->channels != 1) { |
08e696c0 |
av_log(s1, AV_LOG_ERROR, "Only mono is supported\n"); |
e9ef88fb |
goto fail; |
08e696c0 |
} |
f8c01257 |
break; |
36ef5369 |
case AV_CODEC_ID_AAC: |
4f6cd883 |
s->max_frames_per_packet = 50; |
f8c01257 |
break; |
83a0d387 |
default:
break;
}
return 0; |
e9ef88fb |
fail:
av_freep(&s->buf); |
a505c0d7 |
return ret; |
83a0d387 |
}
/* send an rtcp sender report packet */ |
9ceed7af |
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye) |
83a0d387 |
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
83a0d387 |
uint32_t rtp_ts;
|
54904525 |
av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %"PRIx32"\n", s->payload_type, ntp_time, s->timestamp); |
83a0d387 |
s->last_rtcp_ntp_time = ntp_time; |
a4696aa2 |
rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000}, |
83a0d387 |
s1->streams[0]->time_base) + s->base_timestamp; |
b264453d |
avio_w8(s1->pb, RTP_VERSION << 6); |
77eb5504 |
avio_w8(s1->pb, RTCP_SR);
avio_wb16(s1->pb, 6); /* length in words - 1 */
avio_wb32(s1->pb, s->ssrc); |
1109ed79 |
avio_wb32(s1->pb, ntp_time / 1000000);
avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000); |
77eb5504 |
avio_wb32(s1->pb, rtp_ts);
avio_wb32(s1->pb, s->packet_count);
avio_wb32(s1->pb, s->octet_count); |
3b2e8d1d |
if (s->cname) {
int len = FFMIN(strlen(s->cname), 255);
avio_w8(s1->pb, (RTP_VERSION << 6) + 1);
avio_w8(s1->pb, RTCP_SDES);
avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */
avio_wb32(s1->pb, s->ssrc);
avio_w8(s1->pb, 0x01); /* CNAME */
avio_w8(s1->pb, len);
avio_write(s1->pb, s->cname, len);
avio_w8(s1->pb, 0); /* END */
for (len = (7 + len) % 4; len % 4; len++)
avio_w8(s1->pb, 0);
}
|
9ceed7af |
if (bye) {
avio_w8(s1->pb, (RTP_VERSION << 6) | 1);
avio_w8(s1->pb, RTCP_BYE);
avio_wb16(s1->pb, 1); /* length in words - 1 */
avio_wb32(s1->pb, s->ssrc);
}
|
b7f2fdde |
avio_flush(s1->pb); |
83a0d387 |
}
/* send an rtp packet. sequence number is incremented, but the caller
must update the timestamp itself */
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
83a0d387 |
|
1a3eb042 |
av_log(s1, AV_LOG_TRACE, "rtp_send_data size=%d\n", len); |
83a0d387 |
/* build the RTP header */ |
b264453d |
avio_w8(s1->pb, RTP_VERSION << 6); |
77eb5504 |
avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
avio_wb16(s1->pb, s->seq);
avio_wb32(s1->pb, s->timestamp);
avio_wb32(s1->pb, s->ssrc); |
83a0d387 |
|
77eb5504 |
avio_write(s1->pb, buf1, len); |
b7f2fdde |
avio_flush(s1->pb); |
83a0d387 |
|
ab587f39 |
s->seq = (s->seq + 1) & 0xffff; |
83a0d387 |
s->octet_count += len;
s->packet_count++;
}
/* send an integer number of samples and compute time stamp and fill
the rtp send buffer before sending. */ |
bfb82fcd |
static int rtp_send_samples(AVFormatContext *s1,
const uint8_t *buf1, int size, int sample_size_bits) |
83a0d387 |
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
83a0d387 |
int len, max_packet_size, n; |
77e0c758 |
/* Calculate the number of bytes to get samples aligned on a byte border */
int aligned_samples_size = sample_size_bits/av_gcd(sample_size_bits, 8); |
83a0d387 |
|
77e0c758 |
max_packet_size = (s->max_payload_size / aligned_samples_size) * aligned_samples_size;
/* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */
if ((sample_size_bits % 8) == 0 && ((8 * size) % sample_size_bits) != 0) |
bfb82fcd |
return AVERROR(EINVAL); |
83a0d387 |
n = 0;
while (size > 0) {
s->buf_ptr = s->buf;
len = FFMIN(max_packet_size, size);
/* copy data */
memcpy(s->buf_ptr, buf1, len);
s->buf_ptr += len;
buf1 += len;
size -= len; |
77e0c758 |
s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits; |
83a0d387 |
ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
n += (s->buf_ptr - s->buf);
} |
bfb82fcd |
return 0; |
83a0d387 |
}
static void rtp_send_mpegaudio(AVFormatContext *s1,
const uint8_t *buf1, int size)
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
83a0d387 |
int len, count, max_packet_size;
max_packet_size = s->max_payload_size;
/* test if we must flush because not enough space */
len = (s->buf_ptr - s->buf);
if ((len + size) > max_packet_size) {
if (len > 4) {
ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
s->buf_ptr = s->buf + 4;
}
}
if (s->buf_ptr == s->buf + 4) {
s->timestamp = s->cur_timestamp;
}
/* add the packet */
if (size > max_packet_size) {
/* big packet: fragment */
count = 0;
while (size > 0) {
len = max_packet_size - 4;
if (len > size)
len = size;
/* build fragmented packet */
s->buf[0] = 0;
s->buf[1] = 0;
s->buf[2] = count >> 8;
s->buf[3] = count;
memcpy(s->buf + 4, buf1, len);
ff_rtp_send_data(s1, s->buf, len + 4, 0);
size -= len;
buf1 += len;
count += len;
}
} else {
if (s->buf_ptr == s->buf + 4) {
/* no fragmentation possible */
s->buf[0] = 0;
s->buf[1] = 0;
s->buf[2] = 0;
s->buf[3] = 0;
}
memcpy(s->buf_ptr, buf1, size);
s->buf_ptr += size;
}
}
static void rtp_send_raw(AVFormatContext *s1,
const uint8_t *buf1, int size)
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
83a0d387 |
int len, max_packet_size;
max_packet_size = s->max_payload_size;
while (size > 0) {
len = max_packet_size;
if (len > size)
len = size;
s->timestamp = s->cur_timestamp;
ff_rtp_send_data(s1, buf1, len, (len == size));
buf1 += len;
size -= len;
}
}
/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
static void rtp_send_mpegts_raw(AVFormatContext *s1,
const uint8_t *buf1, int size)
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
83a0d387 |
int len, out_len;
|
01f251c4 |
s->timestamp = s->cur_timestamp; |
83a0d387 |
while (size >= TS_PACKET_SIZE) {
len = s->max_payload_size - (s->buf_ptr - s->buf);
if (len > size)
len = size;
memcpy(s->buf_ptr, buf1, len);
buf1 += len;
size -= len;
s->buf_ptr += len;
out_len = s->buf_ptr - s->buf;
if (out_len >= s->max_payload_size) {
ff_rtp_send_data(s1, s->buf, out_len, 0);
s->buf_ptr = s->buf;
}
}
}
|
579fd87b |
static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)
{
RTPMuxContext *s = s1->priv_data;
AVStream *st = s1->streams[0]; |
9200514a |
int frame_duration = av_get_audio_frame_duration2(st->codecpar, 0);
int frame_size = st->codecpar->block_align; |
579fd87b |
int frames = size / frame_size;
while (frames > 0) { |
4f6cd883 |
if (s->num_frames > 0 &&
av_compare_ts(s->cur_timestamp - s->timestamp, st->time_base,
s1->max_delay, AV_TIME_BASE_Q) >= 0) {
ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
s->num_frames = 0;
} |
579fd87b |
if (!s->num_frames) {
s->buf_ptr = s->buf;
s->timestamp = s->cur_timestamp;
} |
4f6cd883 |
memcpy(s->buf_ptr, buf, frame_size);
frames--;
s->num_frames++;
s->buf_ptr += frame_size;
buf += frame_size;
s->cur_timestamp += frame_duration; |
579fd87b |
if (s->num_frames == s->max_frames_per_packet) {
ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);
s->num_frames = 0;
}
}
return 0;
}
|
83a0d387 |
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
{ |
302879cb |
RTPMuxContext *s = s1->priv_data; |
83a0d387 |
AVStream *st = s1->streams[0];
int rtcp_bytes;
int size= pkt->size;
|
1a3eb042 |
av_log(s1, AV_LOG_TRACE, "%d: write len=%d\n", pkt->stream_index, size); |
83a0d387 |
rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
RTCP_TX_RATIO_DEN; |
7337484e |
if ((s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
(ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) &&
!(s->flags & FF_RTP_FLAG_SKIP_RTCP)) { |
9ceed7af |
rtcp_send_sr(s1, ff_ntp_time(), 0); |
83a0d387 |
s->last_octet_count = s->octet_count;
s->first_packet = 0;
}
s->cur_timestamp = s->base_timestamp + pkt->pts;
|
9200514a |
switch(st->codecpar->codec_id) { |
36ef5369 |
case AV_CODEC_ID_PCM_MULAW:
case AV_CODEC_ID_PCM_ALAW:
case AV_CODEC_ID_PCM_U8:
case AV_CODEC_ID_PCM_S8: |
9200514a |
return rtp_send_samples(s1, pkt->data, size, 8 * st->codecpar->channels); |
36ef5369 |
case AV_CODEC_ID_PCM_U16BE:
case AV_CODEC_ID_PCM_U16LE:
case AV_CODEC_ID_PCM_S16BE:
case AV_CODEC_ID_PCM_S16LE: |
9200514a |
return rtp_send_samples(s1, pkt->data, size, 16 * st->codecpar->channels); |
75bd0109 |
case AV_CODEC_ID_PCM_S24BE:
return rtp_send_samples(s1, pkt->data, size, 24 * st->codecpar->channels); |
36ef5369 |
case AV_CODEC_ID_ADPCM_G722: |
0048a2a8 |
/* The actual sample size is half a byte per sample, but since the
* stream clock rate is 8000 Hz while the sample rate is 16000 Hz, |
77e0c758 |
* the correct parameter for send_samples_bits is 8 bits per stream
* clock. */ |
9200514a |
return rtp_send_samples(s1, pkt->data, size, 8 * st->codecpar->channels); |
36ef5369 |
case AV_CODEC_ID_ADPCM_G726: |
2386cfc1 |
case AV_CODEC_ID_ADPCM_G726LE: |
bfb82fcd |
return rtp_send_samples(s1, pkt->data, size, |
9200514a |
st->codecpar->bits_per_coded_sample * st->codecpar->channels); |
36ef5369 |
case AV_CODEC_ID_MP2:
case AV_CODEC_ID_MP3: |
d3d1eae6 |
rtp_send_mpegaudio(s1, pkt->data, size); |
83a0d387 |
break; |
36ef5369 |
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO: |
d3d1eae6 |
ff_rtp_send_mpegvideo(s1, pkt->data, size); |
83a0d387 |
break; |
36ef5369 |
case AV_CODEC_ID_AAC: |
08321228 |
if (s->flags & FF_RTP_FLAG_MP4A_LATM) |
ef409645 |
ff_rtp_send_latm(s1, pkt->data, size);
else
ff_rtp_send_aac(s1, pkt->data, size); |
83a0d387 |
break; |
36ef5369 |
case AV_CODEC_ID_AMR_NB:
case AV_CODEC_ID_AMR_WB: |
d3d1eae6 |
ff_rtp_send_amr(s1, pkt->data, size); |
08e696c0 |
break; |
36ef5369 |
case AV_CODEC_ID_MPEG2TS: |
d3d1eae6 |
rtp_send_mpegts_raw(s1, pkt->data, size); |
83a0d387 |
break; |
f591b7b5 |
case AV_CODEC_ID_DIRAC:
ff_rtp_send_vc2hq(s1, pkt->data, size, st->codecpar->field_order != AV_FIELD_PROGRESSIVE ? 1 : 0);
break; |
36ef5369 |
case AV_CODEC_ID_H264: |
c82bf15d |
ff_rtp_send_h264_hevc(s1, pkt->data, size); |
f79bfe48 |
break; |
50a4d5cf |
case AV_CODEC_ID_H261:
ff_rtp_send_h261(s1, pkt->data, size);
break; |
36ef5369 |
case AV_CODEC_ID_H263: |
c4584f3c |
if (s->flags & FF_RTP_FLAG_RFC2190) { |
984b914c |
int mb_info_size = 0;
const uint8_t *mb_info =
av_packet_get_side_data(pkt, AV_PKT_DATA_H263_MB_INFO,
&mb_info_size);
ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size); |
c4584f3c |
break;
}
/* Fallthrough */ |
36ef5369 |
case AV_CODEC_ID_H263P: |
d3d1eae6 |
ff_rtp_send_h263(s1, pkt->data, size); |
9edfaf3c |
break; |
6821a5a4 |
case AV_CODEC_ID_HEVC: |
c82bf15d |
ff_rtp_send_h264_hevc(s1, pkt->data, size); |
6821a5a4 |
break; |
36ef5369 |
case AV_CODEC_ID_VORBIS:
case AV_CODEC_ID_THEORA: |
91af5601 |
ff_rtp_send_xiph(s1, pkt->data, size);
break; |
36ef5369 |
case AV_CODEC_ID_VP8: |
7b18d94c |
ff_rtp_send_vp8(s1, pkt->data, size);
break; |
668fb1cb |
case AV_CODEC_ID_VP9:
ff_rtp_send_vp9(s1, pkt->data, size);
break; |
36ef5369 |
case AV_CODEC_ID_ILBC: |
579fd87b |
rtp_send_ilbc(s1, pkt->data, size);
break; |
cee1950b |
case AV_CODEC_ID_MJPEG:
ff_rtp_send_jpeg(s1, pkt->data, size);
break; |
c136a813 |
case AV_CODEC_ID_OPUS:
if (size > s->max_payload_size) {
av_log(s1, AV_LOG_ERROR,
"Packet size %d too large for max RTP payload size %d\n",
size, s->max_payload_size);
return AVERROR(EINVAL);
}
/* Intentional fallthrough */ |
83a0d387 |
default:
/* better than nothing : send the codec raw data */ |
d3d1eae6 |
rtp_send_raw(s1, pkt->data, size); |
83a0d387 |
break;
}
return 0;
}
|
d3536678 |
static int rtp_write_trailer(AVFormatContext *s1)
{
RTPMuxContext *s = s1->priv_data;
|
9ceed7af |
/* If the caller closes and recreates ->pb, this might actually
* be NULL here even if it was successfully allocated at the start. */
if (s1->pb && (s->flags & FF_RTP_FLAG_SEND_BYE))
rtcp_send_sr(s1, ff_ntp_time(), 1); |
d3536678 |
av_freep(&s->buf);
return 0;
}
|
c6610a21 |
AVOutputFormat ff_rtp_muxer = { |
dfc2c4d9 |
.name = "rtp", |
6774247a |
.long_name = NULL_IF_CONFIG_SMALL("RTP output"), |
dfc2c4d9 |
.priv_data_size = sizeof(RTPMuxContext), |
36ef5369 |
.audio_codec = AV_CODEC_ID_PCM_MULAW,
.video_codec = AV_CODEC_ID_MPEG4, |
dfc2c4d9 |
.write_header = rtp_write_header,
.write_packet = rtp_write_packet,
.write_trailer = rtp_write_trailer, |
20234a4b |
.priv_class = &rtp_muxer_class, |
42181740 |
.flags = AVFMT_TS_NONSTRICT, |
83a0d387 |
}; |