static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats;
enum PixelFormat pix_fmt;
int ret;
/** accept any input pixel format that is not hardware accelerated, not
* a bitstream format, and does not have vertically sub-sampled chroma */
if (ctx->inputs[0]) {
formats = NULL;
for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++)
if (!( av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_HWACCEL
|| av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_BITSTREAM)
&& av_pix_fmt_descriptors[pix_fmt].nb_components
&& !av_pix_fmt_descriptors[pix_fmt].log2_chroma_h
&& (ret = avfilter_add_format(&formats, pix_fmt)) < 0) {
avfilter_formats_unref(&formats);
return ret;
}
avfilter_formats_ref(formats, &ctx->inputs[0]->out_formats);
avfilter_formats_ref(formats, &ctx->outputs[0]->in_formats);
}
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
ABufferSourceContext *abuffer = ctx->priv;
AVFilterFormats *formats;
formats = NULL;
avfilter_add_format(&formats, abuffer->sample_format);
avfilter_set_common_sample_formats(ctx, formats);
formats = NULL;
avfilter_add_format(&formats, abuffer->channel_layout);
avfilter_set_common_channel_layouts(ctx, formats);
formats = NULL;
avfilter_add_format(&formats, abuffer->packing_format);
avfilter_set_common_packing_formats(ctx, formats);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
AConvertContext *aconvert = ctx->priv;
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
avfilter_formats_ref(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO),
&inlink->out_formats);
if (aconvert->out_sample_fmt != AV_SAMPLE_FMT_NONE) {
formats = NULL;
avfilter_add_format(&formats, aconvert->out_sample_fmt);
avfilter_formats_ref(formats, &outlink->in_formats);
} else
avfilter_formats_ref(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO),
&outlink->in_formats);
avfilter_formats_ref(avfilter_make_all_channel_layouts(),
&inlink->out_chlayouts);
if (aconvert->out_chlayout != 0) {
formats = NULL;
avfilter_add_format(&formats, aconvert->out_chlayout);
avfilter_formats_ref(formats, &outlink->in_chlayouts);
} else
avfilter_formats_ref(avfilter_make_all_channel_layouts(),
&outlink->in_chlayouts);
avfilter_formats_ref(avfilter_make_all_packing_formats(),
&inlink->out_packing);
if (aconvert->out_packing_fmt != -1) {
formats = NULL;
avfilter_add_format(&formats, aconvert->out_packing_fmt);
avfilter_formats_ref(formats, &outlink->in_packing);
} else
avfilter_formats_ref(avfilter_make_all_packing_formats(),
&outlink->in_packing);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
Frei0rContext *frei0r = ctx->priv;
AVFilterFormats *formats = NULL;
if (frei0r->plugin_info.color_model == F0R_COLOR_MODEL_BGRA8888) {
avfilter_add_format(&formats, PIX_FMT_BGRA);
} else if (frei0r->plugin_info.color_model == F0R_COLOR_MODEL_RGBA8888) {
avfilter_add_format(&formats, PIX_FMT_RGBA);
} else { /* F0R_COLOR_MODEL_PACKED32 */
static const enum PixelFormat pix_fmts[] = {
PIX_FMT_BGRA, PIX_FMT_ARGB, PIX_FMT_ABGR, PIX_FMT_ARGB, PIX_FMT_NONE
};
formats = avfilter_make_format_list(pix_fmts);
}
if (!formats)
return AVERROR(ENOMEM);
avfilter_set_common_formats(ctx, formats);
return 0;
}
AVFilterFormats *avfilter_all_formats(enum AVMediaType type)
{
AVFilterFormats *ret = NULL;
int fmt;
int num_formats = type == AVMEDIA_TYPE_VIDEO ? PIX_FMT_NB :
type == AVMEDIA_TYPE_AUDIO ? AV_SAMPLE_FMT_NB : 0;
for (fmt = 0; fmt < num_formats; fmt++)
if ((type != AVMEDIA_TYPE_VIDEO) ||
(type == AVMEDIA_TYPE_VIDEO && !(av_pix_fmt_descriptors[fmt].flags & PIX_FMT_HWACCEL)))
avfilter_add_format(&ret, fmt);
return ret;
}
static int query_formats(AVFilterContext *ctx)
{
ABufferSinkContext *abuffersink = ctx->priv;
AVFilterFormats *formats;
int ret;
formats = NULL;
if ((ret = avfilter_add_format(&formats, abuffersink->sample_fmt)) < 0)
return ret;
avfilter_set_common_sample_formats(ctx, formats);
formats = NULL;
if ((ret = avfilter_add_format(&formats, abuffersink->channel_layout)) < 0)
return ret;
avfilter_set_common_channel_layouts(ctx, formats);
formats = NULL;
if ((ret = avfilter_add_format(&formats, abuffersink->planar)) < 0)
return ret;
avfilter_set_common_packing_formats(ctx, formats);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
avfilter_add_format(&formats, AV_SAMPLE_FMT_S16);
if (!formats)
return AVERROR(ENOMEM);
avfilter_set_common_sample_formats(ctx, formats);
formats = avfilter_make_all_channel_layouts();
if (!formats)
return AVERROR(ENOMEM);
avfilter_set_common_channel_layouts(ctx, formats);
formats = avfilter_make_all_packing_formats();
if (!formats)
return AVERROR(ENOMEM);
avfilter_set_common_packing_formats(ctx, formats);
return 0;
}
