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) { 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 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 = 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 asink_query_formats(AVFilterContext *ctx) { BufferSinkContext *buf = ctx->priv; AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layouts = NULL; if (buf->sample_fmts) { if (!(formats = ff_make_format_list(buf->sample_fmts))) return AVERROR(ENOMEM); ff_set_common_formats(ctx, formats); } if (buf->channel_layouts || buf->all_channel_counts) { layouts = buf->all_channel_counts ? ff_all_channel_counts() : avfilter_make_format64_list(buf->channel_layouts); if (!layouts) return AVERROR(ENOMEM); ff_set_common_channel_layouts(ctx, layouts); } if (buf->sample_rates) { formats = ff_make_format_list(buf->sample_rates); if (!formats) return AVERROR(ENOMEM); ff_set_common_samplerates(ctx, 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 query_formats(AVFilterContext *ctx) { LADSPAContext *s = ctx->priv; AVFilterFormats *formats; AVFilterChannelLayouts *layouts; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE }; formats = ff_make_format_list(sample_fmts); if (!formats) return AVERROR(ENOMEM); ff_set_common_formats(ctx, formats); if (s->nb_inputs) { formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); ff_set_common_samplerates(ctx, formats); } else { int sample_rates[] = { s->sample_rate, -1 }; ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates)); } if (s->nb_inputs == 1 && s->nb_outputs == 1) { // We will instantiate multiple LADSPA_Handle, one over each channel layouts = ff_all_channel_layouts(); if (!layouts) return AVERROR(ENOMEM); ff_set_common_channel_layouts(ctx, layouts); } else { AVFilterLink *outlink = ctx->outputs[0]; if (s->nb_inputs >= 1) { AVFilterLink *inlink = ctx->inputs[0]; int64_t inlayout = FF_COUNT2LAYOUT(s->nb_inputs); layouts = NULL; ff_add_channel_layout(&layouts, inlayout); ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts); if (!s->nb_outputs) ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); } if (s->nb_outputs >= 1) { int64_t outlayout = FF_COUNT2LAYOUT(s->nb_outputs); layouts = NULL; ff_add_channel_layout(&layouts, outlayout); ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); } } 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 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) { 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 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 query_formats(AVFilterContext *ctx) { const FadeContext *s = ctx->priv; static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P, 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_NONE }; static const enum AVPixelFormat pix_fmts_rgb[] = { 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_NONE }; static const enum AVPixelFormat pix_fmts_alpha[] = { AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE }; static const enum AVPixelFormat pix_fmts_rgba[] = { AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE }; AVFilterFormats *fmts_list; if (s->alpha) { if (s->black_fade) fmts_list = ff_make_format_list(pix_fmts_alpha); else fmts_list = ff_make_format_list(pix_fmts_rgba); } else { if (s->black_fade) fmts_list = ff_make_format_list(pix_fmts); else fmts_list = ff_make_format_list(pix_fmts_rgb); } if (!fmts_list) return AVERROR(ENOMEM); return ff_set_common_formats(ctx, fmts_list); }
static int ffsink_query_formats(AVFilterContext *ctx) { AVFilterContext *src = ctx; int err; /* Find buffer. */ while (src && src->nb_inputs && src->inputs) { AVFilterLink *link = src->inputs[0]; if (link) src = link->src; else break; } /* Make ffsink output in the format in which buffer inputs. */ if (src) { const int pix_fmts[] = { src->outputs[0]->in_formats->formats[0], -1 }; ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); err = 0; } else err = ff_default_query_formats(ctx); return err; }
static int acompressor_query_formats(AVFilterContext *ctx) { AVFilterFormats *formats; AVFilterChannelLayouts *layouts; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE }; int ret; layouts = ff_all_channel_counts(); if (!layouts) return AVERROR(ENOMEM); ret = ff_set_common_channel_layouts(ctx, layouts); if (ret < 0) return ret; formats = ff_make_format_list(sample_fmts); if (!formats) return AVERROR(ENOMEM); ret = ff_set_common_formats(ctx, formats); if (ret < 0) return ret; formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); return ff_set_common_samplerates(ctx, formats); }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats; AVFilterChannelLayouts *layouts = NULL; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE }; int ret, i; if (!ctx->inputs[0]->in_channel_layouts || !ctx->inputs[0]->in_channel_layouts->nb_channel_layouts) { av_log(ctx, AV_LOG_WARNING, "No channel layout for input 1\n"); return AVERROR(EAGAIN); } if ((ret = ff_add_channel_layout(&layouts, ctx->inputs[0]->in_channel_layouts->channel_layouts[0])) < 0 || (ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) return ret; for (i = 0; i < 2; i++) { layouts = ff_all_channel_counts(); if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->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 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) { static const enum AVPixelFormat pixel_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, AV_PIX_FMT_NONE }; AVFilterFormats *formats = ff_make_format_list(pixel_fmts); if (!formats) return AVERROR(ENOMEM); return ff_set_common_formats(ctx, formats); }
static int query_formats(AVFilterContext *ctx) { static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGB48LE, AV_PIX_FMT_BGR48BE, AV_PIX_FMT_BGR48LE, AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA, AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB565BE, AV_PIX_FMT_RGB565LE, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_RGB555LE, AV_PIX_FMT_BGR565BE, AV_PIX_FMT_BGR565LE, AV_PIX_FMT_BGR555BE, AV_PIX_FMT_BGR555LE, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_YUV420P16LE, AV_PIX_FMT_YUV420P16BE, AV_PIX_FMT_YUV422P16LE, AV_PIX_FMT_YUV422P16BE, AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUV444P16BE, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE, AV_PIX_FMT_PAL8, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE }; ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats; AVFilterChannelLayouts *layouts; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_NONE }; layouts = ff_all_channel_layouts(); if (!layouts) return AVERROR(ENOMEM); ff_set_common_channel_layouts(ctx, layouts); formats = ff_make_format_list(sample_fmts); if (!formats) return AVERROR(ENOMEM); ff_set_common_formats(ctx, formats); formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); ff_set_common_samplerates(ctx, formats); return 0; }
static int query_formats(AVFilterContext *ctx) { static const enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_YUV410P, PIX_FMT_YUV411P, PIX_FMT_YUV440P, PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUVJ440P, AV_NE( PIX_FMT_YUV420P9BE, PIX_FMT_YUV420P9LE ), AV_NE( PIX_FMT_YUV422P9BE, PIX_FMT_YUV422P9LE ), AV_NE( PIX_FMT_YUV444P9BE, PIX_FMT_YUV444P9LE ), AV_NE( PIX_FMT_YUV420P10BE, PIX_FMT_YUV420P10LE ), AV_NE( PIX_FMT_YUV422P10BE, PIX_FMT_YUV422P10LE ), AV_NE( PIX_FMT_YUV444P10BE, PIX_FMT_YUV444P10LE ), PIX_FMT_NONE }; ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); return 0; }
static int query_formats(AVFilterContext *ctx) { enum PixelFormat pix_fmts[] = { PIX_FMT_ARGB, PIX_FMT_RGBA, PIX_FMT_ABGR, PIX_FMT_BGRA, PIX_FMT_RGB24, PIX_FMT_BGR24, PIX_FMT_RGB565BE, PIX_FMT_RGB565LE, PIX_FMT_RGB555BE, PIX_FMT_RGB555LE, PIX_FMT_BGR565BE, PIX_FMT_BGR565LE, PIX_FMT_BGR555BE, PIX_FMT_BGR555LE, PIX_FMT_GRAY16BE, PIX_FMT_GRAY16LE, PIX_FMT_YUV420P16LE, PIX_FMT_YUV420P16BE, PIX_FMT_YUV444P16LE, PIX_FMT_YUV444P16BE, PIX_FMT_NV12, PIX_FMT_NV21, PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_YUV444P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUVJ420P, PIX_FMT_YUV410P, PIX_FMT_YUVA420P, PIX_FMT_GRAY8, PIX_FMT_NONE }; ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layouts = NULL; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE, }; if (ff_add_channel_layout(&layouts, AV_CH_LAYOUT_STEREO) != 0) return AVERROR(ENOMEM); ff_set_common_channel_layouts(ctx, layouts); formats = ff_make_format_list(sample_fmts); if (!formats) return AVERROR(ENOMEM); ff_set_common_formats(ctx, formats); formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); ff_set_common_samplerates(ctx, formats); 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_YUV440P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16, AV_PIX_FMT_NONE }; return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); }
static int query_formats(AVFilterContext *ctx) { MovieContext *movie = ctx->priv; enum AVPixelFormat pix_fmts[] = { movie->codec_ctx->pix_fmt, AV_PIX_FMT_NONE }; ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); return 0; }
static int query_formats(AVFilterContext *ctx) { static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE }; AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts); if (!fmts_list) return AVERROR(ENOMEM); return ff_set_common_formats(ctx, fmts_list); }
static int query_formats(AVFilterContext *ctx) { // this will ensure that formats are the same on all pads AVFilterFormats *fmts_list = ff_make_format_list(formats_supported); if (!fmts_list) return AVERROR(ENOMEM); return ff_set_common_formats(ctx, fmts_list); }