static struct mp_log *get_av_log(void *ptr)
{
if (!ptr)
return log_root;
AVClass *avc = *(AVClass **)ptr;
if (!avc) {
mp_warn(log_root,
"av_log callback called with bad parameters (NULL AVClass).\n"
"This is a bug in one of Libav/FFmpeg libraries used.\n");
return log_root;
}
if (!strcmp(avc->class_name, "AVCodecContext")) {
AVCodecContext *s = ptr;
if (s->codec) {
if (s->codec->type == AVMEDIA_TYPE_AUDIO) {
if (av_codec_is_decoder(s->codec))
return log_decaudio;
} else if (s->codec->type == AVMEDIA_TYPE_VIDEO) {
if (av_codec_is_decoder(s->codec))
return log_decvideo;
}
}
}
if (!strcmp(avc->class_name, "AVFormatContext")) {
AVFormatContext *s = ptr;
if (s->iformat)
return log_demuxer;
}
return log_root;
}
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
{
AVCodecInternal *avci = avctx->internal;
int ret;
av_frame_unref(frame);
if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
return AVERROR(EINVAL);
ret = bsfs_init(avctx);
if (ret < 0)
return ret;
if (avci->buffer_frame->buf[0]) {
av_frame_move_ref(frame, avci->buffer_frame);
} else {
ret = decode_receive_frame_internal(avctx, frame);
if (ret < 0)
return ret;
}
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
ret = apply_cropping(avctx, frame);
if (ret < 0) {
av_frame_unref(frame);
return ret;
}
}
avctx->frame_number++;
return 0;
}
CCodecIds(void)
{
// get ids and names
AVCodec* codec = NULL;
xbmc_codec_t tmp;
while ((codec = av_codec_next(codec)))
{
if (av_codec_is_decoder(codec))
{
tmp.codec_type = (xbmc_codec_type_t)codec->type;
tmp.codec_id = codec->id;
std::string strUpperCodecName = codec->name;
StringUtils::ToUpper(strUpperCodecName);
m_lookup.insert(std::make_pair(strUpperCodecName, tmp));
}
}
// teletext is not returned by av_codec_next. we got our own decoder
tmp.codec_type = XBMC_CODEC_TYPE_SUBTITLE;
tmp.codec_id = AV_CODEC_ID_DVB_TELETEXT;
m_lookup.insert(std::make_pair("TELETEXT", tmp));
// rds is not returned by av_codec_next. we got our own decoder
tmp.codec_type = XBMC_CODEC_TYPE_RDS;
tmp.codec_id = AV_CODEC_ID_NONE;
m_lookup.insert(std::make_pair("RDS", tmp));
}
static const AVCodec *next_codec_for_id(enum AVCodecID id, const AVCodec *prev,
int encoder)
{
while ((prev = av_codec_next(prev))) {
if (prev->id == id &&
(encoder ? av_codec_is_encoder(prev) : av_codec_is_decoder(prev)))
return prev;
}
return NULL;
}
void mp_add_lavc_decoders(struct mp_decoder_list *list, enum AVMediaType type)
{
AVCodec *cur = NULL;
for (;;) {
cur = av_codec_next(cur);
if (!cur)
break;
if (av_codec_is_decoder(cur) && cur->type == type && !is_crap(cur)) {
mp_add_decoder(list, "lavc", mp_codec_from_av_codec_id(cur->id),
cur->name, cur->long_name);
}
}
}
static inline int v4l2_get_framesize_compressed(V4L2Context* ctx, int width, int height)
{
V4L2m2mContext *s = ctx_to_m2mctx(ctx);
const int SZ_4K = 0x1000;
int size;
if (av_codec_is_decoder(s->avctx->codec))
return ((width * height * 3 / 2) / 2) + 128;
/* encoder */
size = FFALIGN(height, 32) * FFALIGN(width, 32) * 3 / 2 / 2;
return FFALIGN(size, SZ_4K);
}
QStringList AudioDecoder::supportedCodecs()
{
static QStringList codecs;
if (!codecs.isEmpty())
return codecs;
avcodec_register_all();
AVCodec* c = NULL;
while ((c=av_codec_next(c))) {
if (!av_codec_is_decoder(c) || c->type != AVMEDIA_TYPE_AUDIO)
continue;
codecs.append(QString::fromLatin1(c->name));
}
return codecs;
}
static void add_codecs(struct mp_decoder_list *list, enum AVMediaType type,
bool decoders)
{
void *iter = NULL;
for (;;) {
const AVCodec *cur = av_codec_iterate(&iter);
if (!cur)
break;
if (av_codec_is_decoder(cur) == decoders &&
(type == AVMEDIA_TYPE_UNKNOWN || cur->type == type))
{
mp_add_decoder(list, mp_codec_from_av_codec_id(cur->id),
cur->name, cur->long_name);
}
}
}
static const AVCodec* FindDecoder(CDVDStreamInfo& hints)
{
const AVCodec* codec = nullptr;
void *i = 0;
while ((codec = av_codec_iterate(&i)))
{
if (!av_codec_is_decoder(codec))
continue;
if (codec->id != hints.codec)
continue;
const AVCodecHWConfig* config = FindHWConfig(codec);
if (config)
return codec;
}
return nullptr;
}
int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
{
AVCodecInternal *avci = avctx->internal;
int ret = 0;
if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
return AVERROR(EINVAL);
if (avctx->internal->draining)
return AVERROR_EOF;
ret = bsfs_init(avctx);
if (ret < 0)
return ret;
av_packet_unref(avci->buffer_pkt);
if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
ret = av_packet_ref(avci->buffer_pkt, avpkt);
if (ret < 0)
return ret;
}
ret = av_bsf_send_packet(avci->filter.bsfs[0], avci->buffer_pkt);
if (ret < 0) {
av_packet_unref(avci->buffer_pkt);
return ret;
}
if (!avci->buffer_frame->buf[0]) {
ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
return ret;
}
return 0;
}
gboolean
gst_ffmpegauddec_register (GstPlugin * plugin)
{
GTypeInfo typeinfo = {
sizeof (GstFFMpegAudDecClass),
(GBaseInitFunc) gst_ffmpegauddec_base_init,
NULL,
(GClassInitFunc) gst_ffmpegauddec_class_init,
NULL,
NULL,
sizeof (GstFFMpegAudDec),
0,
(GInstanceInitFunc) gst_ffmpegauddec_init,
};
GType type;
AVCodec *in_plugin;
gint rank;
in_plugin = av_codec_next (NULL);
GST_LOG ("Registering decoders");
while (in_plugin) {
gchar *type_name;
/* only decoders */
if (!av_codec_is_decoder (in_plugin)
|| in_plugin->type != AVMEDIA_TYPE_AUDIO) {
goto next;
}
/* no quasi codecs, please */
if (in_plugin->id == AV_CODEC_ID_PCM_S16LE_PLANAR ||
(in_plugin->id >= AV_CODEC_ID_PCM_S16LE &&
in_plugin->id <= AV_CODEC_ID_PCM_BLURAY) ||
(in_plugin->id >= AV_CODEC_ID_PCM_S8_PLANAR &&
#if AV_VERSION_INT (LIBAVCODEC_VERSION_MAJOR, LIBAVCODEC_VERSION_MINOR, LIBAVCODEC_VERSION_MICRO) >= AV_VERSION_INT (57,54,0)
in_plugin->id <= AV_CODEC_ID_PCM_S64BE)) {
#else
in_plugin->id <= AV_CODEC_ID_PCM_S16BE_PLANAR)) {
#endif
goto next;
}
/* No decoders depending on external libraries (we don't build them, but
* people who build against an external ffmpeg might have them.
* We have native gstreamer plugins for all of those libraries anyway. */
if (!strncmp (in_plugin->name, "lib", 3)) {
GST_DEBUG
("Not using external library decoder %s. Use the gstreamer-native ones instead.",
in_plugin->name);
goto next;
}
GST_DEBUG ("Trying plugin %s [%s]", in_plugin->name, in_plugin->long_name);
/* no codecs for which we're GUARANTEED to have better alternatives */
/* MP1 : Use MP3 for decoding */
/* MP2 : Use MP3 for decoding */
/* Theora: Use libtheora based theoradec */
if (!strcmp (in_plugin->name, "vorbis") ||
!strcmp (in_plugin->name, "wavpack") ||
!strcmp (in_plugin->name, "mp1") ||
!strcmp (in_plugin->name, "mp2") ||
!strcmp (in_plugin->name, "libfaad") ||
!strcmp (in_plugin->name, "mpeg4aac") ||
!strcmp (in_plugin->name, "ass") ||
!strcmp (in_plugin->name, "srt") ||
!strcmp (in_plugin->name, "pgssub") ||
!strcmp (in_plugin->name, "dvdsub") ||
!strcmp (in_plugin->name, "dvbsub")) {
GST_LOG ("Ignoring decoder %s", in_plugin->name);
goto next;
}
/* construct the type */
type_name = g_strdup_printf ("avdec_%s", in_plugin->name);
g_strdelimit (type_name, ".,|-<> ", '_');
type = g_type_from_name (type_name);
if (!type) {
/* create the gtype now */
type =
g_type_register_static (GST_TYPE_AUDIO_DECODER, type_name, &typeinfo,
0);
g_type_set_qdata (type, GST_FFDEC_PARAMS_QDATA, (gpointer) in_plugin);
}
/* (Ronald) MPEG-4 gets a higher priority because it has been well-
* tested and by far outperforms divxdec/xviddec - so we prefer it.
* msmpeg4v3 same, as it outperforms divxdec for divx3 playback.
* VC1/WMV3 are not working and thus unpreferred for now. */
switch (in_plugin->id) {
case AV_CODEC_ID_RA_144:
case AV_CODEC_ID_RA_288:
case AV_CODEC_ID_COOK:
case AV_CODEC_ID_AAC:
rank = GST_RANK_PRIMARY;
break;
/* SIPR: decoder should have a higher rank than realaudiodec.
*/
case AV_CODEC_ID_SIPR:
rank = GST_RANK_SECONDARY;
break;
default:
rank = GST_RANK_MARGINAL;
break;
}
if (!gst_element_register (plugin, type_name, rank, type)) {
g_warning ("Failed to register %s", type_name);
g_free (type_name);
return FALSE;
}
g_free (type_name);
next:
in_plugin = av_codec_next (in_plugin);
}
GST_LOG ("Finished Registering decoders");
return TRUE;
}
std::vector<codecinfo> codec::listCodecs()
{
//assert(ffmpeg::InstanceCount() > 0 && "ffmpeg not initialized, at least one live instance must exist");
std::vector<codecinfo> outputCodecList;
AVCodec * ccodec = NULL;
while ((ccodec = av_codec_next(ccodec)) != NULL){
codecinfo c;
c.isEncoder = (av_codec_is_encoder(ccodec) != 0) ? true : false;
c.isDecoder = (av_codec_is_decoder(ccodec) != 0) ? true : false;
c.name = ccodec->name;
if (ccodec->long_name != NULL){
c.long_name = ccodec->long_name;
}
c.mediaType = conversion::convertFrom(ccodec->type);
c.capabilities = (codec_capabilities)ccodec->capabilities;
const AVRational *sfr = ccodec->supported_framerates;
while (sfr != NULL && sfr->num != 0 && sfr->den != 0)
{
c.frameRates.push_back(rational(sfr->num, sfr->den));
sfr++;
}
const AVPixelFormat *pf = ccodec->pix_fmts;
while (pf != NULL && *pf != -1)
{
c.pixelFormats.push_back(conversion::convertFrom(*pf));
pf++;
}
const int *sr = ccodec->supported_samplerates;
while (sr != NULL && *sr != 0)
{
c.sampleRates.push_back(*sr);
sr++;
}
const AVSampleFormat *sf = ccodec->sample_fmts;
while (sf != NULL && *sf != -1)
{
c.sampleFormats.push_back(conversion::convertFrom(*sf));
sf++;
}
const uint64_t *cl = ccodec->channel_layouts;
while (cl != NULL && *cl != 0)
{
c.channelLayouts.push_back((channel_layout)*cl);
cl++;
}
c.max_lowres = ccodec->max_lowres;
//av_codec_get_lowres() - receives codec ctx!!
const AVProfile * pr = ccodec->profiles;
while (pr != NULL && pr->profile != FF_PROFILE_UNKNOWN)
{
c.profiles.push_back(codec_profile(pr->profile, pr->name));
pr++;
}
outputCodecList.push_back(c);
}
return outputCodecList;
}
