static int ffat_decode(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
ATDecodeContext *at = avctx->priv_data;
AVFrame *frame = data;
int pkt_size = avpkt->size;
AVPacket filtered_packet = {0};
OSStatus ret;
AudioBufferList out_buffers;
if (avctx->codec_id == AV_CODEC_ID_AAC && avpkt->size > 2 &&
(AV_RB16(avpkt->data) & 0xfff0) == 0xfff0) {
AVPacket filter_pkt = {0};
if (!at->bsf) {
const AVBitStreamFilter *bsf = av_bsf_get_by_name("aac_adtstoasc");
if(!bsf)
return AVERROR_BSF_NOT_FOUND;
if ((ret = av_bsf_alloc(bsf, &at->bsf)))
return ret;
if (((ret = avcodec_parameters_from_context(at->bsf->par_in, avctx)) < 0) ||
((ret = av_bsf_init(at->bsf)) < 0)) {
av_bsf_free(&at->bsf);
return ret;
}
}
if ((ret = av_packet_ref(&filter_pkt, avpkt)) < 0)
return ret;
if ((ret = av_bsf_send_packet(at->bsf, &filter_pkt)) < 0) {
av_packet_unref(&filter_pkt);
return ret;
}
if ((ret = av_bsf_receive_packet(at->bsf, &filtered_packet)) < 0)
return ret;
at->extradata = at->bsf->par_out->extradata;
at->extradata_size = at->bsf->par_out->extradata_size;
avpkt = &filtered_packet;
}
if (!at->converter) {
if ((ret = ffat_create_decoder(avctx, avpkt)) < 0) {
av_packet_unref(&filtered_packet);
return ret;
}
}
out_buffers = (AudioBufferList){
.mNumberBuffers = 1,
.mBuffers = {
{
.mNumberChannels = avctx->channels,
.mDataByteSize = av_get_bytes_per_sample(avctx->sample_fmt) * avctx->frame_size
* avctx->channels,
}
}
};
int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options)
{
int ret;
const AVBitStreamFilter *filter;
AVBSFContext *bsf;
filter = av_bsf_get_by_name(bsf_name);
if (!filter)
return AVERROR_BSF_NOT_FOUND;
ret = av_bsf_alloc(filter, &bsf);
if (ret < 0)
return ret;
if (options) {
ret = av_opt_set_dict2(bsf, options, AV_OPT_SEARCH_CHILDREN);
if (ret < 0)
goto end;
}
ret = av_bsf_list_append(lst, bsf);
end:
if (ret < 0)
av_bsf_free(&bsf);
return ret;
}
AVBitStreamFilterContext *av_bitstream_filter_init(const char *name)
{
AVBitStreamFilterContext *ctx = NULL;
BSFCompatContext *priv = NULL;
const AVBitStreamFilter *bsf;
bsf = av_bsf_get_by_name(name);
if (!bsf)
return NULL;
ctx = av_mallocz(sizeof(*ctx));
if (!ctx)
return NULL;
priv = av_mallocz(sizeof(*priv));
if (!priv)
goto fail;
ctx->filter = bsf;
ctx->priv_data = priv;
return ctx;
fail:
if (priv)
av_bsf_free(&priv->ctx);
av_freep(&priv);
av_freep(&ctx);
return NULL;
}
bool FFmpegEncoderOpen(struct FFmpegEncoder* encoder, const char* outfile) {
AVCodec* acodec = avcodec_find_encoder_by_name(encoder->audioCodec);
AVCodec* vcodec = avcodec_find_encoder_by_name(encoder->videoCodec);
if ((encoder->audioCodec && !acodec) || !vcodec || !FFmpegEncoderVerifyContainer(encoder)) {
return false;
}
encoder->currentAudioSample = 0;
encoder->currentAudioFrame = 0;
encoder->currentVideoFrame = 0;
encoder->nextAudioPts = 0;
AVOutputFormat* oformat = av_guess_format(encoder->containerFormat, 0, 0);
#ifndef USE_LIBAV
avformat_alloc_output_context2(&encoder->context, oformat, 0, outfile);
#else
encoder->context = avformat_alloc_context();
strncpy(encoder->context->filename, outfile, sizeof(encoder->context->filename) - 1);
encoder->context->filename[sizeof(encoder->context->filename) - 1] = '\0';
encoder->context->oformat = oformat;
#endif
if (acodec) {
#ifdef FFMPEG_USE_CODECPAR
encoder->audioStream = avformat_new_stream(encoder->context, NULL);
encoder->audio = avcodec_alloc_context3(acodec);
#else
encoder->audioStream = avformat_new_stream(encoder->context, acodec);
encoder->audio = encoder->audioStream->codec;
#endif
encoder->audio->bit_rate = encoder->audioBitrate;
encoder->audio->channels = 2;
encoder->audio->channel_layout = AV_CH_LAYOUT_STEREO;
encoder->audio->sample_rate = encoder->sampleRate;
encoder->audio->sample_fmt = encoder->sampleFormat;
AVDictionary* opts = 0;
av_dict_set(&opts, "strict", "-2", 0);
if (encoder->context->oformat->flags & AVFMT_GLOBALHEADER) {
#ifdef AV_CODEC_FLAG_GLOBAL_HEADER
encoder->audio->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
#else
encoder->audio->flags |= CODEC_FLAG_GLOBAL_HEADER;
#endif
}
avcodec_open2(encoder->audio, acodec, &opts);
av_dict_free(&opts);
#if LIBAVCODEC_VERSION_MAJOR >= 55
encoder->audioFrame = av_frame_alloc();
#else
encoder->audioFrame = avcodec_alloc_frame();
#endif
if (!encoder->audio->frame_size) {
encoder->audio->frame_size = 1;
}
encoder->audioFrame->nb_samples = encoder->audio->frame_size;
encoder->audioFrame->format = encoder->audio->sample_fmt;
encoder->audioFrame->pts = 0;
#ifdef USE_LIBAVRESAMPLE
encoder->resampleContext = avresample_alloc_context();
av_opt_set_int(encoder->resampleContext, "in_channel_layout", AV_CH_LAYOUT_STEREO, 0);
av_opt_set_int(encoder->resampleContext, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
av_opt_set_int(encoder->resampleContext, "in_sample_rate", PREFERRED_SAMPLE_RATE, 0);
av_opt_set_int(encoder->resampleContext, "out_sample_rate", encoder->sampleRate, 0);
av_opt_set_int(encoder->resampleContext, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
av_opt_set_int(encoder->resampleContext, "out_sample_fmt", encoder->sampleFormat, 0);
avresample_open(encoder->resampleContext);
#else
encoder->resampleContext = swr_alloc_set_opts(NULL, AV_CH_LAYOUT_STEREO, encoder->sampleFormat, encoder->sampleRate,
AV_CH_LAYOUT_STEREO, AV_SAMPLE_FMT_S16, PREFERRED_SAMPLE_RATE, 0, NULL);
swr_init(encoder->resampleContext);
#endif
encoder->audioBufferSize = (encoder->audioFrame->nb_samples * PREFERRED_SAMPLE_RATE / encoder->sampleRate) * 4;
encoder->audioBuffer = av_malloc(encoder->audioBufferSize);
encoder->postaudioBufferSize = av_samples_get_buffer_size(0, encoder->audio->channels, encoder->audio->frame_size, encoder->audio->sample_fmt, 0);
encoder->postaudioBuffer = av_malloc(encoder->postaudioBufferSize);
avcodec_fill_audio_frame(encoder->audioFrame, encoder->audio->channels, encoder->audio->sample_fmt, (const uint8_t*) encoder->postaudioBuffer, encoder->postaudioBufferSize, 0);
if (encoder->audio->codec->id == AV_CODEC_ID_AAC &&
(strcasecmp(encoder->containerFormat, "mp4") ||
strcasecmp(encoder->containerFormat, "m4v") ||
strcasecmp(encoder->containerFormat, "mov"))) {
// MP4 container doesn't support the raw ADTS AAC format that the encoder spits out
#ifdef FFMPEG_USE_NEW_BSF
av_bsf_alloc(av_bsf_get_by_name("aac_adtstoasc"), &encoder->absf);
avcodec_parameters_from_context(encoder->absf->par_in, encoder->audio);
av_bsf_init(encoder->absf);
#else
encoder->absf = av_bitstream_filter_init("aac_adtstoasc");
#endif
}
#ifdef FFMPEG_USE_CODECPAR
avcodec_parameters_from_context(encoder->audioStream->codecpar, encoder->audio);
#endif
}
#ifdef FFMPEG_USE_CODECPAR
encoder->videoStream = avformat_new_stream(encoder->context, NULL);
encoder->video = avcodec_alloc_context3(vcodec);
#else
encoder->videoStream = avformat_new_stream(encoder->context, vcodec);
encoder->video = encoder->videoStream->codec;
#endif
encoder->video->bit_rate = encoder->videoBitrate;
encoder->video->width = encoder->width;
encoder->video->height = encoder->height;
encoder->video->time_base = (AVRational) { VIDEO_TOTAL_LENGTH, GBA_ARM7TDMI_FREQUENCY };
encoder->video->pix_fmt = encoder->pixFormat;
encoder->video->gop_size = 60;
encoder->video->max_b_frames = 3;
if (encoder->context->oformat->flags & AVFMT_GLOBALHEADER) {
#ifdef AV_CODEC_FLAG_GLOBAL_HEADER
encoder->video->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
#else
encoder->video->flags |= CODEC_FLAG_GLOBAL_HEADER;
#endif
}
if (encoder->video->codec->id == AV_CODEC_ID_H264 &&
(strcasecmp(encoder->containerFormat, "mp4") ||
strcasecmp(encoder->containerFormat, "m4v") ||
strcasecmp(encoder->containerFormat, "mov"))) {
// QuickTime and a few other things require YUV420
encoder->video->pix_fmt = AV_PIX_FMT_YUV420P;
}
if (strcmp(vcodec->name, "libx264") == 0) {
// Try to adaptively figure out when you can use a slower encoder
if (encoder->width * encoder->height > 1000000) {
av_opt_set(encoder->video->priv_data, "preset", "superfast", 0);
} else if (encoder->width * encoder->height > 500000) {
av_opt_set(encoder->video->priv_data, "preset", "veryfast", 0);
} else {
av_opt_set(encoder->video->priv_data, "preset", "faster", 0);
}
if (encoder->videoBitrate == 0) {
av_opt_set(encoder->video->priv_data, "crf", "0", 0);
encoder->video->pix_fmt = AV_PIX_FMT_YUV444P;
}
}
avcodec_open2(encoder->video, vcodec, 0);
#if LIBAVCODEC_VERSION_MAJOR >= 55
encoder->videoFrame = av_frame_alloc();
#else
encoder->videoFrame = avcodec_alloc_frame();
#endif
encoder->videoFrame->format = encoder->video->pix_fmt;
encoder->videoFrame->width = encoder->video->width;
encoder->videoFrame->height = encoder->video->height;
encoder->videoFrame->pts = 0;
_ffmpegSetVideoDimensions(&encoder->d, encoder->iwidth, encoder->iheight);
av_image_alloc(encoder->videoFrame->data, encoder->videoFrame->linesize, encoder->video->width, encoder->video->height, encoder->video->pix_fmt, 32);
#ifdef FFMPEG_USE_CODECPAR
avcodec_parameters_from_context(encoder->videoStream->codecpar, encoder->video);
#endif
if (avio_open(&encoder->context->pb, outfile, AVIO_FLAG_WRITE) < 0) {
return false;
}
return avformat_write_header(encoder->context, 0) >= 0;
}
static int bsfs_init(AVCodecContext *avctx)
{
AVCodecInternal *avci = avctx->internal;
DecodeFilterContext *s = &avci->filter;
const char *bsfs_str;
int ret;
if (s->nb_bsfs)
return 0;
bsfs_str = avctx->codec->bsfs ? avctx->codec->bsfs : "null";
while (bsfs_str && *bsfs_str) {
AVBSFContext **tmp;
const AVBitStreamFilter *filter;
char *bsf;
bsf = av_get_token(&bsfs_str, ",");
if (!bsf) {
ret = AVERROR(ENOMEM);
goto fail;
}
filter = av_bsf_get_by_name(bsf);
if (!filter) {
av_log(avctx, AV_LOG_ERROR, "A non-existing bitstream filter %s "
"requested by a decoder. This is a bug, please report it.\n",
bsf);
ret = AVERROR_BUG;
av_freep(&bsf);
goto fail;
}
av_freep(&bsf);
tmp = av_realloc_array(s->bsfs, s->nb_bsfs + 1, sizeof(*s->bsfs));
if (!tmp) {
ret = AVERROR(ENOMEM);
goto fail;
}
s->bsfs = tmp;
s->nb_bsfs++;
ret = av_bsf_alloc(filter, &s->bsfs[s->nb_bsfs - 1]);
if (ret < 0)
goto fail;
if (s->nb_bsfs == 1) {
/* We do not currently have an API for passing the input timebase into decoders,
* but no filters used here should actually need it.
* So we make up some plausible-looking number (the MPEG 90kHz timebase) */
s->bsfs[s->nb_bsfs - 1]->time_base_in = (AVRational){ 1, 90000 };
ret = avcodec_parameters_from_context(s->bsfs[s->nb_bsfs - 1]->par_in,
avctx);
} else {
s->bsfs[s->nb_bsfs - 1]->time_base_in = s->bsfs[s->nb_bsfs - 2]->time_base_out;
ret = avcodec_parameters_copy(s->bsfs[s->nb_bsfs - 1]->par_in,
s->bsfs[s->nb_bsfs - 2]->par_out);
}
if (ret < 0)
goto fail;
ret = av_bsf_init(s->bsfs[s->nb_bsfs - 1]);
if (ret < 0)
goto fail;
}
return 0;
fail:
ff_decode_bsfs_uninit(avctx);
return ret;
}
STATUS DemuxerLibAV::selectVideoStream() {
if (!_initialized) {
log->printf("DemuxerLibAV::selectVideoStream(): demuxer not opened!\n");
return S_FAIL;
}
for (U32 i = 0; i < _afc->nb_streams; i++) {
AVStream *stream = _afc->streams[i];
AVCodec *codec = avcodec_find_decoder(stream->codecpar->codec_id);
if (codec == NULL) {
log->printf("DemuxerLibAV::selectVideoStream(): avcodec_find_decoder failed!\n");
return S_FAIL;
}
AVCodecContext *cc = avcodec_alloc_context3(codec);
if (cc == NULL) {
log->printf("DemuxerLibAV::selectVideoStream(): avcodec_alloc_context3 failed!\n");
return S_FAIL;
}
if (avcodec_parameters_to_context(cc, stream->codecpar) < 0) {
log->printf("DemuxerLibAV::selectVideoStream(): avcodec_parameters_to_context failed!\n");
avcodec_free_context(&cc);
return S_FAIL;
}
if (cc->codec_type == AVMEDIA_TYPE_VIDEO) {
_videoStream = stream;
if (cc->codec_id == AV_CODEC_ID_H264) {
if (cc->extradata && cc->extradata_size >= 8 && cc->extradata[0] == 1) {
const AVBitStreamFilter *bsf = av_bsf_get_by_name("h264_mp4toannexb");
if (bsf == nullptr) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_get_by_name failed!\n");
avcodec_free_context(&cc);
return S_FAIL;
}
if (av_bsf_alloc(bsf, &_bsf) < 0) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_alloc failed!\n");
avcodec_free_context(&cc);
return S_FAIL;
}
if (avcodec_parameters_from_context(_bsf->par_in, cc) < 0)
{
log->printf("DemuxerLibAV::selectVideoStream(): avcodec_parameters_from_context failed!\n");
av_bsf_free(&_bsf);
avcodec_free_context(&cc);
return S_FAIL;
}
_bsf->time_base_in = cc->time_base;
if (av_bsf_init(_bsf) < 0) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_init failed!\n");
av_bsf_free(&_bsf);
avcodec_free_context(&cc);
return S_FAIL;
}
}
} else if (cc->codec_id == AV_CODEC_ID_MPEG4) {
const AVBitStreamFilter *bsf = av_bsf_get_by_name("mpeg4_unpack_bframes");
if (bsf == nullptr) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_get_by_name failed!\n");
avcodec_free_context(&cc);
return S_FAIL;
}
if (av_bsf_alloc(bsf, &_bsf) < 0) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_alloc failed!\n");
avcodec_free_context(&cc);
return S_FAIL;
}
if (avcodec_parameters_from_context(_bsf->par_in, cc) < 0)
{
log->printf("DemuxerLibAV::selectVideoStream(): avcodec_parameters_from_context failed!\n");
av_bsf_free(&_bsf);
avcodec_free_context(&cc);
return S_FAIL;
}
_bsf->time_base_in = cc->time_base;
if (av_bsf_init(_bsf) < 0) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_init failed!\n");
av_bsf_free(&_bsf);
avcodec_free_context(&cc);
return S_FAIL;
}
} else if (cc->codec_id == AV_CODEC_ID_HEVC) {
if (cc->extradata && cc->extradata_size >= 8 && cc->extradata[0] == 1) {
const AVBitStreamFilter *bsf = av_bsf_get_by_name("hevc_mp4toannexb");
if (bsf == nullptr) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bitstream_filter_init failed!\n");
avcodec_free_context(&cc);
return S_FAIL;
}
if (av_bsf_alloc(bsf, &_bsf) < 0) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_alloc failed!\n");
avcodec_free_context(&cc);
return S_FAIL;
}
if (avcodec_parameters_from_context(_bsf->par_in, cc) < 0)
{
log->printf("DemuxerLibAV::selectVideoStream(): avcodec_parameters_from_context failed!\n");
av_bsf_free(&_bsf);
avcodec_free_context(&cc);
return S_FAIL;
}
_bsf->time_base_in = cc->time_base;
if (av_bsf_init(_bsf) < 0) {
log->printf("DemuxerLibAV::selectVideoStream(): av_bsf_init failed!\n");
av_bsf_free(&_bsf);
avcodec_free_context(&cc);
return S_FAIL;
}
}
}
_videoStreamInfo.width = (U32)cc->width;
_videoStreamInfo.height = (U32)cc->height;
_videoStreamInfo.timeBaseScale = (U32)cc->time_base.num;
_videoStreamInfo.timeBaseRate = (U32)cc->time_base.den;
_videoStreamInfo.priv = cc;
switch (cc->codec_id) {
case AV_CODEC_ID_MPEG1VIDEO:
_videoStreamInfo.codecId = CODEC_ID_MPEG1VIDEO;
break;
case AV_CODEC_ID_MPEG2VIDEO:
_videoStreamInfo.codecId = CODEC_ID_MPEG2VIDEO;
break;
case AV_CODEC_ID_H261:
_videoStreamInfo.codecId = CODEC_ID_H261;
break;
case AV_CODEC_ID_H263:
_videoStreamInfo.codecId = CODEC_ID_H263;
break;
case AV_CODEC_ID_MPEG4:
_videoStreamInfo.codecId = CODEC_ID_MPEG4;
break;
case AV_CODEC_ID_MSMPEG4V1:
_videoStreamInfo.codecId = CODEC_ID_MSMPEG4V1;
break;
case AV_CODEC_ID_MSMPEG4V2:
_videoStreamInfo.codecId = CODEC_ID_MSMPEG4V2;
break;
case AV_CODEC_ID_MSMPEG4V3:
_videoStreamInfo.codecId = CODEC_ID_MSMPEG4V3;
break;
case AV_CODEC_ID_H263P:
_videoStreamInfo.codecId = CODEC_ID_H263P;
break;
case AV_CODEC_ID_H263I:
_videoStreamInfo.codecId = CODEC_ID_H263I;
break;
case AV_CODEC_ID_FLV1:
_videoStreamInfo.codecId = CODEC_ID_FLV1;
break;
case AV_CODEC_ID_SVQ1:
_videoStreamInfo.codecId = CODEC_ID_SVQ1;
break;
case AV_CODEC_ID_SVQ3:
_videoStreamInfo.codecId = CODEC_ID_SVQ3;
break;
case AV_CODEC_ID_AIC:
_videoStreamInfo.codecId = CODEC_ID_AIC;
break;
case AV_CODEC_ID_DVVIDEO:
_videoStreamInfo.codecId = CODEC_ID_DVVIDEO;
break;
case AV_CODEC_ID_VP3:
_videoStreamInfo.codecId = CODEC_ID_VP3;
break;
case AV_CODEC_ID_VP5:
_videoStreamInfo.codecId = CODEC_ID_VP5;
break;
case AV_CODEC_ID_VP6:
_videoStreamInfo.codecId = CODEC_ID_VP6;
break;
case AV_CODEC_ID_VP6A:
_videoStreamInfo.codecId = CODEC_ID_VP6A;
break;
case AV_CODEC_ID_VP6F:
_videoStreamInfo.codecId = CODEC_ID_VP6F;
break;
case AV_CODEC_ID_VP7:
_videoStreamInfo.codecId = CODEC_ID_VP7;
break;
case AV_CODEC_ID_VP8:
_videoStreamInfo.codecId = CODEC_ID_VP8;
break;
case AV_CODEC_ID_VP9:
_videoStreamInfo.codecId = CODEC_ID_VP9;
break;
case AV_CODEC_ID_WEBP:
_videoStreamInfo.codecId = CODEC_ID_WEBP;
break;
case AV_CODEC_ID_THEORA:
_videoStreamInfo.codecId = CODEC_ID_THEORA;
break;
case AV_CODEC_ID_RV10:
_videoStreamInfo.codecId = CODEC_ID_RV10;
break;
case AV_CODEC_ID_RV20:
_videoStreamInfo.codecId = CODEC_ID_RV20;
break;
case AV_CODEC_ID_RV30:
_videoStreamInfo.codecId = CODEC_ID_RV30;
break;
case AV_CODEC_ID_RV40:
_videoStreamInfo.codecId = CODEC_ID_RV40;
break;
case AV_CODEC_ID_WMV1:
_videoStreamInfo.codecId = CODEC_ID_WMV1;
break;
case AV_CODEC_ID_WMV2:
_videoStreamInfo.codecId = CODEC_ID_WMV2;
break;
case AV_CODEC_ID_WMV3:
_videoStreamInfo.codecId = CODEC_ID_WMV3;
break;
case AV_CODEC_ID_VC1:
_videoStreamInfo.codecId = CODEC_ID_VC1;
break;
case AV_CODEC_ID_H264:
_videoStreamInfo.codecId = CODEC_ID_H264;
break;
case AV_CODEC_ID_HEVC:
_videoStreamInfo.codecId = CODEC_ID_HEVC;
break;
default:
_videoStreamInfo.codecId = CODEC_ID_NONE;
log->printf("DemuxerLibAV::selectVideoStream(): Unknown codec: 0x%08x!\n",
cc->codec_id);
avcodec_free_context(&cc);
return S_FAIL;
}
switch (cc->pix_fmt) {
case AV_PIX_FMT_RGB24:
_videoStreamInfo.pixelfmt = FMT_RGB24;
break;
case AV_PIX_FMT_ARGB:
_videoStreamInfo.pixelfmt = FMT_ARGB;
break;
case AV_PIX_FMT_YUV420P:
_videoStreamInfo.pixelfmt = FMT_YUV420P;
break;
case AV_PIX_FMT_YUV422P:
_videoStreamInfo.pixelfmt = FMT_YUV422P;
break;
case AV_PIX_FMT_YUV444P:
_videoStreamInfo.pixelfmt = FMT_YUV444P;
break;
case AV_PIX_FMT_NV12:
_videoStreamInfo.pixelfmt = FMT_NV12;
break;
default:
_videoStreamInfo.pixelfmt = FMT_NONE;
log->printf("DemuxerLibAV::selectVideoStream(): Unknown pixel format: 0x%08x!\n", cc->pix_fmt);
avcodec_free_context(&cc);
return S_FAIL;
}
return S_OK;
}
}
return S_FAIL;
}
static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
{
int ret;
FFAMediaFormat *format = NULL;
MediaCodecH264DecContext *s = avctx->priv_data;
format = ff_AMediaFormat_new();
if (!format) {
av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
ret = AVERROR_EXTERNAL;
goto done;
}
ff_AMediaFormat_setString(format, "mime", CODEC_MIME);
ff_AMediaFormat_setInt32(format, "width", avctx->width);
ff_AMediaFormat_setInt32(format, "height", avctx->height);
if (avctx->extradata[0] == 1) {
uint8_t *extradata = NULL;
int extradata_size = 0;
int sps_offset, sps_size;
int pps_offset, pps_size;
if ((ret = h264_extradata_to_annexb_sps_pps(avctx, &extradata, &extradata_size,
&sps_offset, &sps_size, &pps_offset, &pps_size)) < 0) {
goto done;
}
ff_AMediaFormat_setBuffer(format, "csd-0", extradata + sps_offset, sps_size);
ff_AMediaFormat_setBuffer(format, "csd-1", extradata + pps_offset, pps_size);
av_freep(&extradata);
} else {
ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata, avctx->extradata_size);
}
if ((ret = ff_mediacodec_dec_init(avctx, &s->ctx, CODEC_MIME, format)) < 0) {
goto done;
}
av_log(avctx, AV_LOG_INFO, "MediaCodec started successfully, ret = %d\n", ret);
s->fifo = av_fifo_alloc(sizeof(AVPacket));
if (!s->fifo) {
ret = AVERROR(ENOMEM);
goto done;
}
const AVBitStreamFilter *bsf = av_bsf_get_by_name("h264_mp4toannexb");
if(!bsf) {
ret = AVERROR_BSF_NOT_FOUND;
goto done;
}
if ((ret = av_bsf_alloc(bsf, &s->bsf))) {
goto done;
}
if (((ret = avcodec_parameters_from_context(s->bsf->par_in, avctx)) < 0) ||
((ret = av_bsf_init(s->bsf)) < 0)) {
goto done;
}
av_init_packet(&s->filtered_pkt);
done:
if (format) {
ff_AMediaFormat_delete(format);
}
if (ret < 0) {
mediacodec_decode_close(avctx);
}
return ret;
}
