static int hwdownload_query_formats(AVFilterContext *avctx)
{
AVFilterFormats *infmts = NULL;
AVFilterFormats *outfmts = NULL;
const AVPixFmtDescriptor *desc;
int err;
for (desc = av_pix_fmt_desc_next(NULL); desc;
desc = av_pix_fmt_desc_next(desc)) {
if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
err = ff_add_format(&infmts, av_pix_fmt_desc_get_id(desc));
else
err = ff_add_format(&outfmts, av_pix_fmt_desc_get_id(desc));
if (err) {
ff_formats_unref(&infmts);
ff_formats_unref(&outfmts);
return err;
}
}
if ((err = ff_formats_ref(infmts, &avctx->inputs[0]->out_formats)) < 0 ||
(err = ff_formats_ref(outfmts, &avctx->outputs[0]->in_formats)) < 0)
return err;
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AResampleContext *aresample = ctx->priv;
int out_rate = av_get_int(aresample->swr, "osr", NULL);
uint64_t out_layout = av_get_int(aresample->swr, "ocl", NULL);
enum AVSampleFormat out_format = av_get_int(aresample->swr, "osf", NULL);
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
AVFilterFormats *in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
AVFilterFormats *out_formats;
AVFilterFormats *in_samplerates = ff_all_samplerates();
AVFilterFormats *out_samplerates;
AVFilterChannelLayouts *in_layouts = ff_all_channel_layouts();
AVFilterChannelLayouts *out_layouts;
ff_formats_ref (in_formats, &inlink->out_formats);
ff_formats_ref (in_samplerates, &inlink->out_samplerates);
ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts);
if(out_rate > 0) {
out_samplerates = ff_make_format_list((int[]) {
out_rate, -1
});
static int cudaupload_query_formats(AVFilterContext *ctx)
{
int ret;
static const enum AVPixelFormat input_pix_fmts[] = {
AV_PIX_FMT_NV12, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P,
AV_PIX_FMT_P010, AV_PIX_FMT_P016, AV_PIX_FMT_YUV444P16,
AV_PIX_FMT_0RGB32, AV_PIX_FMT_0BGR32,
AV_PIX_FMT_NONE,
};
static const enum AVPixelFormat output_pix_fmts[] = {
AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE,
};
AVFilterFormats *in_fmts = ff_make_format_list(input_pix_fmts);
AVFilterFormats *out_fmts;
ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats);
if (ret < 0)
return ret;
out_fmts = ff_make_format_list(output_pix_fmts);
ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
if (ret < 0)
return ret;
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats;
enum AVPixelFormat 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]) {
const AVPixFmtDescriptor *desc = NULL;
formats = NULL;
while ((desc = av_pix_fmt_desc_next(desc))) {
pix_fmt = av_pix_fmt_desc_get_id(desc);
if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
desc->flags & AV_PIX_FMT_FLAG_PAL ||
desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) &&
desc->nb_components && !desc->log2_chroma_h &&
(ret = ff_add_format(&formats, pix_fmt)) < 0) {
ff_formats_unref(&formats);
return ret;
}
}
ff_formats_ref(formats, &ctx->inputs[0]->out_formats);
ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
}
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat main_fmts[] = {
AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
AV_PIX_FMT_GBRAP,
AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
AV_PIX_FMT_NONE
};
static const enum AVPixelFormat alpha_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
AVFilterFormats *main_formats = NULL, *alpha_formats = NULL;
int ret;
if (!(main_formats = ff_make_format_list(main_fmts)) ||
!(alpha_formats = ff_make_format_list(alpha_fmts))) {
ret = AVERROR(ENOMEM);
goto fail;
}
if ((ret = ff_formats_ref(main_formats , &ctx->inputs[0]->out_formats)) < 0 ||
(ret = ff_formats_ref(alpha_formats, &ctx->inputs[1]->out_formats)) < 0 ||
(ret = ff_formats_ref(main_formats , &ctx->outputs[0]->in_formats)) < 0)
goto fail;
return 0;
fail:
if (main_formats)
av_freep(&main_formats->formats);
av_freep(&main_formats);
if (alpha_formats)
av_freep(&alpha_formats->formats);
av_freep(&alpha_formats);
return ret;
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layouts = NULL;
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
int ret;
formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0)
return ret;
layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0)
return ret;
formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0)
return ret;
formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
return ret;
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];
AVFilterChannelLayouts *layouts;
ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_AUDIO),
&inlink->out_formats);
if (aconvert->out_sample_fmt != AV_SAMPLE_FMT_NONE) {
formats = NULL;
ff_add_format(&formats, aconvert->out_sample_fmt);
ff_formats_ref(formats, &outlink->in_formats);
} else
ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_AUDIO),
&outlink->in_formats);
ff_channel_layouts_ref(ff_all_channel_layouts(),
&inlink->out_channel_layouts);
if (aconvert->out_chlayout != 0) {
layouts = NULL;
ff_add_channel_layout(&layouts, aconvert->out_chlayout);
ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
} else
ff_channel_layouts_ref(ff_all_channel_layouts(),
&outlink->in_channel_layouts);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layout = NULL;
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
formats = ff_make_format_list(sample_fmts);
if (!formats)
return AVERROR(ENOMEM);
ff_formats_ref(formats, &inlink->out_formats);
ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
ff_channel_layouts_ref(layout, &inlink->out_channel_layouts);
formats = ff_all_samplerates();
if (!formats)
return AVERROR(ENOMEM);
ff_formats_ref(formats, &inlink->out_samplerates);
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
ff_formats_ref(formats, &outlink->in_formats);
return 0;
}
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 = ff_add_format(&formats, pix_fmt)) < 0) {
ff_formats_unref(&formats);
return ret;
}
ff_formats_ref(formats, &ctx->inputs[0]->out_formats);
ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
}
return 0;
}
static int hwmap_query_formats(AVFilterContext *avctx)
{
ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
&avctx->inputs[0]->out_formats);
ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
&avctx->outputs[0]->in_formats);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
VectorscopeContext *s = ctx->priv;
const enum AVPixelFormat *out_pix_fmts;
const AVPixFmtDescriptor *desc;
AVFilterFormats *avff;
int depth, rgb, i, ret;
if (!ctx->inputs[0]->in_formats ||
!ctx->inputs[0]->in_formats->nb_formats) {
return AVERROR(EAGAIN);
}
if (!ctx->inputs[0]->out_formats) {
const enum AVPixelFormat *in_pix_fmts;
if ((s->x == 1 && s->y == 2) || (s->x == 2 && s->y == 1))
in_pix_fmts = in2_pix_fmts;
else
in_pix_fmts = in1_pix_fmts;
if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0)
return ret;
}
avff = ctx->inputs[0]->in_formats;
desc = av_pix_fmt_desc_get(avff->formats[0]);
rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
depth = desc->comp[0].depth;
for (i = 1; i < avff->nb_formats; i++) {
desc = av_pix_fmt_desc_get(avff->formats[i]);
if (rgb != (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
depth != desc->comp[0].depth)
return AVERROR(EAGAIN);
}
if (rgb && depth == 8)
out_pix_fmts = out_rgb8_pix_fmts;
else if (rgb && depth == 9)
out_pix_fmts = out_rgb9_pix_fmts;
else if (rgb && depth == 10)
out_pix_fmts = out_rgb10_pix_fmts;
else if (rgb && depth == 12)
out_pix_fmts = out_rgb12_pix_fmts;
else if (depth == 8)
out_pix_fmts = out_yuv8_pix_fmts;
else if (depth == 9)
out_pix_fmts = out_yuv9_pix_fmts;
else if (depth == 10)
out_pix_fmts = out_yuv10_pix_fmts;
else if (depth == 12)
out_pix_fmts = out_yuv12_pix_fmts;
else
return AVERROR(EAGAIN);
if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0)
return ret;
return 0;
}
static int hwmap_query_formats(AVFilterContext *avctx)
{
int ret;
if ((ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
&avctx->inputs[0]->out_formats)) < 0 ||
(ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
&avctx->outputs[0]->in_formats)) < 0)
return ret;
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat in_fmts[] = {
AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
AV_PIX_FMT_NONE
};
static const enum AVPixelFormat out_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
ff_formats_ref(ff_make_format_list(in_fmts), &ctx->inputs[0]->out_formats);
ff_formats_ref(ff_make_format_list(out_fmts), &ctx->outputs[0]->in_formats);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
int ret;
if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0)
return ret;
if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0)
return ret;
return 0;
}
static int scale_vaapi_query_formats(AVFilterContext *avctx)
{
enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_VAAPI, AV_PIX_FMT_NONE,
};
ff_formats_ref(ff_make_format_list(pix_fmts),
&avctx->inputs[0]->out_formats);
ff_formats_ref(ff_make_format_list(pix_fmts),
&avctx->outputs[0]->in_formats);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
const enum PixelFormat inout_pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
const enum PixelFormat blend_pix_fmts[] = { PIX_FMT_YUVA420P, PIX_FMT_NONE };
AVFilterFormats *inout_formats = ff_make_format_list(inout_pix_fmts);
AVFilterFormats *blend_formats = ff_make_format_list(blend_pix_fmts);
ff_formats_ref(inout_formats, &ctx->inputs [MAIN ]->out_formats);
ff_formats_ref(blend_formats, &ctx->inputs [OVERLAY]->out_formats);
ff_formats_ref(inout_formats, &ctx->outputs[MAIN ]->in_formats );
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *avff;
const AVPixFmtDescriptor *desc;
const enum AVPixelFormat *out_pix_fmts;
int rgb, i, bits;
int ret;
if (!ctx->inputs[0]->in_formats ||
!ctx->inputs[0]->in_formats->nb_formats) {
return AVERROR(EAGAIN);
}
if (!ctx->inputs[0]->out_formats)
if ((ret = ff_formats_ref(ff_make_format_list(levels_in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0)
return ret;
avff = ctx->inputs[0]->in_formats;
desc = av_pix_fmt_desc_get(avff->formats[0]);
rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
bits = desc->comp[0].depth;
for (i = 1; i < avff->nb_formats; i++) {
desc = av_pix_fmt_desc_get(avff->formats[i]);
if ((rgb != (desc->flags & AV_PIX_FMT_FLAG_RGB)) ||
(bits != desc->comp[0].depth))
return AVERROR(EAGAIN);
}
if (rgb && bits == 8)
out_pix_fmts = levels_out_rgb8_pix_fmts;
else if (rgb && bits == 9)
out_pix_fmts = levels_out_rgb9_pix_fmts;
else if (rgb && bits == 10)
out_pix_fmts = levels_out_rgb10_pix_fmts;
else if (rgb && bits == 12)
out_pix_fmts = levels_out_rgb12_pix_fmts;
else if (bits == 8)
out_pix_fmts = levels_out_yuv8_pix_fmts;
else if (bits == 9)
out_pix_fmts = levels_out_yuv9_pix_fmts;
else if (bits == 10)
out_pix_fmts = levels_out_yuv10_pix_fmts;
else if (bits == 12)
out_pix_fmts = levels_out_yuv12_pix_fmts;
else
return AVERROR(EAGAIN);
if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0)
return ret;
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_YUVA444P,
AV_PIX_FMT_YUV444P,
AV_PIX_FMT_YUVJ444P,
AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12,
AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV444P16,
AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P16,
AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9,
AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
AV_PIX_FMT_GRAY16,
AV_PIX_FMT_NONE
};
static const enum AVPixelFormat map_fmts[] = {
AV_PIX_FMT_GRAY16,
AV_PIX_FMT_NONE
};
AVFilterFormats *pix_formats = NULL, *map_formats = NULL;
int ret;
if (!(pix_formats = ff_make_format_list(pix_fmts)) ||
!(map_formats = ff_make_format_list(map_fmts))) {
ret = AVERROR(ENOMEM);
goto fail;
}
if ((ret = ff_formats_ref(pix_formats, &ctx->inputs[0]->out_formats)) < 0 ||
(ret = ff_formats_ref(map_formats, &ctx->inputs[1]->out_formats)) < 0 ||
(ret = ff_formats_ref(map_formats, &ctx->inputs[2]->out_formats)) < 0 ||
(ret = ff_formats_ref(pix_formats, &ctx->outputs[0]->in_formats)) < 0)
goto fail;
return 0;
fail:
if (pix_formats)
av_freep(&pix_formats->formats);
av_freep(&pix_formats);
if (map_formats)
av_freep(&map_formats->formats);
av_freep(&map_formats);
return ret;
}
static int query_formats(AVFilterContext *ctx)
{
enum AVPixelFormat main_fmts[] = {
AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
AV_PIX_FMT_NONE
};
enum AVPixelFormat alpha_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
AVFilterFormats *main_formats = ff_make_format_list(main_fmts);
AVFilterFormats *alpha_formats = ff_make_format_list(alpha_fmts);
ff_formats_ref(main_formats, &ctx->inputs[0]->out_formats);
ff_formats_ref(alpha_formats, &ctx->inputs[1]->out_formats);
ff_formats_ref(main_formats, &ctx->outputs[0]->in_formats);
return 0;
}
static int deint_vaapi_query_formats(AVFilterContext *avctx)
{
enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_VAAPI, AV_PIX_FMT_NONE,
};
int err;
if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
&avctx->inputs[0]->out_formats)) < 0)
return err;
if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
&avctx->outputs[0]->in_formats)) < 0)
return err;
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
int i;
AVFilterFormats *formats, *rates;
AVFilterChannelLayouts *layouts;
for (i = 0; i < 2; i++) {
formats = ctx->inputs[i]->in_formats;
ff_formats_ref(formats, &ctx->inputs[i]->out_formats);
ff_formats_ref(formats, &ctx->outputs[i]->in_formats);
rates = ff_all_samplerates();
ff_formats_ref(rates, &ctx->inputs[i]->out_samplerates);
ff_formats_ref(rates, &ctx->outputs[i]->in_samplerates);
layouts = ctx->inputs[i]->in_channel_layouts;
ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts);
}
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
SpectrumSynthContext *s = ctx->priv;
AVFilterFormats *formats = NULL;
AVFilterChannelLayouts *layout = NULL;
AVFilterLink *magnitude = ctx->inputs[0];
AVFilterLink *phase = ctx->inputs[1];
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
AV_PIX_FMT_YUV444P16, AV_PIX_FMT_NONE };
int ret, sample_rates[] = { 48000, -1 };
formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref (formats, &outlink->in_formats )) < 0 ||
(ret = ff_add_channel_layout (&layout, FF_COUNT2LAYOUT(s->channels))) < 0 ||
(ret = ff_channel_layouts_ref (layout , &outlink->in_channel_layouts)) < 0)
return ret;
sample_rates[0] = s->sample_rate;
formats = ff_make_format_list(sample_rates);
if (!formats)
return AVERROR(ENOMEM);
if ((ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
return ret;
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
if ((ret = ff_formats_ref(formats, &magnitude->out_formats)) < 0)
return ret;
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
if ((ret = ff_formats_ref(formats, &phase->out_formats)) < 0)
return ret;
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
VectorscopeContext *s = ctx->priv;
const enum AVPixelFormat *out_pix_fmts;
const AVPixFmtDescriptor *desc;
AVFilterFormats *avff;
int rgb, i;
if (!ctx->inputs[0]->in_formats ||
!ctx->inputs[0]->in_formats->nb_formats) {
return AVERROR(EAGAIN);
}
if (!ctx->inputs[0]->out_formats) {
const enum AVPixelFormat *in_pix_fmts;
if ((s->x == 1 && s->y == 2) || (s->x == 2 && s->y == 1))
in_pix_fmts = in2_pix_fmts;
else
in_pix_fmts = in1_pix_fmts;
ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats);
}
avff = ctx->inputs[0]->in_formats;
desc = av_pix_fmt_desc_get(avff->formats[0]);
rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
for (i = 1; i < avff->nb_formats; i++) {
desc = av_pix_fmt_desc_get(avff->formats[i]);
if (rgb != desc->flags & AV_PIX_FMT_FLAG_RGB)
return AVERROR(EAGAIN);
}
if (rgb)
out_pix_fmts = out_rgb_pix_fmts;
else
out_pix_fmts = out_yuv_pix_fmts;
ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AudioFIRContext *s = ctx->priv;
AVFilterFormats *formats;
AVFilterChannelLayouts *layouts;
static const enum AVSampleFormat sample_fmts[] = {
AV_SAMPLE_FMT_FLTP,
AV_SAMPLE_FMT_NONE
};
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_RGB0,
AV_PIX_FMT_NONE
};
int ret;
if (s->response) {
AVFilterLink *videolink = ctx->outputs[1];
formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0)
return ret;
}
layouts = ff_all_channel_counts();
if (!layouts)
return AVERROR(ENOMEM);
if (s->ir_format) {
ret = ff_set_common_channel_layouts(ctx, layouts);
if (ret < 0)
return ret;
} else {
AVFilterChannelLayouts *mono = NULL;
ret = ff_add_channel_layout(&mono, AV_CH_LAYOUT_MONO);
if (ret)
return ret;
if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts)) < 0)
return ret;
if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0)
return ret;
if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[1]->out_channel_layouts)) < 0)
return ret;
}
formats = ff_make_format_list(sample_fmts);
if ((ret = ff_set_common_formats(ctx, formats)) < 0)
return ret;
formats = ff_all_samplerates();
return ff_set_common_samplerates(ctx, formats);
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
AVFilterFormats *in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
AVFilterFormats *out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
AVFilterFormats *in_samplerates = ff_all_samplerates();
AVFilterFormats *out_samplerates = ff_all_samplerates();
AVFilterChannelLayouts *in_layouts = ff_all_channel_layouts();
AVFilterChannelLayouts *out_layouts = ff_all_channel_layouts();
ff_formats_ref(in_formats, &inlink->out_formats);
ff_formats_ref(out_formats, &outlink->in_formats);
ff_formats_ref(in_samplerates, &inlink->out_samplerates);
ff_formats_ref(out_samplerates, &outlink->in_samplerates);
ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts);
ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
AVFilterLink *outlink = ctx->outputs[0];
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_RGBA,
AV_PIX_FMT_NONE
};
AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
if (!fmts_list)
return AVERROR(ENOMEM);
ff_formats_ref(fmts_list, &outlink->in_formats);
return 0;
}