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;
}
static int close_slave(TeeSlave *tee_slave)
{
AVFormatContext *avf;
unsigned i;
int ret = 0;
avf = tee_slave->avf;
if (!avf)
return 0;
if (tee_slave->header_written)
ret = av_write_trailer(avf);
if (tee_slave->bsfs) {
for (i = 0; i < avf->nb_streams; ++i)
av_bsf_free(&tee_slave->bsfs[i]);
}
av_freep(&tee_slave->stream_map);
av_freep(&tee_slave->bsfs);
ff_format_io_close(avf, &avf->pb);
avformat_free_context(avf);
tee_slave->avf = NULL;
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;
}
static void bsf_list_close(AVBSFContext *bsf)
{
BSFListContext *lst = bsf->priv_data;
int i;
for (i = 0; i < lst->nb_bsfs; ++i)
av_bsf_free(&lst->bsfs[i]);
av_freep(&lst->bsfs);
av_freep(&lst->item_name);
}
void ff_decode_bsfs_uninit(AVCodecContext *avctx)
{
DecodeFilterContext *s = &avctx->internal->filter;
int i;
for (i = 0; i < s->nb_bsfs; i++)
av_bsf_free(&s->bsfs[i]);
av_freep(&s->bsfs);
s->nb_bsfs = 0;
}
void av_bsf_list_free(AVBSFList **lst)
{
int i;
if (*lst)
return;
for (i = 0; i < (*lst)->nb_bsfs; ++i)
av_bsf_free(&(*lst)->bsfs[i]);
av_free((*lst)->bsfs);
av_freep(lst);
}
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;
}
static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
{
MediaCodecH264DecContext *s = avctx->priv_data;
ff_mediacodec_dec_close(avctx, &s->ctx);
av_fifo_free(s->fifo);
av_bsf_free(&s->bsf);
av_packet_unref(&s->filtered_pkt);
return 0;
}
void av_bitstream_filter_close(AVBitStreamFilterContext *bsfc)
{
BSFCompatContext *priv;
if (!bsfc)
return;
priv = bsfc->priv_data;
av_bsf_free(&priv->ctx);
av_freep(&bsfc->priv_data);
av_free(bsfc);
}
void FFmpegEncoderClose(struct FFmpegEncoder* encoder) {
if (!encoder->context) {
return;
}
av_write_trailer(encoder->context);
avio_close(encoder->context->pb);
if (encoder->audioCodec) {
av_free(encoder->postaudioBuffer);
if (encoder->audioBuffer) {
av_free(encoder->audioBuffer);
}
#if LIBAVCODEC_VERSION_MAJOR >= 55
av_frame_free(&encoder->audioFrame);
#else
avcodec_free_frame(&encoder->audioFrame);
#endif
avcodec_close(encoder->audio);
if (encoder->resampleContext) {
#ifdef USE_LIBAVRESAMPLE
avresample_close(encoder->resampleContext);
#else
swr_free(&encoder->resampleContext);
#endif
}
if (encoder->absf) {
#ifdef FFMPEG_USE_NEW_BSF
av_bsf_free(&encoder->absf);
#else
av_bitstream_filter_close(encoder->absf);
encoder->absf = 0;
#endif
}
}
#if LIBAVCODEC_VERSION_MAJOR >= 55
av_frame_free(&encoder->videoFrame);
#else
avcodec_free_frame(&encoder->videoFrame);
#endif
avcodec_close(encoder->video);
sws_freeContext(encoder->scaleContext);
encoder->scaleContext = NULL;
avformat_free_context(encoder->context);
encoder->context = 0;
}
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;
}
