int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
{
AVBSFContext *ctx;
int ret;
ctx = av_mallocz(sizeof(*ctx));
if (!ctx)
return AVERROR(ENOMEM);
ctx->av_class = &bsf_class;
ctx->filter = filter;
ctx->par_in = avcodec_parameters_alloc();
ctx->par_out = avcodec_parameters_alloc();
if (!ctx->par_in || !ctx->par_out) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->internal = av_mallocz(sizeof(*ctx->internal));
if (!ctx->internal) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->internal->buffer_pkt = av_packet_alloc();
if (!ctx->internal->buffer_pkt) {
ret = AVERROR(ENOMEM);
goto fail;
}
av_opt_set_defaults(ctx);
/* allocate priv data and init private options */
if (filter->priv_data_size) {
ctx->priv_data = av_mallocz(filter->priv_data_size);
if (!ctx->priv_data) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (filter->priv_class) {
*(const AVClass **)ctx->priv_data = filter->priv_class;
av_opt_set_defaults(ctx->priv_data);
}
}
*pctx = ctx;
return 0;
fail:
av_bsf_free(&ctx);
return ret;
}
AVCodecParameters *mp_codec_params_to_av(struct mp_codec_params *c)
{
AVCodecParameters *avp = avcodec_parameters_alloc();
if (!avp)
return NULL;
// If we have lavf demuxer params, they overwrite by definition any others.
if (c->lav_codecpar) {
if (avcodec_parameters_copy(avp, c->lav_codecpar) < 0)
goto error;
return avp;
}
avp->codec_type = mp_to_av_stream_type(c->type);
avp->codec_id = mp_codec_to_av_codec_id(c->codec);
avp->codec_tag = c->codec_tag;
if (c->extradata_size) {
avp->extradata =
av_mallocz(c->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!avp->extradata)
goto error;
avp->extradata_size = c->extradata_size;
memcpy(avp->extradata, c->extradata, avp->extradata_size);
}
avp->bits_per_coded_sample = c->bits_per_coded_sample;
// Video only
avp->width = c->disp_w;
avp->height = c->disp_h;
// Audio only
avp->sample_rate = c->samplerate;
avp->bit_rate = c->bitrate;
avp->block_align = c->block_align;
avp->channels = c->channels.num;
if (!mp_chmap_is_unknown(&c->channels))
avp->channel_layout = mp_chmap_to_lavc(&c->channels);
return avp;
error:
avcodec_parameters_free(&avp);
return NULL;
}
int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
{
MOVMuxContext *mov = s->priv_data;
MOVTrack *track = &mov->tracks[index];
MOVTrack *src_track = &mov->tracks[src_index];
AVStream *src_st = s->streams[src_index];
int ret = AVERROR(ENOMEM);
track->tag = MKTAG('r','t','p',' ');
track->src_track = src_index;
track->par = avcodec_parameters_alloc();
if (!track->par)
goto fail;
track->par->codec_type = AVMEDIA_TYPE_DATA;
track->par->codec_tag = track->tag;
ret = ff_rtp_chain_mux_open(&track->rtp_ctx, s, src_st, NULL,
RTP_MAX_PACKET_SIZE, src_index);
if (ret < 0)
goto fail;
/* Copy the RTP AVStream timebase back to the hint AVStream */
track->timescale = track->rtp_ctx->streams[0]->time_base.den;
/* Mark the hinted track that packets written to it should be
* sent to this track for hinting. */
src_track->hint_track = index;
return 0;
fail:
av_log(s, AV_LOG_WARNING,
"Unable to initialize hinting of stream %d\n", src_index);
avcodec_parameters_free(&track->par);
/* Set a default timescale, to avoid crashes in av_dump_format */
track->timescale = 90000;
return ret;
}
MediaPacket::MediaPacket(IN FeedFrame & feedFrame) {
AVCodecParameters *param = avcodec_parameters_alloc();
shouldFreeAvCodecParameters = true;
enum AVCodecID codecId;
switch(feedFrame.type_) {
case ReceiverType::H264 :
stream_ = AVMEDIA_TYPE_VIDEO;
codecId = AV_CODEC_ID_H264;
break;
case ReceiverType::H265 :
stream_ = AVMEDIA_TYPE_VIDEO;
codecId = AV_CODEC_ID_HEVC;
break;
case ReceiverType::G711A :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_PCM_ALAW;
break;
case ReceiverType::G711U :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_PCM_MULAW;
break;
case ReceiverType::PCMS16E :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_PCM_S16LE;
break;
case ReceiverType::AACNoAdts :
case ReceiverType::AACAdts :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_AAC;
break;
default:
codecId = AV_CODEC_ID_NONE;
}
SetCodec(codecId);
switch(feedFrame.type_) {
case ReceiverType::G711A :
case ReceiverType::PCMS16E :
case ReceiverType::G711U :
param->channels = 1;
param->channel_layout = AV_CH_LAYOUT_MONO;
param->sample_rate = 8000;
param->codec_id = codecId;
param->codec_type = AVMEDIA_TYPE_AUDIO;
param->format = AV_SAMPLE_FMT_S16;
param->bits_per_coded_sample = 8;
param->bits_per_raw_sample = 16;
if (ReceiverType::PCMS16E == feedFrame.type_)
param->bits_per_coded_sample = 16;
break;
default:
codecId = AV_CODEC_ID_NONE;
}
pAvCodecPar_ = param;
AVPacket* pAvPacket = av_packet_alloc();
av_init_packet(pAvPacket);
pAvPacket->data = reinterpret_cast<uint8_t *>(feedFrame.data_.data());
pAvPacket->size = feedFrame.data_.size();
pAvPacket->pts = feedFrame.nPts_;
pAvPacket->dts = feedFrame.nDts_;
pAvPacket_ = const_cast<AVPacket*>(pAvPacket);
}
