#include "avformat.h"
#include "internal.h"
#include "avc.h"
+#include "hevc.h"
#include "rtp.h"
#if CONFIG_NETWORK
#include "network.h"
}
#define MAX_PSET_SIZE 1024
-static char *extradata2psets(AVCodecContext *c)
+static char *extradata2psets(AVFormatContext *s, AVCodecParameters *par)
{
char *psets, *p;
const uint8_t *r;
static const char pset_string[] = "; sprop-parameter-sets=";
static const char profile_string[] = "; profile-level-id=";
- uint8_t *orig_extradata = NULL;
- int orig_extradata_size = 0;
+ uint8_t *extradata = par->extradata;
+ int extradata_size = par->extradata_size;
+ uint8_t *tmpbuf = NULL;
const uint8_t *sps = NULL, *sps_end;
- if (c->extradata_size > MAX_EXTRADATA_SIZE) {
- av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
+ if (par->extradata_size > MAX_EXTRADATA_SIZE) {
+ av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
return NULL;
}
- if (c->extradata[0] == 1) {
- uint8_t *dummy_p;
- int dummy_int;
- AVBitStreamFilterContext *bsfc= av_bitstream_filter_init("h264_mp4toannexb");
-
- if (!bsfc) {
- av_log(c, AV_LOG_ERROR, "Cannot open the h264_mp4toannexb BSF!\n");
-
- return NULL;
- }
-
- orig_extradata_size = c->extradata_size;
- orig_extradata = av_mallocz(orig_extradata_size +
- FF_INPUT_BUFFER_PADDING_SIZE);
- if (!orig_extradata) {
- av_bitstream_filter_close(bsfc);
+ if (par->extradata[0] == 1) {
+ if (ff_avc_write_annexb_extradata(par->extradata, &extradata,
+ &extradata_size))
return NULL;
- }
- memcpy(orig_extradata, c->extradata, orig_extradata_size);
- av_bitstream_filter_filter(bsfc, c, NULL, &dummy_p, &dummy_int, NULL, 0, 0);
- av_bitstream_filter_close(bsfc);
+ tmpbuf = extradata;
}
psets = av_mallocz(MAX_PSET_SIZE);
- if (psets == NULL) {
- av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the parameter sets.\n");
- av_free(orig_extradata);
+ if (!psets) {
+ av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the parameter sets.\n");
+ av_free(tmpbuf);
return NULL;
}
memcpy(psets, pset_string, strlen(pset_string));
p = psets + strlen(pset_string);
- r = ff_avc_find_startcode(c->extradata, c->extradata + c->extradata_size);
- while (r < c->extradata + c->extradata_size) {
+ r = ff_avc_find_startcode(extradata, extradata + extradata_size);
+ while (r < extradata + extradata_size) {
const uint8_t *r1;
uint8_t nal_type;
while (!*(r++));
nal_type = *r & 0x1f;
- r1 = ff_avc_find_startcode(r, c->extradata + c->extradata_size);
+ r1 = ff_avc_find_startcode(r, extradata + extradata_size);
if (nal_type != 7 && nal_type != 8) { /* Only output SPS and PPS */
r = r1;
continue;
sps = r;
sps_end = r1;
}
- if (av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r) == NULL) {
- av_log(c, AV_LOG_ERROR, "Cannot Base64-encode %td %td!\n", MAX_PSET_SIZE - (p - psets), r1 - r);
+ if (!av_base64_encode(p, MAX_PSET_SIZE - (p - psets), r, r1 - r)) {
+ av_log(s, AV_LOG_ERROR, "Cannot Base64-encode %td %td!\n", MAX_PSET_SIZE - (p - psets), r1 - r);
av_free(psets);
+ av_free(tmpbuf);
return NULL;
}
ff_data_to_hex(p, sps + 1, 3, 0);
p[6] = '\0';
}
- if (orig_extradata) {
- av_free(c->extradata);
- c->extradata = orig_extradata;
- c->extradata_size = orig_extradata_size;
+ av_free(tmpbuf);
+
+ return psets;
+}
+
+static char *extradata2psets_hevc(AVCodecParameters *par)
+{
+ char *psets;
+ uint8_t *extradata = par->extradata;
+ int extradata_size = par->extradata_size;
+ uint8_t *tmpbuf = NULL;
+ int ps_pos[3] = { 0 };
+ static const char * const ps_names[3] = { "vps", "sps", "pps" };
+ int num_arrays, num_nalus;
+ int pos, i, j;
+
+ // Convert to hvcc format. Since we need to group multiple NALUs of
+ // the same type, and we might need to convert from one format to the
+ // other anyway, we get away with a little less work by using the hvcc
+ // format.
+ if (par->extradata[0] != 1) {
+ AVIOContext *pb;
+ if (avio_open_dyn_buf(&pb) < 0)
+ return NULL;
+ if (ff_isom_write_hvcc(pb, par->extradata, par->extradata_size, 0) < 0) {
+ avio_close_dyn_buf(pb, &tmpbuf);
+ goto err;
+ }
+ extradata_size = avio_close_dyn_buf(pb, &extradata);
+ tmpbuf = extradata;
+ }
+
+ if (extradata_size < 23)
+ goto err;
+
+ num_arrays = extradata[22];
+ pos = 23;
+ for (i = 0; i < num_arrays; i++) {
+ int num_nalus, nalu_type;
+ if (pos + 3 > extradata_size)
+ goto err;
+ nalu_type = extradata[pos] & 0x3f;
+ // Not including libavcodec/hevc.h to avoid confusion between
+ // NAL_* with the same name for both H.264 and HEVC.
+ if (nalu_type == 32) // VPS
+ ps_pos[0] = pos;
+ else if (nalu_type == 33) // SPS
+ ps_pos[1] = pos;
+ else if (nalu_type == 34) // PPS
+ ps_pos[2] = pos;
+ num_nalus = AV_RB16(&extradata[pos + 1]);
+ pos += 3;
+ for (j = 0; j < num_nalus; j++) {
+ int len;
+ if (pos + 2 > extradata_size)
+ goto err;
+ len = AV_RB16(&extradata[pos]);
+ pos += 2;
+ if (pos + len > extradata_size)
+ goto err;
+ pos += len;
+ }
}
+ if (!ps_pos[0] || !ps_pos[1] || !ps_pos[2])
+ goto err;
+
+ psets = av_mallocz(MAX_PSET_SIZE);
+ if (!psets)
+ goto err;
+ psets[0] = '\0';
+
+ for (i = 0; i < 3; i++) {
+ pos = ps_pos[i];
+
+ if (i > 0)
+ av_strlcat(psets, "; ", MAX_PSET_SIZE);
+ av_strlcatf(psets, MAX_PSET_SIZE, "sprop-%s=", ps_names[i]);
+
+ // Skipping boundary checks in the input here; we've already traversed
+ // the whole hvcc structure above without issues
+ num_nalus = AV_RB16(&extradata[pos + 1]);
+ pos += 3;
+ for (j = 0; j < num_nalus; j++) {
+ int len = AV_RB16(&extradata[pos]);
+ int strpos;
+ pos += 2;
+ if (j > 0)
+ av_strlcat(psets, ",", MAX_PSET_SIZE);
+ strpos = strlen(psets);
+ if (!av_base64_encode(psets + strpos, MAX_PSET_SIZE - strpos,
+ &extradata[pos], len)) {
+ av_free(psets);
+ goto err;
+ }
+ pos += len;
+ }
+ }
+ av_free(tmpbuf);
return psets;
+
+err:
+ av_free(tmpbuf);
+ return NULL;
}
-static char *extradata2config(AVCodecContext *c)
+static char *extradata2config(AVFormatContext *s, AVCodecParameters *par)
{
char *config;
- if (c->extradata_size > MAX_EXTRADATA_SIZE) {
- av_log(c, AV_LOG_ERROR, "Too much extradata!\n");
+ if (par->extradata_size > MAX_EXTRADATA_SIZE) {
+ av_log(s, AV_LOG_ERROR, "Too much extradata!\n");
return NULL;
}
- config = av_malloc(10 + c->extradata_size * 2);
- if (config == NULL) {
- av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
+ config = av_malloc(10 + par->extradata_size * 2);
+ if (!config) {
+ av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
return NULL;
}
memcpy(config, "; config=", 9);
- ff_data_to_hex(config + 9, c->extradata, c->extradata_size, 0);
- config[9 + c->extradata_size * 2] = 0;
+ ff_data_to_hex(config + 9, par->extradata, par->extradata_size, 0);
+ config[9 + par->extradata_size * 2] = 0;
return config;
}
-static char *xiph_extradata2config(AVCodecContext *c)
+static char *xiph_extradata2config(AVFormatContext *s, AVCodecParameters *par)
{
char *config, *encoded_config;
uint8_t *header_start[3];
int headers_len, header_len[3], config_len;
int first_header_size;
- switch (c->codec_id) {
+ switch (par->codec_id) {
case AV_CODEC_ID_THEORA:
first_header_size = 42;
break;
first_header_size = 30;
break;
default:
- av_log(c, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
+ av_log(s, AV_LOG_ERROR, "Unsupported Xiph codec ID\n");
return NULL;
}
- if (avpriv_split_xiph_headers(c->extradata, c->extradata_size,
+ if (avpriv_split_xiph_headers(par->extradata, par->extradata_size,
first_header_size, header_start,
header_len) < 0) {
- av_log(c, AV_LOG_ERROR, "Extradata corrupt.\n");
+ av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
return NULL;
}
return encoded_config;
xiph_fail:
- av_log(c, AV_LOG_ERROR,
+ av_log(s, AV_LOG_ERROR,
"Not enough memory for configuration string\n");
return NULL;
}
-static int latm_context2profilelevel(AVCodecContext *c)
+static int latm_context2profilelevel(AVCodecParameters *par)
{
/* MP4A-LATM
* The RTP payload format specification is described in RFC 3016
/* TODO: AAC Profile only supports AAC LC Object Type.
* Different Object Types should implement different Profile Levels */
- if (c->sample_rate <= 24000) {
- if (c->channels <= 2)
+ if (par->sample_rate <= 24000) {
+ if (par->channels <= 2)
profile_level = 0x28; // AAC Profile, Level 1
- } else if (c->sample_rate <= 48000) {
- if (c->channels <= 2) {
+ } else if (par->sample_rate <= 48000) {
+ if (par->channels <= 2) {
profile_level = 0x29; // AAC Profile, Level 2
- } else if (c->channels <= 5) {
+ } else if (par->channels <= 5) {
profile_level = 0x2A; // AAC Profile, Level 4
}
- } else if (c->sample_rate <= 96000) {
- if (c->channels <= 5) {
+ } else if (par->sample_rate <= 96000) {
+ if (par->channels <= 5) {
profile_level = 0x2B; // AAC Profile, Level 5
}
}
return profile_level;
}
-static char *latm_context2config(AVCodecContext *c)
+static char *latm_context2config(AVFormatContext *s, AVCodecParameters *par)
{
/* MP4A-LATM
* The RTP payload format specification is described in RFC 3016
char *config;
for (rate_index = 0; rate_index < 16; rate_index++)
- if (avpriv_mpeg4audio_sample_rates[rate_index] == c->sample_rate)
+ if (avpriv_mpeg4audio_sample_rates[rate_index] == par->sample_rate)
break;
if (rate_index == 16) {
- av_log(c, AV_LOG_ERROR, "Unsupported sample rate\n");
+ av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
return NULL;
}
config_byte[0] = 0x40;
config_byte[1] = 0;
config_byte[2] = 0x20 | rate_index;
- config_byte[3] = c->channels << 4;
+ config_byte[3] = par->channels << 4;
config_byte[4] = 0x3f;
config_byte[5] = 0xc0;
config = av_malloc(6*2+1);
if (!config) {
- av_log(c, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
+ av_log(s, AV_LOG_ERROR, "Cannot allocate memory for the config info.\n");
return NULL;
}
ff_data_to_hex(config, config_byte, 6, 1);
return config;
}
-static char *sdp_write_media_attributes(char *buff, int size, AVCodecContext *c, int payload_type, AVFormatContext *fmt)
+static char *sdp_write_media_attributes(char *buff, int size, AVCodecParameters *p, int payload_type, AVFormatContext *fmt)
{
char *config = NULL;
- switch (c->codec_id) {
+ switch (p->codec_id) {
case AV_CODEC_ID_H264: {
int mode = 1;
if (fmt && fmt->oformat && fmt->oformat->priv_class &&
av_opt_flag_is_set(fmt->priv_data, "rtpflags", "h264_mode0"))
mode = 0;
- if (c->extradata_size) {
- config = extradata2psets(c);
+ if (p->extradata_size) {
+ config = extradata2psets(fmt, p);
}
av_strlcatf(buff, size, "a=rtpmap:%d H264/90000\r\n"
"a=fmtp:%d packetization-mode=%d%s\r\n",
payload_type, mode, config ? config : "");
break;
}
+ case AV_CODEC_ID_H261:
+ {
+ const char *pic_fmt = NULL;
+ /* only QCIF and CIF are specified as supported in RFC 4587 */
+ if (p->width == 176 && p->height == 144)
+ pic_fmt = "QCIF=1";
+ else if (p->width == 352 && p->height == 288)
+ pic_fmt = "CIF=1";
+ if (payload_type >= RTP_PT_PRIVATE)
+ av_strlcatf(buff, size, "a=rtpmap:%d H261/90000\r\n", payload_type);
+ if (pic_fmt)
+ av_strlcatf(buff, size, "a=fmtp:%d %s\r\n", payload_type, pic_fmt);
+ break;
+ }
case AV_CODEC_ID_H263:
case AV_CODEC_ID_H263P:
/* a=framesize is required by 3GPP TS 26.234 (PSS). It
* stagefright and on Samsung bada. */
if (!fmt || !fmt->oformat->priv_class ||
!av_opt_flag_is_set(fmt->priv_data, "rtpflags", "rfc2190") ||
- c->codec_id == AV_CODEC_ID_H263P)
+ p->codec_id == AV_CODEC_ID_H263P)
av_strlcatf(buff, size, "a=rtpmap:%d H263-2000/90000\r\n"
"a=framesize:%d %d-%d\r\n",
payload_type,
- payload_type, c->width, c->height);
+ payload_type, p->width, p->height);
+ break;
+ case AV_CODEC_ID_HEVC:
+ if (p->extradata_size)
+ config = extradata2psets_hevc(p);
+ av_strlcatf(buff, size, "a=rtpmap:%d H265/90000\r\n", payload_type);
+ if (config)
+ av_strlcatf(buff, size, "a=fmtp:%d %s\r\n",
+ payload_type, config);
break;
case AV_CODEC_ID_MPEG4:
- if (c->extradata_size) {
- config = extradata2config(c);
+ if (p->extradata_size) {
+ config = extradata2config(fmt, p);
}
av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
"a=fmtp:%d profile-level-id=1%s\r\n",
case AV_CODEC_ID_AAC:
if (fmt && fmt->oformat->priv_class &&
av_opt_flag_is_set(fmt->priv_data, "rtpflags", "latm")) {
- config = latm_context2config(c);
+ config = latm_context2config(fmt, p);
if (!config)
return NULL;
av_strlcatf(buff, size, "a=rtpmap:%d MP4A-LATM/%d/%d\r\n"
"a=fmtp:%d profile-level-id=%d;cpresent=0;config=%s\r\n",
- payload_type, c->sample_rate, c->channels,
- payload_type, latm_context2profilelevel(c), config);
+ payload_type, p->sample_rate, p->channels,
+ payload_type, latm_context2profilelevel(p), config);
} else {
- if (c->extradata_size) {
- config = extradata2config(c);
+ if (p->extradata_size) {
+ config = extradata2config(fmt, p);
} else {
/* FIXME: maybe we can forge config information based on the
* codec parameters...
*/
- av_log(c, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
+ av_log(fmt, AV_LOG_ERROR, "AAC with no global headers is currently not supported.\n");
return NULL;
}
- if (config == NULL) {
+ if (!config) {
return NULL;
}
av_strlcatf(buff, size, "a=rtpmap:%d MPEG4-GENERIC/%d/%d\r\n"
"a=fmtp:%d profile-level-id=1;"
"mode=AAC-hbr;sizelength=13;indexlength=3;"
"indexdeltalength=3%s\r\n",
- payload_type, c->sample_rate, c->channels,
+ payload_type, p->sample_rate, p->channels,
payload_type, config);
}
break;
if (payload_type >= RTP_PT_PRIVATE)
av_strlcatf(buff, size, "a=rtpmap:%d L16/%d/%d\r\n",
payload_type,
- c->sample_rate, c->channels);
+ p->sample_rate, p->channels);
break;
case AV_CODEC_ID_PCM_MULAW:
if (payload_type >= RTP_PT_PRIVATE)
av_strlcatf(buff, size, "a=rtpmap:%d PCMU/%d/%d\r\n",
payload_type,
- c->sample_rate, c->channels);
+ p->sample_rate, p->channels);
break;
case AV_CODEC_ID_PCM_ALAW:
if (payload_type >= RTP_PT_PRIVATE)
av_strlcatf(buff, size, "a=rtpmap:%d PCMA/%d/%d\r\n",
payload_type,
- c->sample_rate, c->channels);
+ p->sample_rate, p->channels);
break;
case AV_CODEC_ID_AMR_NB:
av_strlcatf(buff, size, "a=rtpmap:%d AMR/%d/%d\r\n"
"a=fmtp:%d octet-align=1\r\n",
- payload_type, c->sample_rate, c->channels,
+ payload_type, p->sample_rate, p->channels,
payload_type);
break;
case AV_CODEC_ID_AMR_WB:
av_strlcatf(buff, size, "a=rtpmap:%d AMR-WB/%d/%d\r\n"
"a=fmtp:%d octet-align=1\r\n",
- payload_type, c->sample_rate, c->channels,
+ payload_type, p->sample_rate, p->channels,
payload_type);
break;
case AV_CODEC_ID_VORBIS:
- if (c->extradata_size)
- config = xiph_extradata2config(c);
+ if (p->extradata_size)
+ config = xiph_extradata2config(fmt, p);
else
- av_log(c, AV_LOG_ERROR, "Vorbis configuration info missing\n");
+ av_log(fmt, AV_LOG_ERROR, "Vorbis configuration info missing\n");
if (!config)
return NULL;
av_strlcatf(buff, size, "a=rtpmap:%d vorbis/%d/%d\r\n"
"a=fmtp:%d configuration=%s\r\n",
- payload_type, c->sample_rate, c->channels,
+ payload_type, p->sample_rate, p->channels,
payload_type, config);
break;
case AV_CODEC_ID_THEORA: {
const char *pix_fmt;
- switch (c->pix_fmt) {
+ switch (p->format) {
case AV_PIX_FMT_YUV420P:
pix_fmt = "YCbCr-4:2:0";
break;
pix_fmt = "YCbCr-4:4:4";
break;
default:
- av_log(c, AV_LOG_ERROR, "Unsupported pixel format.\n");
+ av_log(fmt, AV_LOG_ERROR, "Unsupported pixel format.\n");
return NULL;
}
- if (c->extradata_size)
- config = xiph_extradata2config(c);
+ if (p->extradata_size)
+ config = xiph_extradata2config(fmt, p);
else
- av_log(c, AV_LOG_ERROR, "Theora configuation info missing\n");
+ av_log(fmt, AV_LOG_ERROR, "Theora configuation info missing\n");
if (!config)
return NULL;
"width=%d; height=%d; sampling=%s; "
"configuration=%s\r\n",
payload_type, payload_type,
- c->width, c->height, pix_fmt, config);
+ p->width, p->height, pix_fmt, config);
break;
}
case AV_CODEC_ID_VP8:
if (payload_type >= RTP_PT_PRIVATE)
av_strlcatf(buff, size, "a=rtpmap:%d G722/%d/%d\r\n",
payload_type,
- 8000, c->channels);
+ 8000, p->channels);
break;
case AV_CODEC_ID_ADPCM_G726: {
if (payload_type >= RTP_PT_PRIVATE)
av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
payload_type,
- c->bits_per_coded_sample*8,
- c->sample_rate);
+ p->bits_per_coded_sample*8,
+ p->sample_rate);
break;
}
case AV_CODEC_ID_ILBC:
av_strlcatf(buff, size, "a=rtpmap:%d iLBC/%d\r\n"
"a=fmtp:%d mode=%d\r\n",
- payload_type, c->sample_rate,
- payload_type, c->block_align == 38 ? 20 : 30);
+ payload_type, p->sample_rate,
+ payload_type, p->block_align == 38 ? 20 : 30);
break;
case AV_CODEC_ID_SPEEX:
av_strlcatf(buff, size, "a=rtpmap:%d speex/%d\r\n",
- payload_type, c->sample_rate);
+ payload_type, p->sample_rate);
break;
case AV_CODEC_ID_OPUS:
- av_strlcatf(buff, size, "a=rtpmap:%d opus/48000\r\n",
+ /* The opus RTP draft says that all opus streams MUST be declared
+ as stereo, to avoid negotiation failures. The actual number of
+ channels can change on a packet-by-packet basis. The number of
+ channels a receiver prefers to receive or a sender plans to send
+ can be declared via fmtp parameters (both default to mono), but
+ receivers MUST be able to receive and process stereo packets. */
+ av_strlcatf(buff, size, "a=rtpmap:%d opus/48000/2\r\n",
payload_type);
+ if (p->channels == 2) {
+ av_strlcatf(buff, size, "a=fmtp:%d sprop-stereo=1\r\n",
+ payload_type);
+ }
break;
default:
/* Nothing special to do here... */
const char *dest_addr, const char *dest_type,
int port, int ttl, AVFormatContext *fmt)
{
- AVCodecContext *c = st->codec;
+ AVCodecParameters *p = st->codecpar;
const char *type;
int payload_type;
- payload_type = ff_rtp_get_payload_type(fmt, c, idx);
+ payload_type = ff_rtp_get_payload_type(fmt, st->codecpar, idx);
- switch (c->codec_type) {
+ switch (p->codec_type) {
case AVMEDIA_TYPE_VIDEO : type = "video" ; break;
case AVMEDIA_TYPE_AUDIO : type = "audio" ; break;
case AVMEDIA_TYPE_SUBTITLE: type = "text" ; break;
av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
sdp_write_address(buff, size, dest_addr, dest_type, ttl);
- if (c->bit_rate) {
- av_strlcatf(buff, size, "b=AS:%d\r\n", c->bit_rate / 1000);
+ if (p->bit_rate) {
+ av_strlcatf(buff, size, "b=AS:%d\r\n", p->bit_rate / 1000);
}
- sdp_write_media_attributes(buff, size, c, payload_type, fmt);
+ sdp_write_media_attributes(buff, size, p, payload_type, fmt);
}
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
projects / ffmpeg / blobdiff