static int ffdec_init(struct decoder_ctx *ctx, int hw)
{
int ret;
AVCodecContext *avctx = ctx->avctx;
AVCodec *dec = avcodec_find_decoder(avctx->codec_id);
TRACE(ctx, "initialize context");
av_opt_set_int(avctx, "refcounted_frames", 1, 0);
if (hw && avctx->codec_id == AV_CODEC_ID_H264) {
AVCodec *codec = avcodec_find_decoder_by_name("h264_mediacodec");
if (!codec)
return AVERROR_DECODER_NOT_FOUND;
dec = codec;
}
TRACE(ctx, "codec open");
ret = avcodec_open2(avctx, dec, NULL);
if (ret < 0)
return ret;
ctx->avctx = avctx;
return ret;
}
AVCodec *FFDec::init( StreamInfo *_streamInfo )
{
streamInfo = _streamInfo;
AVCodec *codec = avcodec_find_decoder_by_name( streamInfo->codec_name );
if ( codec )
{
codec_ctx = avcodec_alloc_context3( codec );
codec_ctx->codec_id = codec->id;
codec_ctx->bit_rate = streamInfo->bitrate;
codec_ctx->channels = streamInfo->channels;
codec_ctx->sample_rate = streamInfo->sample_rate;
codec_ctx->block_align = streamInfo->block_align;
codec_ctx->bits_per_coded_sample = streamInfo->bpcs;
codec_ctx->pix_fmt = ( AVPixelFormat )streamInfo->img_fmt;
codec_ctx->coded_width = codec_ctx->width = streamInfo->W;
codec_ctx->coded_height = codec_ctx->height = streamInfo->H;
// codec_ctx->debug_mv = FF_DEBUG_VIS_MV_P_FOR | FF_DEBUG_VIS_MV_B_FOR || FF_DEBUG_VIS_MV_B_BACK;
if ( codec->type != AVMEDIA_TYPE_SUBTITLE && !streamInfo->data.isEmpty() )
{
codec_ctx->extradata = ( uint8_t * )streamInfo->data.data();
codec_ctx->extradata_size = streamInfo->data.size();
}
}
return codec;
}
static int module_init(void)
{
struct list *vidcodecl = baresip_vidcodecl();
char h264enc[64];
char h264dec[64];
#ifdef USE_X264
debug("avcodec: x264 build %d\n", X264_BUILD);
#else
debug("avcodec: using libavcodec H.264 encoder\n");
#endif
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(53, 10, 0)
avcodec_init();
#endif
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)
avcodec_register_all();
#endif
if (0 == conf_get_str(conf_cur(), "avcodec_h264dec",
h264dec, sizeof(h264dec))) {
info("avcodec: using h264 decoder by name (%s)\n", h264dec);
avcodec_h264dec = avcodec_find_decoder_by_name(h264dec);
if (!avcodec_h264dec) {
warning("avcodec: h264 decoder not found (%s)\n",
h264dec);
return ENOENT;
}
vidcodec_register(vidcodecl, &h264);
}
else {
if (avcodec_find_decoder(AV_CODEC_ID_H264))
vidcodec_register(vidcodecl, &h264);
}
if (avcodec_find_decoder(AV_CODEC_ID_H263))
vidcodec_register(vidcodecl, &h263);
if (avcodec_find_decoder(AV_CODEC_ID_MPEG4))
vidcodec_register(vidcodecl, &mpg4);
if (0 == conf_get_str(conf_cur(), "avcodec_h264enc",
h264enc, sizeof(h264enc))) {
info("avcodec: using h264 encoder by name (%s)\n", h264enc);
avcodec_h264enc = avcodec_find_encoder_by_name(h264enc);
if (!avcodec_h264enc) {
warning("avcodec: h264 encoder not found (%s)\n",
h264enc);
return ENOENT;
}
}
return 0;
}
bool AVDecoder::open()
{
DPTR_D(AVDecoder);
// codec_ctx can't be null for none-ffmpeg based decoders because we may use it's properties in those decoders
if (!d.codec_ctx) {
qWarning("FFmpeg codec context not ready");
return false;
}
AVCodec *codec = 0;
if (!d.codec_name.isEmpty()) {
codec = avcodec_find_decoder_by_name(d.codec_name.toUtf8().constData());
if (!codec) {
const AVCodecDescriptor* cd = avcodec_descriptor_get_by_name(d.codec_name.toUtf8().constData());
if (cd) {
codec = avcodec_find_decoder(cd->id);
}
}
} else {
codec = avcodec_find_decoder(d.codec_ctx->codec_id);
}
if (!codec) { // TODO: can be null for none-ffmpeg based decoders
QString es(tr("No codec could be found for '%1'"));
if (d.codec_name.isEmpty()) {
es = es.arg(QLatin1String(avcodec_get_name(d.codec_ctx->codec_id)));
} else {
es = es.arg(d.codec_name);
}
qWarning() << es;
AVError::ErrorCode ec(AVError::CodecError);
switch (d.codec_ctx->coder_type) {
case AVMEDIA_TYPE_VIDEO:
ec = AVError::VideoCodecNotFound;
break;
case AVMEDIA_TYPE_AUDIO:
ec = AVError::AudioCodecNotFound;
break;
case AVMEDIA_TYPE_SUBTITLE:
ec = AVError::SubtitleCodecNotFound;
default:
break;
}
emit error(AVError(ec, es));
return false;
}
// hwa extra init can be here
if (!d.open()) {
d.close();
return false;
}
// TODO: skip for none-ffmpeg based decoders
d.applyOptionsForDict();
av_opt_set_int(d.codec_ctx, "refcounted_frames", d.enableFrameRef(), 0); // why dict may have no effect?
// TODO: only open for ff decoders
AV_ENSURE_OK(avcodec_open2(d.codec_ctx, codec, d.options.isEmpty() ? NULL : &d.dict), false);
d.is_open = true;
return true;
}
AVCodec* VDPAUDecoder::openCodec(AVCodecContext* pContext)
{
if (!isAvailable()) {
return 0;
}
AVCodec* pCodec = 0;
switch (pContext->codec_id) {
case AV_CODEC_ID_MPEG1VIDEO:
pCodec = avcodec_find_decoder_by_name("mpeg1video_vdpau");
if(pCodec) {
pCodec->id = AV_CODEC_ID_MPEG1VIDEO;
}
break;
case AV_CODEC_ID_MPEG2VIDEO:
pCodec = avcodec_find_decoder_by_name("mpegvideo_vdpau");
break;
case AV_CODEC_ID_H264:
pCodec = avcodec_find_decoder_by_name("h264_vdpau");
break;
case AV_CODEC_ID_WMV3:
pCodec = avcodec_find_decoder_by_name("wmv3_vdpau");
break;
case AV_CODEC_ID_VC1:
pCodec = avcodec_find_decoder_by_name("vc1_vdpau");
break;
default:
pCodec = 0;
}
if (pCodec) {
pContext->get_buffer = VDPAUDecoder::getBuffer;
pContext->release_buffer = VDPAUDecoder::releaseBuffer;
pContext->draw_horiz_band = VDPAUDecoder::drawHorizBand;
pContext->get_format = VDPAUDecoder::getFormat;
pContext->slice_flags = SLICE_FLAG_CODED_ORDER | SLICE_FLAG_ALLOW_FIELD;
m_Size = IntPoint(pContext->width, pContext->height);
}
return pCodec;
}
bool AVDecoder::open()
{
DPTR_D(AVDecoder);
if (!d.codec_ctx) {
qWarning("FFmpeg codec context not ready");
return false;
}
AVCodec *codec = 0;
if (!d.codec_name.isEmpty()) {
codec = avcodec_find_decoder_by_name(d.codec_name.toUtf8().constData());
} else {
codec = avcodec_find_decoder(d.codec_ctx->codec_id);
}
if (!codec) {
QString es(tr("No codec could be found for '%1'"));
if (d.codec_name.isEmpty()) {
es = es.arg(avcodec_get_name(d.codec_ctx->codec_id));
} else {
es = es.arg(d.codec_name);
}
qWarning() << es;
AVError::ErrorCode ec(AVError::CodecError);
switch (d.codec_ctx->coder_type) {
case AVMEDIA_TYPE_VIDEO:
ec = AVError::VideoCodecNotFound;
break;
case AVMEDIA_TYPE_AUDIO:
ec = AVError::AudioCodecNotFound;
break;
case AVMEDIA_TYPE_SUBTITLE:
ec = AVError::SubtitleCodecNotFound;
default:
break;
}
emit error(AVError(ec, es));
return false;
}
// hwa extra init can be here
if (!d.open()) {
d.close();
return false;
}
d.applyOptionsForDict();
int ret = avcodec_open2(d.codec_ctx, codec, d.options.isEmpty() ? NULL : &d.dict);
if (ret < 0) {
qWarning("open video codec failed: %s", av_err2str(ret));
return false;
}
d.is_open = true;
return true;
}
AVCodecContext *new_software_decoder(uint8_t *decoder_config, uint32_t decoder_config_len)
{
char decoder_name[10];
int config_size,i;
AVCodecContext *dec;
bzero(decoder_name, sizeof(decoder_name));
memcpy(decoder_name, decoder_config, 4);
decoder_config += 4;
decoder_config_len -= 4;
// av_vaapi, av_vdpau
if (!strcmp(decoder_name,"wmv3")){
dec = avcodec_alloc_context2(AVMEDIA_TYPE_VIDEO);
memcpy(&config_size,decoder_config,sizeof(config_size));
decoder_config += sizeof(config_size);
decoder_config_len -=sizeof(config_size);
memcpy(&dec->width,decoder_config,sizeof(dec->width));
memcpy(&dec->height,decoder_config+sizeof(dec->width),sizeof(dec->height));
decoder_config += config_size;
decoder_config_len -= config_size;
} else if(!strcmp(decoder_name,"wmav")){
dec = avcodec_alloc_context2(AVMEDIA_TYPE_AUDIO);
bzero(decoder_name, sizeof(decoder_name));
memcpy(decoder_name,decoder_config-4,5);
decoder_config++; decoder_config_len--;
memcpy(&dec->channels,decoder_config,sizeof(dec->channels));
memcpy(&dec->bit_rate,decoder_config+=sizeof(dec->channels),sizeof(dec->bit_rate));
memcpy(&dec->sample_rate,decoder_config+=sizeof(dec->bit_rate),sizeof(dec->sample_rate));
decoder_config+=sizeof(dec->sample_rate);decoder_config_len-=sizeof(dec->sample_rate) + sizeof(dec->bit_rate) + sizeof(dec->channels);
};
printf("PARAMS: %i %i %i",dec->bit_rate,dec->sample_rate,dec->channels);
AVCodec *decoder = avcodec_find_decoder_by_name(decoder_name);
if(!decoder) {
fprintf(stderr, "Can't find decoder %s\r\n", decoder_name);
return NULL;
};
dec->extradata_size = decoder_config_len;
dec->extradata = av_mallocz(dec->extradata_size);
memcpy(dec->extradata, (const char *)decoder_config, dec->extradata_size);
av_log(dec,AV_LOG_ERROR,"Payload: \n");
for(i=0;i<dec->extradata_size;i++)
av_log(dec,AV_LOG_ERROR,"%i, ",(int)dec->extradata[i]);
if(avcodec_open(dec, decoder) < 0) {
free(dec->extradata);
dec->extradata = NULL;
av_free(dec);
fprintf(stderr, "Can't open decoder %i\r\n");
return NULL;
};
return dec;
}
int mp_codec_to_av_codec_id(const char *codec)
{
int id = AV_CODEC_ID_NONE;
if (codec) {
const AVCodecDescriptor *desc = avcodec_descriptor_get_by_name(codec);
if (desc)
id = desc->id;
if (id == AV_CODEC_ID_NONE) {
AVCodec *avcodec = avcodec_find_decoder_by_name(codec);
if (avcodec)
id = avcodec->id;
}
}
return id;
}
bool FFMpegDecoder::open_codec(const char * codec_name)
{
m_pCodec = avcodec_find_decoder_by_name(codec_name);
if (m_pCodec == NULL){
return false;
}
if (m_pCodecContext == NULL)
m_pCodecContext = avcodec_alloc_context3(m_pCodec);
if (avcodec_open2(m_pCodecContext, m_pCodec, &m_Options)<0){
return false;
}
m_isOpened = true;
return true;
}
FFMpegVideoDecoder::FFMpegVideoDecoder(char* codecName)
{
codec =avcodec_find_decoder_by_name(codecName);
if (!codec)
{
fprintf(stderr,"failed to find decoder: %s\n",codecName);
}
ctx = avcodec_alloc_context();
decodedFrame = avcodec_alloc_frame();
avcodec_open(ctx,codec);
AVPacket avpkt;
av_init_packet(&avpkt);
}
// ---------------------------------------------------------------------------------
static PyObject * Codec_GetID( PyACodecObject* obj, PyObject *args)
{
AVCodec *p;
char *sName=NULL;
int i= 0;
if (!PyArg_ParseTuple(args, "s", &sName ))
return NULL;
p = avcodec_find_encoder_by_name(sName);
if( !p )
p = avcodec_find_decoder_by_name(sName);
if (p)
i= p->id;
return PyInt_FromLong( i );
}
static AVCodec *find_decoder
(
enum AVCodecID codec_id,
const char **preferred_decoder_names
)
{
AVCodec *codec = avcodec_find_decoder( codec_id );
if( codec && preferred_decoder_names )
for( const char **decoder_name = preferred_decoder_names; *decoder_name != NULL; decoder_name++ )
{
AVCodec *preferred_decoder = avcodec_find_decoder_by_name( *decoder_name );
if( preferred_decoder
&& preferred_decoder->id == codec->id )
{
codec = preferred_decoder;
break;
}
}
return codec;
}
static int open_codec_context(AVCodecContext **dec_ctx, AVFormatContext *fmt_ctx, char *codec)
{
int ret = -1;
AVCodec *dec = avcodec_find_decoder_by_name(codec);
AVDictionary *opts = NULL;
unsigned int i;
for (i = 0; i < fmt_ctx->nb_streams && i < INT_MAX; i += 1) {
if (fmt_ctx->streams[i]->codec) {
if (!dec || (fmt_ctx->streams[i]->codec->codec_id == dec->id)) {
*dec_ctx = fmt_ctx->streams[i]->codec;
ret = 0;
break;
}
}
}
if (ret < 0) {
fprintf(stderr, "Could not find stream\n");
} else {
/* find decoder for the stream */
if (!dec)
dec = avcodec_find_decoder((*dec_ctx)->codec_id);
if (!dec) {
fprintf(stderr, "Failed to find decoder\n");
return -1;
}
/* Init the decoders, with or without reference counting */
av_dict_set(&opts, "refcounted_frames", "1", 0);
av_dict_set(&opts, "strict", "-2", 0);
av_dict_set(&opts, "codec_whitelist", codec, 0);
av_dict_set(&opts, "thread_type", "slice", 0);
if ((ret = avcodec_open2(*dec_ctx, dec, &opts)) < 0) {
fprintf(stderr, "Failed to open decoder\n");
}
av_dict_free(&opts);
}
return ret;
}
static AVCodec *find_hardware_decoder(enum AVCodecID id)
{
AVHWAccel *hwa = av_hwaccel_next(NULL);
AVCodec *c = NULL;
while (hwa) {
if (hwa->id == id) {
if (hwa->pix_fmt == AV_PIX_FMT_VDA_VLD ||
hwa->pix_fmt == AV_PIX_FMT_DXVA2_VLD ||
hwa->pix_fmt == AV_PIX_FMT_VAAPI_VLD) {
c = avcodec_find_decoder_by_name(hwa->name);
if (c)
break;
}
}
hwa = av_hwaccel_next(hwa);
}
return c;
}
int RealFFMpegCodecDecoder::InitCodec(char *_codecName)
{
avcodec_register_all();
if (ctx)
{
avcodec_close(ctx);
av_free(ctx);
}
codec = avcodec_find_decoder_by_name(_codecName);
ctx = avcodec_alloc_context();
int ret = avcodec_open(ctx, codec);
if(codec->capabilities&CODEC_CAP_TRUNCATED)
ctx->flags|= CODEC_FLAG_TRUNCATED;
strcpy(m_codecName,codec->name);
return ret;
}
static int latm_decode_init(AVCodecContext *avctx)
{
struct LATMContext *latmctx = avctx->priv_data;
int ret;
latmctx->aac_codec = avcodec_find_decoder_by_name("aac");
if (!latmctx->aac_codec) {
av_log(avctx, AV_LOG_ERROR, "AAC decoder is required by AAC LATM decoder.\n");
return AVERROR(ENOSYS);
}
assert(latmctx->aac_codec->init);
ret = latmctx->aac_codec->init(avctx);
if (avctx->extradata_size > 0)
latmctx->initialized = !ret;
else
latmctx->initialized = 0;
return ret;
}
// ---------------------------------------------------------------------------------
static PyObject * GetCodecID( PyObject* obj, PyObject *args)
{
AVCodec *p;
PyObject* cRes=NULL;
char *sName=NULL;
if (!PyArg_ParseTuple(args, "s", &sName ))
return NULL;
p = avcodec_find_encoder_by_name(sName);
if( !p )
p = avcodec_find_decoder_by_name(sName);
if (p)
{
cRes = Py_BuildValue("i",p->id);
return cRes;
}
else
{
PyErr_Format( g_cErr, "%s: no such codec exists", sName );
return NULL;
}
}
static int init(sh_audio_t *sh_audio)
{
struct MPOpts *opts = sh_audio->opts;
AVCodecContext *lavc_context;
AVCodec *lavc_codec;
if (sh_audio->codec->dll) {
lavc_codec = avcodec_find_decoder_by_name(sh_audio->codec->dll);
if (!lavc_codec) {
mp_tmsg(MSGT_DECAUDIO, MSGL_ERR,
"Cannot find codec '%s' in libavcodec...\n",
sh_audio->codec->dll);
return 0;
}
} else if (!sh_audio->libav_codec_id) {
mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "No Libav codec ID known. "
"Generic lavc decoder is not applicable.\n");
return 0;
} else {
lavc_codec = avcodec_find_decoder(sh_audio->libav_codec_id);
if (!lavc_codec) {
mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "Libavcodec has no decoder "
"for this codec\n");
return 0;
}
}
sh_audio->codecname = lavc_codec->long_name;
if (!sh_audio->codecname)
sh_audio->codecname = lavc_codec->name;
struct priv *ctx = talloc_zero(NULL, struct priv);
sh_audio->context = ctx;
lavc_context = avcodec_alloc_context3(lavc_codec);
ctx->avctx = lavc_context;
ctx->avframe = avcodec_alloc_frame();
// Always try to set - option only exists for AC3 at the moment
av_opt_set_double(lavc_context, "drc_scale", opts->drc_level,
AV_OPT_SEARCH_CHILDREN);
lavc_context->sample_rate = sh_audio->samplerate;
lavc_context->bit_rate = sh_audio->i_bps * 8;
if (sh_audio->wf) {
lavc_context->channels = sh_audio->wf->nChannels;
lavc_context->sample_rate = sh_audio->wf->nSamplesPerSec;
lavc_context->bit_rate = sh_audio->wf->nAvgBytesPerSec * 8;
lavc_context->block_align = sh_audio->wf->nBlockAlign;
lavc_context->bits_per_coded_sample = sh_audio->wf->wBitsPerSample;
}
lavc_context->request_channels = opts->audio_output_channels;
lavc_context->codec_tag = sh_audio->format; //FOURCC
lavc_context->codec_type = AVMEDIA_TYPE_AUDIO;
lavc_context->codec_id = lavc_codec->id; // not sure if required, imho not --A'rpi
/* alloc extra data */
if (sh_audio->wf && sh_audio->wf->cbSize > 0) {
lavc_context->extradata = av_mallocz(sh_audio->wf->cbSize + FF_INPUT_BUFFER_PADDING_SIZE);
lavc_context->extradata_size = sh_audio->wf->cbSize;
memcpy(lavc_context->extradata, sh_audio->wf + 1,
lavc_context->extradata_size);
}
// for QDM2
if (sh_audio->codecdata_len && sh_audio->codecdata &&
!lavc_context->extradata) {
lavc_context->extradata = av_malloc(sh_audio->codecdata_len +
FF_INPUT_BUFFER_PADDING_SIZE);
lavc_context->extradata_size = sh_audio->codecdata_len;
memcpy(lavc_context->extradata, (char *)sh_audio->codecdata,
lavc_context->extradata_size);
}
/* open it */
if (avcodec_open2(lavc_context, lavc_codec, NULL) < 0) {
mp_tmsg(MSGT_DECAUDIO, MSGL_ERR, "Could not open codec.\n");
uninit(sh_audio);
return 0;
}
mp_msg(MSGT_DECAUDIO, MSGL_V, "INFO: libavcodec \"%s\" init OK!\n",
lavc_codec->name);
if (sh_audio->format == 0x3343414D) {
// MACE 3:1
sh_audio->ds->ss_div = 2 * 3; // 1 samples/packet
sh_audio->ds->ss_mul = 2 * sh_audio->wf->nChannels; // 1 byte*ch/packet
} else if (sh_audio->format == 0x3643414D) {
// MACE 6:1
sh_audio->ds->ss_div = 2 * 6; // 1 samples/packet
sh_audio->ds->ss_mul = 2 * sh_audio->wf->nChannels; // 1 byte*ch/packet
}
// Decode at least 1 byte: (to get header filled)
for (int tries = 0;;) {
int x = decode_audio(sh_audio, sh_audio->a_buffer, 1,
sh_audio->a_buffer_size);
if (x > 0) {
sh_audio->a_buffer_len = x;
break;
}
if (++tries >= 5) {
mp_msg(MSGT_DECAUDIO, MSGL_ERR,
"ad_ffmpeg: initial decode failed\n");
uninit(sh_audio);
return 0;
}
}
sh_audio->i_bps = lavc_context->bit_rate / 8;
if (sh_audio->wf && sh_audio->wf->nAvgBytesPerSec)
sh_audio->i_bps = sh_audio->wf->nAvgBytesPerSec;
return 1;
}
static int decode_example(const char *filename)
{
AVFormatContext *fctx = NULL;
AVCodec *codec;
AVCodecContext *avctx;
int video_st = -1;
int i, got_pic;
AVFrame *picture, *tmp_picture;
int size;
uint8_t *tmp_buf;
int ret = 0;
avformat_open_input(&fctx, filename, NULL, NULL);
if (fctx == NULL)
return AVERROR(1);
av_find_stream_info(fctx);
av_dump_format(fctx, 0, filename, 0);
for (i = 0; i < fctx->nb_streams; i++) {
if (fctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
video_st = i;
break;
}
}
avctx = fctx->streams[video_st]->codec;
codec = avcodec_find_decoder_by_name("libdm365_h264");
if (codec == NULL) {
av_log(avctx, AV_LOG_ERROR, "unsupported codec\n");
return AVERROR(1);
}
if (avcodec_open(avctx, codec) < 0) {
av_log(avctx, AV_LOG_ERROR, "cannot open codec\n");
return AVERROR(1);
}
picture = avcodec_alloc_frame();
tmp_picture = avcodec_alloc_frame();
size = avpicture_get_size(PIX_FMT_YUV420P, avctx->width, avctx->height);
tmp_buf = av_malloc(size);
if (tmp_buf == NULL) {
ret = AVERROR(ENOMEM);
goto decode_cleanup;
}
avpicture_fill((AVPicture *)tmp_picture, tmp_buf,
PIX_FMT_NV12, avctx->width, avctx->height);
for (i = 0; i < 10; i++) {
AVPacket pkt;
int nb;
char fname[32];
int factor = 2;
if (av_read_frame(fctx, &pkt) < 0)
break;
nb = avcodec_decode_video2(avctx, picture, &got_pic, &pkt);
if (nb < 0) {
av_log(avctx, AV_LOG_ERROR, "error in decoding\n");
goto decode_cleanup;
}
printf("Decoded frame: %d\n", i);
my_scale((AVPicture *) picture, avctx->width, avctx->height,
(AVPicture *) tmp_picture, factor);
sprintf(fname, "frame%02d.pgm", i+1);
pgm_save(picture->data[0], picture->linesize[0],
avctx->width, avctx->height, fname);
sprintf(fname, "frame%02d.bmp", i+1);
save_image((AVPicture *)tmp_picture, avctx->pix_fmt,
avctx->width/factor, avctx->height/factor, fname);
}
decode_cleanup:
av_free(picture);
av_free(tmp_picture->data[0]);
av_free(tmp_picture);
av_close_input_file(fctx);
avcodec_close(avctx);
return ret;
}
static int init(sh_audio_t *sh_audio)
{
int tries = 0;
int x;
AVCodecContext *lavc_context;
AVCodec *lavc_codec;
mp_msg(MSGT_DECAUDIO,MSGL_V,"FFmpeg's libavcodec audio codec\n");
if(!avcodec_initialized){
avcodec_init();
avcodec_register_all();
avcodec_initialized=1;
}
lavc_codec = (AVCodec *)avcodec_find_decoder_by_name(sh_audio->codec->dll);
if(!lavc_codec){
mp_tmsg(MSGT_DECAUDIO,MSGL_ERR,"Cannot find codec '%s' in libavcodec...\n",sh_audio->codec->dll);
return 0;
}
lavc_context = avcodec_alloc_context();
sh_audio->context=lavc_context;
lavc_context->sample_rate = sh_audio->samplerate;
lavc_context->bit_rate = sh_audio->i_bps * 8;
if(sh_audio->wf){
lavc_context->channels = sh_audio->wf->nChannels;
lavc_context->sample_rate = sh_audio->wf->nSamplesPerSec;
lavc_context->bit_rate = sh_audio->wf->nAvgBytesPerSec * 8;
lavc_context->block_align = sh_audio->wf->nBlockAlign;
lavc_context->bits_per_coded_sample = sh_audio->wf->wBitsPerSample;
}
lavc_context->request_channels = audio_output_channels;
lavc_context->codec_tag = sh_audio->format; //FOURCC
lavc_context->codec_type = CODEC_TYPE_AUDIO;
lavc_context->codec_id = lavc_codec->id; // not sure if required, imho not --A'rpi
/* alloc extra data */
if (sh_audio->wf && sh_audio->wf->cbSize > 0) {
lavc_context->extradata = av_mallocz(sh_audio->wf->cbSize + FF_INPUT_BUFFER_PADDING_SIZE);
lavc_context->extradata_size = sh_audio->wf->cbSize;
memcpy(lavc_context->extradata, (char *)sh_audio->wf + sizeof(WAVEFORMATEX),
lavc_context->extradata_size);
}
// for QDM2
if (sh_audio->codecdata_len && sh_audio->codecdata && !lavc_context->extradata)
{
lavc_context->extradata = av_malloc(sh_audio->codecdata_len);
lavc_context->extradata_size = sh_audio->codecdata_len;
memcpy(lavc_context->extradata, (char *)sh_audio->codecdata,
lavc_context->extradata_size);
}
/* open it */
if (avcodec_open(lavc_context, lavc_codec) < 0) {
mp_tmsg(MSGT_DECAUDIO,MSGL_ERR, "Could not open codec.\n");
return 0;
}
mp_msg(MSGT_DECAUDIO,MSGL_V,"INFO: libavcodec \"%s\" init OK!\n", lavc_codec->name);
// printf("\nFOURCC: 0x%X\n",sh_audio->format);
if(sh_audio->format==0x3343414D){
// MACE 3:1
sh_audio->ds->ss_div = 2*3; // 1 samples/packet
sh_audio->ds->ss_mul = 2*sh_audio->wf->nChannels; // 1 byte*ch/packet
} else
if(sh_audio->format==0x3643414D){
// MACE 6:1
sh_audio->ds->ss_div = 2*6; // 1 samples/packet
sh_audio->ds->ss_mul = 2*sh_audio->wf->nChannels; // 1 byte*ch/packet
}
// Decode at least 1 byte: (to get header filled)
do {
x=decode_audio(sh_audio,sh_audio->a_buffer,1,sh_audio->a_buffer_size);
} while (x <= 0 && tries++ < 5);
if(x>0) sh_audio->a_buffer_len=x;
sh_audio->channels=lavc_context->channels;
sh_audio->samplerate=lavc_context->sample_rate;
sh_audio->i_bps=lavc_context->bit_rate/8;
switch (lavc_context->sample_fmt) {
case SAMPLE_FMT_U8: sh_audio->sample_format = AF_FORMAT_U8; break;
case SAMPLE_FMT_S16: sh_audio->sample_format = AF_FORMAT_S16_NE; break;
case SAMPLE_FMT_S32: sh_audio->sample_format = AF_FORMAT_S32_NE; break;
case SAMPLE_FMT_FLT: sh_audio->sample_format = AF_FORMAT_FLOAT_NE; break;
default:
mp_msg(MSGT_DECAUDIO, MSGL_FATAL, "Unsupported sample format\n");
return 0;
}
/* If the audio is AAC the container level data may be unreliable
* because of SBR handling problems (possibly half real sample rate at
* container level). Default AAC decoding with ad_faad has used codec-level
* values for a long time without generating complaints so it should be OK.
*/
if (sh_audio->wf && lavc_context->codec_id != CODEC_ID_AAC) {
// If the decoder uses the wrong number of channels all is lost anyway.
// sh_audio->channels=sh_audio->wf->nChannels;
if (sh_audio->wf->nSamplesPerSec)
sh_audio->samplerate=sh_audio->wf->nSamplesPerSec;
if (sh_audio->wf->nAvgBytesPerSec)
sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec;
}
sh_audio->samplesize=af_fmt2bits(sh_audio->sample_format)/ 8;
return 1;
}
// IDemux
void CInputStream::UpdateStreams()
{
DisposeStreams();
INPUTSTREAM_IDS streamIDs;
try
{
streamIDs = m_pStruct->GetStreamIds();
}
catch (std::exception &e)
{
DisposeStreams();
CLog::Log(LOGERROR, "CInputStream::UpdateStreams - error GetStreamIds. Reason: %s", e.what());
return;
}
if (streamIDs.m_streamCount > INPUTSTREAM_IDS::MAX_STREAM_COUNT)
{
DisposeStreams();
return;
}
for (unsigned int i=0; i<streamIDs.m_streamCount; i++)
{
INPUTSTREAM_INFO stream;
try
{
stream = m_pStruct->GetStream(streamIDs.m_streamIds[i]);
}
catch (std::exception &e)
{
DisposeStreams();
CLog::Log(LOGERROR, "CInputStream::GetTotalTime - error GetStream. Reason: %s", e.what());
return;
}
if (stream.m_streamType == INPUTSTREAM_INFO::TYPE_NONE)
continue;
std::string codecName(stream.m_codecName);
StringUtils::ToLower(codecName);
AVCodec *codec = avcodec_find_decoder_by_name(codecName.c_str());
if (!codec)
continue;
CDemuxStream *demuxStream;
if (stream.m_streamType == INPUTSTREAM_INFO::TYPE_AUDIO)
{
CDemuxStreamAudio *audioStream = new CDemuxStreamAudio();
audioStream->iChannels = stream.m_Channels;
audioStream->iSampleRate = stream.m_SampleRate;
audioStream->iBlockAlign = stream.m_BlockAlign;
audioStream->iBitRate = stream.m_BitRate;
audioStream->iBitsPerSample = stream.m_BitsPerSample;
demuxStream = audioStream;
}
else if (stream.m_streamType == INPUTSTREAM_INFO::TYPE_VIDEO)
{
CDemuxStreamVideo *videoStream = new CDemuxStreamVideo();
videoStream->iFpsScale = stream.m_FpsScale;
videoStream->iFpsRate = stream.m_FpsRate;
videoStream->iWidth = stream.m_Width;
videoStream->iHeight = stream.m_Height;
videoStream->fAspect = stream.m_Aspect;
videoStream->stereo_mode = "mono";
demuxStream = videoStream;
}
else if (stream.m_streamType == INPUTSTREAM_INFO::TYPE_SUBTITLE)
{
// TODO needs identifier in INPUTSTREAM_INFO
continue;
}
else
continue;
demuxStream->codec = codec->id;
demuxStream->bandwidth = stream.m_Bandwidth;
demuxStream->codecName = stream.m_codecInternalName;
demuxStream->uniqueId = streamIDs.m_streamIds[i];
demuxStream->language[0] = stream.m_language[0];
demuxStream->language[1] = stream.m_language[1];
demuxStream->language[2] = stream.m_language[2];
demuxStream->language[3] = stream.m_language[3];
if (stream.m_ExtraData && stream.m_ExtraSize)
{
demuxStream->ExtraData = new uint8_t[stream.m_ExtraSize];
demuxStream->ExtraSize = stream.m_ExtraSize;
for (unsigned int j=0; j<stream.m_ExtraSize; j++)
demuxStream->ExtraData[j] = stream.m_ExtraData[j];
}
m_streams[demuxStream->uniqueId] = demuxStream;
}
}
// init driver
static int init(sh_video_t *sh){
AVCodecContext *avctx;
vd_ffmpeg_ctx *ctx;
AVCodec *lavc_codec;
int lowres_w=0;
int do_vis_debug= lavc_param_vismv || (lavc_param_debug&(FF_DEBUG_VIS_MB_TYPE|FF_DEBUG_VIS_QP));
// slice is rather broken with threads, so disable that combination unless
// explicitly requested
int use_slices = vd_use_slices > 0 || (vd_use_slices < 0 && lavc_param_threads <= 1);
AVDictionary *opts = NULL;
init_avcodec();
ctx = sh->context = malloc(sizeof(vd_ffmpeg_ctx));
if (!ctx)
return 0;
memset(ctx, 0, sizeof(vd_ffmpeg_ctx));
lavc_codec = avcodec_find_decoder_by_name(sh->codec->dll);
if(!lavc_codec){
mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_MissingLAVCcodec, sh->codec->dll);
uninit(sh);
return 0;
}
if (auto_threads) {
#if (defined(__MINGW32__) && HAVE_PTHREADS)
lavc_param_threads = pthread_num_processors_np();
#elif defined(__linux__)
/* Code stolen from x264 :) */
unsigned int bit;
int np;
cpu_set_t p_aff;
memset( &p_aff, 0, sizeof(p_aff) );
sched_getaffinity( 0, sizeof(p_aff), &p_aff );
for( np = 0, bit = 0; bit < sizeof(p_aff); bit++ )
np += (((uint8_t *)&p_aff)[bit / 8] >> (bit % 8)) & 1;
lavc_param_threads = np;
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__APPLE__) || defined (__NetBSD__) || defined(__OpenBSD__)
/* Code stolen from x264 :) */
int numberOfCPUs;
size_t length = sizeof( numberOfCPUs );
#if defined (__NetBSD__) || defined(__OpenBSD__)
int mib[2] = { CTL_HW, HW_NCPU };
if( sysctl(mib, 2, &numberOfCPUs, &length, NULL, 0) )
#else
if( sysctlbyname("hw.ncpu", &numberOfCPUs, &length, NULL, 0) )
#endif
{
numberOfCPUs = 1;
}
lavc_param_threads = numberOfCPUs;
#endif
if(lavc_codec->id == CODEC_ID_H264 || lavc_codec->id == CODEC_ID_FFH264
|| lavc_codec->id == CODEC_ID_MPEG2TS || lavc_codec->id == CODEC_ID_MPEG2VIDEO_XVMC) {
if (lavc_param_threads > 16) lavc_param_threads = 16;
if (lavc_param_threads > 1 && (lavc_codec->id == CODEC_ID_MPEG2VIDEO ||
lavc_codec->id == CODEC_ID_MPEG2TS || lavc_codec->id == CODEC_ID_MPEG2VIDEO_XVMC))
vd_use_slices = 0;
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Spawning %d decoding thread%s...\n", lavc_param_threads, lavc_param_threads == 1 ? "" : "s");
} else {
lavc_param_threads = 1;
}
}
if(use_slices && (lavc_codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND) && !do_vis_debug)
ctx->do_slices=1;
if(lavc_codec->capabilities&CODEC_CAP_DR1 && !do_vis_debug && lavc_codec->id != CODEC_ID_INTERPLAY_VIDEO && lavc_codec->id != CODEC_ID_VP8)
ctx->do_dr1=1;
ctx->nonref_dr = lavc_codec->id == CODEC_ID_H264;
ctx->ip_count= ctx->b_count= 0;
ctx->pic = avcodec_alloc_frame();
ctx->avctx = avcodec_alloc_context3(lavc_codec);
avctx = ctx->avctx;
avctx->opaque = sh;
avctx->codec_id = lavc_codec->id;
avctx->get_format = get_format;
if(ctx->do_dr1){
avctx->flags|= CODEC_FLAG_EMU_EDGE;
avctx-> get_buffer= get_buffer;
avctx->release_buffer= release_buffer;
avctx-> reget_buffer= get_buffer;
}
avctx->flags|= lavc_param_bitexact;
avctx->coded_width = sh->disp_w;
avctx->coded_height= sh->disp_h;
avctx->workaround_bugs= lavc_param_workaround_bugs;
switch (lavc_param_error_resilience) {
case 5:
avctx->err_recognition |= AV_EF_EXPLODE | AV_EF_COMPLIANT | AV_EF_CAREFUL;
break;
case 4:
case 3:
avctx->err_recognition |= AV_EF_AGGRESSIVE;
// Fallthrough
case 2:
avctx->err_recognition |= AV_EF_COMPLIANT;
// Fallthrough
case 1:
avctx->err_recognition |= AV_EF_CAREFUL;
}
lavc_param_gray|= CODEC_FLAG_GRAY;
#ifdef CODEC_FLAG2_SHOW_ALL
if(!lavc_param_wait_keyframe) avctx->flags2 |= CODEC_FLAG2_SHOW_ALL;
#endif
avctx->flags2|= lavc_param_fast;
avctx->codec_tag= sh->format;
avctx->stream_codec_tag= sh->video.fccHandler;
avctx->idct_algo= lavc_param_idct_algo;
avctx->error_concealment= lavc_param_error_concealment;
avctx->debug= lavc_param_debug;
if (lavc_param_debug)
av_log_set_level(AV_LOG_DEBUG);
avctx->debug_mv= lavc_param_vismv;
avctx->skip_top = lavc_param_skip_top;
avctx->skip_bottom= lavc_param_skip_bottom;
if(lavc_param_lowres_str != NULL)
{
sscanf(lavc_param_lowres_str, "%d,%d", &lavc_param_lowres, &lowres_w);
if(lavc_param_lowres < 1 || lavc_param_lowres > 16 || (lowres_w > 0 && avctx->width < lowres_w))
lavc_param_lowres = 0;
avctx->lowres = lavc_param_lowres;
}
avctx->skip_loop_filter = str2AVDiscard(lavc_param_skip_loop_filter_str);
avctx->skip_idct = str2AVDiscard(lavc_param_skip_idct_str);
avctx->skip_frame = str2AVDiscard(lavc_param_skip_frame_str);
if(lavc_avopt){
if (parse_avopts(avctx, lavc_avopt) < 0 &&
(!lavc_codec->priv_class ||
parse_avopts(avctx->priv_data, lavc_avopt) < 0)) {
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "Your options /%s/ look like gibberish to me pal\n", lavc_avopt);
uninit(sh);
return 0;
}
}
skip_idct = avctx->skip_idct;
skip_frame = avctx->skip_frame;
mp_dbg(MSGT_DECVIDEO, MSGL_DBG2, "libavcodec.size: %d x %d\n", avctx->width, avctx->height);
switch (sh->format) {
case mmioFOURCC('S','V','Q','3'):
/* SVQ3 extradata can show up as sh->ImageDesc if demux_mov is used, or
in the phony AVI header if demux_lavf is used. The first case is
handled here; the second case falls through to the next section. */
if (sh->ImageDesc) {
avctx->extradata_size = (*(int *)sh->ImageDesc) - sizeof(int);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, ((int *)sh->ImageDesc)+1, avctx->extradata_size);
break;
}
/* fallthrough */
case mmioFOURCC('A','V','R','n'):
case mmioFOURCC('M','J','P','G'):
/* AVRn stores huffman table in AVI header */
/* Pegasus MJPEG stores it also in AVI header, but it uses the common
MJPG fourcc :( */
if (!sh->bih || sh->bih->biSize <= sizeof(*sh->bih))
break;
av_dict_set(&opts, "extern_huff", "1", 0);
avctx->extradata_size = sh->bih->biSize-sizeof(*sh->bih);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, sh->bih+1, avctx->extradata_size);
#if 0
{
int x;
uint8_t *p = avctx->extradata;
for (x=0; x<avctx->extradata_size; x++)
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "[%x] ", p[x]);
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "\n");
}
#endif
break;
case mmioFOURCC('R', 'V', '1', '0'):
case mmioFOURCC('R', 'V', '1', '3'):
case mmioFOURCC('R', 'V', '2', '0'):
case mmioFOURCC('R', 'V', '3', '0'):
case mmioFOURCC('R', 'V', '4', '0'):
if(sh->bih->biSize<sizeof(*sh->bih)+8){
/* only 1 packet per frame & sub_id from fourcc */
avctx->extradata_size= 8;
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
((uint32_t *)avctx->extradata)[0] = 0;
((uint32_t *)avctx->extradata)[1] =
(sh->format == mmioFOURCC('R', 'V', '1', '3')) ? 0x10003001 : 0x10000000;
} else {
/* has extra slice header (demux_rm or rm->avi streamcopy) */
avctx->extradata_size = sh->bih->biSize-sizeof(*sh->bih);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, sh->bih+1, avctx->extradata_size);
}
avctx->sub_id= AV_RB32(avctx->extradata+4);
// printf("%X %X %d %d\n", extrahdr[0], extrahdr[1]);
break;
default:
if (!sh->bih || sh->bih->biSize <= sizeof(*sh->bih))
break;
avctx->extradata_size = sh->bih->biSize-sizeof(*sh->bih);
avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(avctx->extradata, sh->bih+1, avctx->extradata_size);
break;
}
if(sh->bih)
avctx->bits_per_coded_sample= sh->bih->biBitCount;
avctx->thread_count = lavc_param_threads;
avctx->thread_type = FF_THREAD_FRAME | FF_THREAD_SLICE;
if(lavc_codec->capabilities & CODEC_CAP_HWACCEL)
// HACK around badly placed checks in mpeg_mc_decode_init
set_format_params(avctx, PIX_FMT_XVMC_MPEG2_IDCT);
/* open it */
if (avcodec_open2(avctx, lavc_codec, &opts) < 0) {
mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_CantOpenCodec);
uninit(sh);
return 0;
}
av_dict_free(&opts);
// this is necessary in case get_format was never called and init_vo is
// too late e.g. for H.264 VDPAU
set_format_params(avctx, avctx->pix_fmt);
mp_msg(MSGT_DECVIDEO, MSGL_V, "INFO: libavcodec init OK!\n");
return 1; //mpcodecs_config_vo(sh, sh->disp_w, sh->disp_h, IMGFMT_YV12);
}
bool AVDecoder::open()
{
DPTR_D(AVDecoder);
if (!d.codec_ctx) {
qWarning("FFmpeg codec context not ready");
return false;
}
AVCodec *codec = 0;
if (!d.codec_name.isEmpty()) {
codec = avcodec_find_decoder_by_name(d.codec_name.toUtf8().constData());
} else {
codec = avcodec_find_decoder(d.codec_ctx->codec_id);
}
if (!codec) {
if (d.codec_name.isEmpty()) {
qWarning("No codec could be found with id %d", d.codec_ctx->codec_id);
} else {
qWarning("No codec could be found with name %s", d.codec_name.toUtf8().constData());
}
return false;
}
//setup video codec context
if (d.low_resolution > codec->max_lowres) {
qWarning("Use the max value for lowres supported by the decoder (%d)", codec->max_lowres);
d.low_resolution = codec->max_lowres;
}
d.codec_ctx->lowres = d.low_resolution;
if (d.codec_ctx->lowres) {
d.codec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
}
if (d.fast) {
d.codec_ctx->flags2 |= CODEC_FLAG2_FAST;
} else {
//d.codec_ctx->flags2 &= ~CODEC_FLAG2_FAST; //ffplay has no this
}
if (codec->capabilities & CODEC_CAP_DR1) {
d.codec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
}
//set thread
//d.codec_ctx->strict_std_compliance = FF_COMPLIANCE_STRICT;
//d.codec_ctx->slice_flags |= SLICE_FLAG_ALLOW_FIELD;
// lavfilter
//d.codec_ctx->slice_flags |= SLICE_FLAG_ALLOW_FIELD; //lavfilter
//d.codec_ctx->strict_std_compliance = FF_COMPLIANCE_STRICT;
//from vlc
//HAVE_AVCODEC_MT macro?
if (d.threads == -1)
d.threads = qMax(0, QThread::idealThreadCount());
if (d.threads > 0)
d.codec_ctx->thread_count = d.threads;
d.codec_ctx->thread_safe_callbacks = true;
switch (d.codec_ctx->codec_id) {
case QTAV_CODEC_ID(MPEG4):
case QTAV_CODEC_ID(H263):
d.codec_ctx->thread_type = 0;
break;
case QTAV_CODEC_ID(MPEG1VIDEO):
case QTAV_CODEC_ID(MPEG2VIDEO):
d.codec_ctx->thread_type &= ~FF_THREAD_SLICE;
/* fall through */
# if (LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55, 1, 0))
case QTAV_CODEC_ID(H264):
case QTAV_CODEC_ID(VC1):
case QTAV_CODEC_ID(WMV3):
d.codec_ctx->thread_type &= ~FF_THREAD_FRAME;
# endif
default:
break;
}
/*
if (d.codec_ctx->thread_type & FF_THREAD_FRAME)
p_dec->i_extra_picture_buffers = 2 * p_sys->p_context->thread_count;
*/
// hwa extra init can be here
if (!d.open()) {
d.close();
return false;
}
//set dict used by avcodec_open2(). see ffplay
// AVDictionary *opts;
int ret = avcodec_open2(d.codec_ctx, codec, d.options.isEmpty() ? NULL : &d.dict);
if (ret < 0) {
qWarning("open video codec failed: %s", av_err2str(ret));
return false;
}
d.is_open = true;
return true;
}
static bool find_decoder(struct ff_demuxer *demuxer, AVStream *stream)
{
AVCodecContext *codec_context = NULL;
AVCodec *codec = NULL;
AVDictionary *options_dict = NULL;
int ret;
bool hwaccel_decoder = false;
codec_context = stream->codec;
// enable reference counted frames since we may have a buffer size
// > 1
codec_context->refcounted_frames = 1;
// png/tiff decoders have serious issues with multiple threads
if (codec_context->codec_id == AV_CODEC_ID_PNG
|| codec_context->codec_id == AV_CODEC_ID_TIFF
|| codec_context->codec_id == AV_CODEC_ID_JPEG2000
|| codec_context->codec_id == AV_CODEC_ID_WEBP)
codec_context->thread_count = 1;
if (demuxer->options.is_hw_decoding) {
AVHWAccel *hwaccel = find_hwaccel_codec(codec_context);
if (hwaccel) {
AVCodec *codec_vda =
avcodec_find_decoder_by_name(hwaccel->name);
if (codec_vda != NULL) {
AVGetFormatCb original_get_format =
codec_context->get_format;
codec_context->get_format = get_hwaccel_format;
codec_context->opaque = hwaccel;
ret = avcodec_open2(codec_context, codec_vda,
&options_dict);
if (ret < 0) {
av_log(NULL, AV_LOG_WARNING,
"no hardware decoder found for"
" codec with id %d",
codec_context->codec_id);
codec_context->get_format =
original_get_format;
codec_context->opaque = NULL;
} else {
codec = codec_vda;
hwaccel_decoder = true;
}
}
}
}
if (codec == NULL) {
codec = avcodec_find_decoder(codec_context->codec_id);
if (codec == NULL) {
av_log(NULL, AV_LOG_WARNING, "no decoder found for"
" codec with id %d",
codec_context->codec_id);
return false;
}
if (avcodec_open2(codec_context, codec, &options_dict) < 0) {
av_log(NULL, AV_LOG_WARNING, "unable to open decoder"
" with codec id %d",
codec_context->codec_id);
return false;
}
}
return initialize_decoder(demuxer, codec_context, stream,
hwaccel_decoder);
}
static int init(sh_audio_t *sh_audio)
{
struct MPOpts *opts = sh_audio->opts;
AVCodecContext *lavc_context;
AVCodec *lavc_codec;
mp_msg(MSGT_DECAUDIO,MSGL_V,"FFmpeg's libavcodec audio codec\n");
lavc_codec = avcodec_find_decoder_by_name(sh_audio->codec->dll);
if(!lavc_codec){
mp_tmsg(MSGT_DECAUDIO,MSGL_ERR,"Cannot find codec '%s' in libavcodec...\n",sh_audio->codec->dll);
return 0;
}
lavc_context = avcodec_alloc_context();
sh_audio->context=lavc_context;
lavc_context->drc_scale = opts->drc_level;
lavc_context->sample_rate = sh_audio->samplerate;
lavc_context->bit_rate = sh_audio->i_bps * 8;
if(sh_audio->wf){
lavc_context->channels = sh_audio->wf->nChannels;
lavc_context->sample_rate = sh_audio->wf->nSamplesPerSec;
lavc_context->bit_rate = sh_audio->wf->nAvgBytesPerSec * 8;
lavc_context->block_align = sh_audio->wf->nBlockAlign;
lavc_context->bits_per_coded_sample = sh_audio->wf->wBitsPerSample;
}
lavc_context->request_channels = opts->audio_output_channels;
lavc_context->codec_tag = sh_audio->format; //FOURCC
lavc_context->codec_type = AVMEDIA_TYPE_AUDIO;
lavc_context->codec_id = lavc_codec->id; // not sure if required, imho not --A'rpi
/* alloc extra data */
if (sh_audio->wf && sh_audio->wf->cbSize > 0) {
lavc_context->extradata = av_mallocz(sh_audio->wf->cbSize + FF_INPUT_BUFFER_PADDING_SIZE);
lavc_context->extradata_size = sh_audio->wf->cbSize;
memcpy(lavc_context->extradata, sh_audio->wf + 1,
lavc_context->extradata_size);
}
// for QDM2
if (sh_audio->codecdata_len && sh_audio->codecdata && !lavc_context->extradata)
{
lavc_context->extradata = av_malloc(sh_audio->codecdata_len +
FF_INPUT_BUFFER_PADDING_SIZE);
lavc_context->extradata_size = sh_audio->codecdata_len;
memcpy(lavc_context->extradata, (char *)sh_audio->codecdata,
lavc_context->extradata_size);
}
/* open it */
if (avcodec_open(lavc_context, lavc_codec) < 0) {
mp_tmsg(MSGT_DECAUDIO,MSGL_ERR, "Could not open codec.\n");
return 0;
}
mp_msg(MSGT_DECAUDIO,MSGL_V,"INFO: libavcodec \"%s\" init OK!\n", lavc_codec->name);
// printf("\nFOURCC: 0x%X\n",sh_audio->format);
if(sh_audio->format==0x3343414D){
// MACE 3:1
sh_audio->ds->ss_div = 2*3; // 1 samples/packet
sh_audio->ds->ss_mul = 2*sh_audio->wf->nChannels; // 1 byte*ch/packet
} else
if(sh_audio->format==0x3643414D){
// MACE 6:1
sh_audio->ds->ss_div = 2*6; // 1 samples/packet
sh_audio->ds->ss_mul = 2*sh_audio->wf->nChannels; // 1 byte*ch/packet
}
// Decode at least 1 byte: (to get header filled)
for (int tries = 0;;) {
int x = decode_audio(sh_audio, sh_audio->a_buffer, 1,
sh_audio->a_buffer_size);
if (x > 0) {
sh_audio->a_buffer_len = x;
break;
}
if (++tries >= 5) {
mp_msg(MSGT_DECAUDIO, MSGL_ERR,
"ad_ffmpeg: initial decode failed\n");
return 0;
}
}
sh_audio->i_bps=lavc_context->bit_rate/8;
if (sh_audio->wf && sh_audio->wf->nAvgBytesPerSec)
sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec;
switch (lavc_context->sample_fmt) {
case SAMPLE_FMT_U8:
case SAMPLE_FMT_S16:
case SAMPLE_FMT_S32:
case SAMPLE_FMT_FLT:
break;
default:
return 0;
}
return 1;
}
/*****************************************************************************
* OpenDecoder: probe the decoder and return score
*****************************************************************************/
static int OpenDecoder( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t*) p_this;
unsigned i_codec_id;
int i_cat, i_result;
const char *psz_namecodec;
AVCodecContext *p_context = NULL;
AVCodec *p_codec = NULL;
/* *** determine codec type *** */
if( !GetFfmpegCodec( p_dec->fmt_in.i_codec, &i_cat, &i_codec_id,
&psz_namecodec ) )
{
return VLC_EGENERIC;
}
/* Initialization must be done before avcodec_find_decoder() */
vlc_init_avcodec(p_this);
/* *** ask ffmpeg for a decoder *** */
char *psz_decoder = var_CreateGetString( p_this, "avcodec-codec" );
if( psz_decoder && *psz_decoder )
{
p_codec = avcodec_find_decoder_by_name( psz_decoder );
if( !p_codec )
msg_Err( p_this, "Decoder `%s' not found", psz_decoder );
else if( p_codec->id != i_codec_id )
{
msg_Err( p_this, "Decoder `%s' can't handle %4.4s",
psz_decoder, (char*)&p_dec->fmt_in.i_codec );
p_codec = NULL;
}
}
free( psz_decoder );
if( !p_codec )
p_codec = avcodec_find_decoder( i_codec_id );
if( !p_codec )
{
msg_Dbg( p_dec, "codec not found (%s)", psz_namecodec );
return VLC_EGENERIC;
}
/* *** get a p_context *** */
p_context = avcodec_alloc_context3(p_codec);
if( !p_context )
return VLC_ENOMEM;
p_context->debug = var_InheritInteger( p_dec, "avcodec-debug" );
p_context->opaque = (void *)p_this;
p_dec->b_need_packetized = true;
switch( i_cat )
{
case VIDEO_ES:
p_dec->pf_decode_video = DecodeVideo;
i_result = InitVideoDec ( p_dec, p_context, p_codec,
i_codec_id, psz_namecodec );
break;
case AUDIO_ES:
p_dec->pf_decode_audio = DecodeAudio;
i_result = InitAudioDec ( p_dec, p_context, p_codec,
i_codec_id, psz_namecodec );
break;
case SPU_ES:
p_dec->pf_decode_sub = DecodeSubtitle;
i_result = InitSubtitleDec( p_dec, p_context, p_codec,
i_codec_id, psz_namecodec );
break;
default:
i_result = VLC_EGENERIC;
}
if( i_result == VLC_SUCCESS )
{
p_dec->p_sys->i_cat = i_cat;
if( p_context->profile != FF_PROFILE_UNKNOWN)
p_dec->fmt_in.i_profile = p_context->profile;
if( p_context->level != FF_LEVEL_UNKNOWN)
p_dec->fmt_in.i_level = p_context->level;
}
return i_result;
}
bool mp_decode_init(mp_media_t *m, enum AVMediaType type, bool hw)
{
struct mp_decode *d = type == AVMEDIA_TYPE_VIDEO ? &m->v : &m->a;
enum AVCodecID id;
AVStream *stream;
int ret;
memset(d, 0, sizeof(*d));
d->m = m;
d->audio = type == AVMEDIA_TYPE_AUDIO;
ret = av_find_best_stream(m->fmt, type, -1, -1, NULL, 0);
if (ret < 0)
return false;
stream = d->stream = m->fmt->streams[ret];
#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 40, 101)
id = stream->codecpar->codec_id;
#else
id = stream->codec->codec_id;
#endif
if (hw) {
d->codec = find_hardware_decoder(id);
if (d->codec) {
ret = mp_open_codec(d);
if (ret < 0)
d->codec = NULL;
}
}
if (!d->codec) {
if (id == AV_CODEC_ID_VP8)
d->codec = avcodec_find_decoder_by_name("libvpx");
else if (id == AV_CODEC_ID_VP9)
d->codec = avcodec_find_decoder_by_name("libvpx-vp9");
if (!d->codec)
d->codec = avcodec_find_decoder(id);
if (!d->codec) {
blog(LOG_WARNING, "MP: Failed to find %s codec",
av_get_media_type_string(type));
return false;
}
ret = mp_open_codec(d);
if (ret < 0) {
blog(LOG_WARNING, "MP: Failed to open %s decoder: %s",
av_get_media_type_string(type),
av_err2str(ret));
return false;
}
}
d->frame = av_frame_alloc();
if (!d->frame) {
blog(LOG_WARNING, "MP: Failed to allocate %s frame",
av_get_media_type_string(type));
return false;
}
if (d->codec->capabilities & AV_CODEC_CAP_TRUNCATED)
d->decoder->flags |= AV_CODEC_FLAG_TRUNCATED;
return true;
}
// init driver
static int init(sh_video_t *sh){
struct lavc_param *lavc_param = &sh->opts->lavc_param;
AVCodecContext *avctx;
vd_ffmpeg_ctx *ctx;
AVCodec *lavc_codec;
int lowres_w=0;
int do_vis_debug= lavc_param->vismv || (lavc_param->debug&(FF_DEBUG_VIS_MB_TYPE|FF_DEBUG_VIS_QP));
if(!avcodec_initialized){
avcodec_init();
avcodec_register_all();
avcodec_initialized=1;
}
ctx = sh->context = malloc(sizeof(vd_ffmpeg_ctx));
if (!ctx)
return 0;
memset(ctx, 0, sizeof(vd_ffmpeg_ctx));
lavc_codec = (AVCodec *)avcodec_find_decoder_by_name(sh->codec->dll);
if(!lavc_codec){
mp_tmsg(MSGT_DECVIDEO, MSGL_ERR, "Cannot find codec '%s' in libavcodec...\n", sh->codec->dll);
uninit(sh);
return 0;
}
if(sh->opts->vd_use_slices && (lavc_codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND) && !do_vis_debug)
ctx->do_slices=1;
if(lavc_codec->capabilities&CODEC_CAP_DR1 && !do_vis_debug && lavc_codec->id != CODEC_ID_H264 && lavc_codec->id != CODEC_ID_INTERPLAY_VIDEO && lavc_codec->id != CODEC_ID_ROQ)
ctx->do_dr1=1;
ctx->b_age= ctx->ip_age[0]= ctx->ip_age[1]= 256*256*256*64;
ctx->ip_count= ctx->b_count= 0;
ctx->pic = avcodec_alloc_frame();
ctx->avctx = avcodec_alloc_context();
avctx = ctx->avctx;
avctx->opaque = sh;
avctx->codec_type = CODEC_TYPE_VIDEO;
avctx->codec_id = lavc_codec->id;
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL // XvMC
|| lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {
ctx->do_dr1 = true;
ctx->do_slices = true;
lavc_param->threads = 1;
avctx->get_format = get_format;
avctx->get_buffer = get_buffer;
avctx->release_buffer = release_buffer;
avctx->reget_buffer = get_buffer;
avctx->draw_horiz_band = draw_slice;
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL)
mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] XVMC-accelerated "
"MPEG-2.\n");
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] VDPAU hardware "
"decoding.\n");
avctx->slice_flags = SLICE_FLAG_CODED_ORDER|SLICE_FLAG_ALLOW_FIELD;
}
if ( lavc_param->threads == 0 ) {
#if defined(_WIN32)
lavc_param->threads = pthread_num_processors_np();
#elif defined(__linux__)
unsigned int bit;
int np;
cpu_set_t p_aff;
memset( &p_aff, 0, sizeof(p_aff) );
sched_getaffinity( 0, sizeof(p_aff), &p_aff );
for( np = 0, bit = 0; bit < sizeof(p_aff); bit++ )
np += (((uint8_t *)&p_aff)[bit / 8] >> (bit % 8)) & 1;
lavc_param->threads = np;
#elif defined(__BEOS__)
system_info info;
get_system_info( &info );
lavc_param->threads = info.cpu_count;
#elif defined(__MACH__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
int numberOfCPUs;
size_t length = sizeof( numberOfCPUs );
#ifdef __OpenBSD__
int mib[2] = { CTL_HW, HW_NCPU };
if( sysctl(mib, 2, &numberOfCPUs, &length, NULL, 0) )
#else
if( sysctlbyname("hw.ncpu", &numberOfCPUs, &length, NULL, 0) )
#endif
{
numberOfCPUs = 1;
}
lavc_param->threads = numberOfCPUs;
#else /* No CPU detection routine available */
lavc_param->threads = 1;
#endif
}
int
vdpau_codec_create(media_codec_t *mc, enum CodecID id,
AVCodecContext *ctx, media_codec_params_t *mcp,
media_pipe_t *mp)
{
VdpDecoderProfile profile;
vdpau_dev_t *vd = mp->mp_vdpau_dev;
VdpStatus r;
int refframes;
if(vd == NULL)
return 1;
if(mcp->width == 0 || mcp->height == 0)
return 1;
switch(id) {
case CODEC_ID_MPEG1VIDEO:
profile = VDP_DECODER_PROFILE_MPEG1;
mc->codec = avcodec_find_decoder_by_name("mpegvideo_vdpau");
refframes = 2;
break;
case CODEC_ID_MPEG2VIDEO:
profile = VDP_DECODER_PROFILE_MPEG2_MAIN;
mc->codec = avcodec_find_decoder_by_name("mpegvideo_vdpau");
refframes = 2;
break;
case CODEC_ID_H264:
profile = VDP_DECODER_PROFILE_H264_HIGH;
mc->codec = avcodec_find_decoder_by_name("h264_vdpau");
refframes = 16;
break;
#if 0 // Seems broken
case CODEC_ID_VC1:
profile = VDP_DECODER_PROFILE_VC1_ADVANCED;
mc->codec = avcodec_find_decoder_by_name("vc1_vdpau");
refframes = 16;
break;
case CODEC_ID_WMV3:
profile = VDP_DECODER_PROFILE_VC1_MAIN;
mc->codec = avcodec_find_decoder_by_name("wmv3_vdpau");
refframes = 16;
break;
#endif
default:
return 1;
}
if(mc->codec == NULL)
return -1;
vdpau_codec_t *vc = calloc(1, sizeof(vdpau_codec_t));
TAILQ_INIT(&vc->vc_vvs_alloc);
TAILQ_INIT(&vc->vc_vvs_free);
vc->vc_vd = vd;
vc->vc_width = mcp->width;
vc->vc_height = mcp->height;
vc->vc_profile = profile;
vc->vc_refframes = refframes;
r = vd->vdp_decoder_create(vd->vd_dev, vc->vc_profile,
vc->vc_width, vc->vc_height,
vc->vc_refframes, &vc->vc_decoder);
if(r != VDP_STATUS_OK) {
TRACE(TRACE_INFO, "VDPAU", "Unable to create decoder: %s",
vdpau_errstr(vd, r));
vc_destroy(vc);
return -1;
}
r = vdpau_create_buffers(vc, vc->vc_width, vc->vc_height,
vc->vc_refframes + 5);
if(r != VDP_STATUS_OK) {
TRACE(TRACE_INFO, "VDPAU", "Unable to allocate decoding buffers");
vc_destroy(vc);
return -1;
}
TRACE(TRACE_DEBUG, "VDPAU", "Decoder initialized");
mc->codec_ctx = ctx ?: avcodec_alloc_context();
mc->codec_ctx->codec_id = mc->codec->id;
mc->codec_ctx->codec_type = mc->codec->type;
if(avcodec_open(mc->codec_ctx, mc->codec) < 0) {
if(ctx == NULL)
free(mc->codec_ctx);
mc->codec = NULL;
vc_destroy(vc);
return -1;
}
mc->codec_ctx->get_buffer = vdpau_get_buffer;
mc->codec_ctx->release_buffer = vdpau_release_buffer;
mc->codec_ctx->draw_horiz_band = vdpau_draw_horiz_band;
mc->codec_ctx->get_format = vdpau_get_pixfmt;
mc->codec_ctx->slice_flags = SLICE_FLAG_CODED_ORDER | SLICE_FLAG_ALLOW_FIELD;
mc->codec_ctx->opaque = mc;
mc->opaque = vc;
mc->decode = vdpau_decode;
mc->close = vdpau_codec_close;
mc->reinit = vdpau_codec_reinit;
return 0;
}
static int init(sh_audio_t *sh_audio)
{
int x;
AVCodecContext *lavc_context;
AVCodec *lavc_codec;
mp_msg(MSGT_DECAUDIO,MSGL_V,"FFmpeg's libavcodec audio codec\n");
if(!avcodec_inited){
avcodec_init();
avcodec_register_all();
avcodec_inited=1;
}
lavc_codec = (AVCodec *)avcodec_find_decoder_by_name(sh_audio->codec->dll);
if(!lavc_codec){
mp_msg(MSGT_DECAUDIO,MSGL_ERR,MSGTR_MissingLAVCcodec,sh_audio->codec->dll);
return 0;
}
lavc_context = avcodec_alloc_context();
sh_audio->context=lavc_context;
if(sh_audio->wf){
lavc_context->channels = sh_audio->wf->nChannels;
lavc_context->sample_rate = sh_audio->wf->nSamplesPerSec;
lavc_context->bit_rate = sh_audio->wf->nAvgBytesPerSec * 8;
lavc_context->block_align = sh_audio->wf->nBlockAlign;
lavc_context->bits_per_sample = sh_audio->wf->wBitsPerSample;
}
lavc_context->codec_tag = sh_audio->format; //FOURCC
lavc_context->codec_id = lavc_codec->id; // not sure if required, imho not --A'rpi
/* alloc extra data */
if (sh_audio->wf && sh_audio->wf->cbSize > 0) {
lavc_context->extradata = av_mallocz(sh_audio->wf->cbSize + FF_INPUT_BUFFER_PADDING_SIZE);
lavc_context->extradata_size = sh_audio->wf->cbSize;
memcpy(lavc_context->extradata, (char *)sh_audio->wf + sizeof(WAVEFORMATEX),
lavc_context->extradata_size);
}
// for QDM2
if (sh_audio->codecdata_len && sh_audio->codecdata && !lavc_context->extradata)
{
lavc_context->extradata = av_malloc(sh_audio->codecdata_len);
lavc_context->extradata_size = sh_audio->codecdata_len;
memcpy(lavc_context->extradata, (char *)sh_audio->codecdata,
lavc_context->extradata_size);
}
/* open it */
if (avcodec_open(lavc_context, lavc_codec) < 0) {
mp_msg(MSGT_DECAUDIO,MSGL_ERR, MSGTR_CantOpenCodec);
return 0;
}
mp_msg(MSGT_DECAUDIO,MSGL_V,"INFO: libavcodec init OK!\n");
// printf("\nFOURCC: 0x%X\n",sh_audio->format);
if(sh_audio->format==0x3343414D){
// MACE 3:1
sh_audio->ds->ss_div = 2*3; // 1 samples/packet
sh_audio->ds->ss_mul = 2*sh_audio->wf->nChannels; // 1 byte*ch/packet
} else
if(sh_audio->format==0x3643414D){
// MACE 6:1
sh_audio->ds->ss_div = 2*6; // 1 samples/packet
sh_audio->ds->ss_mul = 2*sh_audio->wf->nChannels; // 1 byte*ch/packet
}
// Decode at least 1 byte: (to get header filled)
x=decode_audio(sh_audio,sh_audio->a_buffer,1,sh_audio->a_buffer_size);
if(x>0) sh_audio->a_buffer_len=x;
sh_audio->channels=lavc_context->channels;
sh_audio->samplerate=lavc_context->sample_rate;
sh_audio->i_bps=lavc_context->bit_rate/8;
if(sh_audio->wf){
// If the decoder uses the wrong number of channels all is lost anyway.
// sh_audio->channels=sh_audio->wf->nChannels;
if (sh_audio->wf->nSamplesPerSec)
sh_audio->samplerate=sh_audio->wf->nSamplesPerSec;
if (sh_audio->wf->nAvgBytesPerSec)
sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec;
}
sh_audio->samplesize=2;
return 1;
}
