Merge commit '7bc1a883c9158bb6e383d86fc76bdf2541e9a9fe'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Apr 2013 01:10:43 +0000 (03:10 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 11 Apr 2013 01:10:43 +0000 (03:10 +0200)
* commit '7bc1a883c9158bb6e383d86fc76bdf2541e9a9fe':
  vsrc_color: switch to an AVOptions-based system.

Conflicts:
doc/filters.texi
libavfilter/vsrc_color.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavfilter/avfilter.c
libavfilter/vsrc_testsrc.c

@@@ -655,104 -479,8 +655,105 @@@ int avfilter_init_filter(AVFilterContex
      AVDictionary *options = NULL;
      AVDictionaryEntry *e;
      int ret=0;
 +    int anton_options =
 +        !strcmp(filter->filter->name,  "allpass"   ) ||
 +        !strcmp(filter->filter->name,  "afade"     ) ||
 +        !strcmp(filter->filter->name,  "aformat") ||
 +        !strcmp(filter->filter->name,  "amix"      ) ||
 +        !strcmp(filter->filter->name,  "apad"      ) ||
 +        !strcmp(filter->filter->name,  "aphaser"   ) ||
 +        !strcmp(filter->filter->name,  "asplit"    ) ||
 +        !strcmp(filter->filter->name,  "ass")     ||
 +        !strcmp(filter->filter->name,  "asyncts"   ) ||
 +        !strcmp(filter->filter->name,  "bandpass"  ) ||
 +        !strcmp(filter->filter->name,  "bandreject") ||
 +        !strcmp(filter->filter->name,  "bass"      ) ||
 +        !strcmp(filter->filter->name,  "biquad"    ) ||
 +        !strcmp(filter->filter->name,  "blackframe") ||
 +        !strcmp(filter->filter->name,  "blend"     ) ||
 +        !strcmp(filter->filter->name,  "boxblur"   ) ||
 +        !strcmp(filter->filter->name,  "cellauto") ||
 +        !strcmp(filter->filter->name,  "channelmap") ||
 +        !strcmp(filter->filter->name,  "channelsplit") ||
++        !strcmp(filter->filter->name,  "color"     ) ||
 +        !strcmp(filter->filter->name,  "colormatrix") ||
 +        !strcmp(filter->filter->name,  "crop"      ) ||
 +        !strcmp(filter->filter->name,  "cropdetect") ||
 +        !strcmp(filter->filter->name,  "curves"    ) ||
 +        !strcmp(filter->filter->name,  "decimate"  ) ||
 +        !strcmp(filter->filter->name,  "delogo"    ) ||
 +        !strcmp(filter->filter->name,  "drawbox"   ) ||
 +        !strcmp(filter->filter->name,  "drawtext"  ) ||
 +        !strcmp(filter->filter->name,  "ebur128"   ) ||
 +        !strcmp(filter->filter->name,  "edgedetect") ||
 +        !strcmp(filter->filter->name,  "equalizer" ) ||
 +        !strcmp(filter->filter->name,  "fade"      ) ||
 +        !strcmp(filter->filter->name,  "field"     ) ||
 +        !strcmp(filter->filter->name,  "fieldorder") ||
 +        !strcmp(filter->filter->name,  "fps"       ) ||
 +        !strcmp(filter->filter->name,  "framestep" ) ||
 +        !strcmp(filter->filter->name,  "frei0r"    ) ||
 +        !strcmp(filter->filter->name,  "frei0r_src") ||
 +        !strcmp(filter->filter->name,  "geq"       ) ||
 +        !strcmp(filter->filter->name, "gradfun"    ) ||
 +        !strcmp(filter->filter->name, "highpass"  ) ||
 +        !strcmp(filter->filter->name, "histeq"     ) ||
 +        !strcmp(filter->filter->name, "histogram"  ) ||
 +        !strcmp(filter->filter->name, "hqdn3d"     ) ||
 +        !strcmp(filter->filter->name, "idet"       ) ||
 +        !strcmp(filter->filter->name,  "il"        ) ||
 +        !strcmp(filter->filter->name,  "join"      ) ||
 +        !strcmp(filter->filter->name,  "kerndeint" ) ||
 +        !strcmp(filter->filter->name, "ocv"        ) ||
 +        !strcmp(filter->filter->name, "life"       ) ||
 +        !strcmp(filter->filter->name, "lut"        ) ||
 +        !strcmp(filter->filter->name, "lutyuv"     ) ||
 +        !strcmp(filter->filter->name, "lutrgb"     ) ||
 +        !strcmp(filter->filter->name, "lowpass"   ) ||
 +        !strcmp(filter->filter->name, "mandelbrot" ) ||
 +        !strcmp(filter->filter->name, "mptestsrc"  ) ||
 +        !strcmp(filter->filter->name, "negate"     ) ||
 +        !strcmp(filter->filter->name, "noise"      ) ||
 +        !strcmp(filter->filter->name, "overlay"    ) ||
 +        !strcmp(filter->filter->name, "pad"        ) ||
 +        !strcmp(filter->filter->name,   "format") ||
 +        !strcmp(filter->filter->name, "noformat") ||
 +        !strcmp(filter->filter->name, "perms")  ||
 +        !strcmp(filter->filter->name, "pp"   )  ||
 +        !strcmp(filter->filter->name, "aperms") ||
 +        !strcmp(filter->filter->name, "resample") ||
 +        !strcmp(filter->filter->name, "setpts"       ) ||
 +        !strcmp(filter->filter->name, "settb"        ) ||
 +        !strcmp(filter->filter->name, "showspectrum") ||
 +        !strcmp(filter->filter->name, "silencedetect") ||
 +        !strcmp(filter->filter->name, "smartblur") ||
 +        !strcmp(filter->filter->name, "split"    ) ||
 +        !strcmp(filter->filter->name, "stereo3d" ) ||
 +        !strcmp(filter->filter->name, "subtitles") ||
 +        !strcmp(filter->filter->name, "thumbnail") ||
 +        !strcmp(filter->filter->name, "transpose") ||
 +        !strcmp(filter->filter->name, "treble"    ) ||
 +        !strcmp(filter->filter->name, "unsharp"  ) ||
 +//         !strcmp(filter->filter->name, "scale"      ) ||
 +        !strcmp(filter->filter->name, "select") ||
 +        !strcmp(filter->filter->name, "volume"   ) ||
 +        !strcmp(filter->filter->name, "yadif"    ) ||
 +        0
 +        ;
 +
 +    if (filter->filter->shorthand) {
 +        av_assert0(filter->priv);
 +        av_assert0(filter->filter->priv_class);
 +        *(const AVClass **)filter->priv = filter->filter->priv_class;
 +        av_opt_set_defaults(filter->priv);
 +        ret = av_opt_set_from_string(filter->priv, args,
 +                                     filter->filter->shorthand, "=", ":");
 +        if (ret < 0)
 +            return ret;
 +        args = NULL;
 +    }
  
 -    if (args && *args && filter->filter->priv_class) {
 +    if (anton_options && args && *args && filter->filter->priv_class) {
  #if FF_API_OLD_FILTER_OPTS
          if (!strcmp(filter->filter->name, "scale") &&
              strchr(args, ':') < strchr(args, '=')) {
@@@ -73,41 -60,33 +73,48 @@@ typedef struct 
  } TestSourceContext;
  
  #define OFFSET(x) offsetof(TestSourceContext, x)
- static const AVOption options[] = {
-     { "size",     "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },
-     { "s",        "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },
-     { "rate",     "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },
-     { "r",        "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },
-     { "duration", "set video duration", OFFSET(duration_str), AV_OPT_TYPE_STRING, {.str = NULL},   0, 0, FLAGS },
-     { "d",        "set video duration", OFFSET(duration_str), AV_OPT_TYPE_STRING, {.str = NULL},   0, 0, FLAGS },
 +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
-     { "color", "set color", OFFSET(color_str), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS },
-     { "c",     "set color", OFFSET(color_str), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS },
++#define COMMON_OPTIONS \
++    { "size",     "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
++    { "s",        "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
++    { "rate",     "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },\
++    { "r",        "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },\
++    { "duration", "set video duration", OFFSET(duration_str), AV_OPT_TYPE_STRING, {.str = NULL},   0, 0, FLAGS },\
++    { "d",        "set video duration", OFFSET(duration_str), AV_OPT_TYPE_STRING, {.str = NULL},   0, 0, FLAGS },\
 +    { "sar",      "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl= 1},  0, INT_MAX, FLAGS },
 +
++
++static const AVOption color_options[] = {
 +    /* only used by color */
 -static const AVOption testsrc_options[] = {
 -    { "size",     "set video size",     OFFSET(size),     AV_OPT_TYPE_STRING, {.str = "320x240"}},
 -    { "s",        "set video size",     OFFSET(size),     AV_OPT_TYPE_STRING, {.str = "320x240"}},
 -    { "rate",     "set video rate",     OFFSET(rate),     AV_OPT_TYPE_STRING, {.str = "25"},    },
 -    { "r",        "set video rate",     OFFSET(rate),     AV_OPT_TYPE_STRING, {.str = "25"},    },
 -    { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_STRING, {.str = NULL},    },
 -    { "sar",      "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl = 1},  0, INT_MAX },
++    { "color", "set color", OFFSET(color_str), AV_OPT_TYPE_STRING, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS },
++    { "c",     "set color", OFFSET(color_str), AV_OPT_TYPE_STRING, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS },
 +
++    COMMON_OPTIONS
++    { NULL },
++};
++
++static const AVOption options[] = {
 +    /* only used by testsrc */
 +    { "decimals", "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0},  0, 17, FLAGS },
 +    { "n",        "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0},  0, 17, FLAGS },
++    COMMON_OPTIONS
      { NULL },
  };
  
 -static av_cold int init_common(AVFilterContext *ctx, const char *args)
 +static av_cold int init(AVFilterContext *ctx, const char *args)
  {
      TestSourceContext *test = ctx->priv;
 -    AVRational frame_rate_q;
 -    int64_t duration = -1;
      int ret = 0;
  
--    av_opt_set_defaults(test);
--
 -    if ((ret = (av_set_options_string(test, args, "=", ":"))) < 0) {
 -        av_log(ctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
 +    if ((ret = (av_set_options_string(test, args, "=", ":"))) < 0)
          return ret;
 -    }
  
 -    if ((ret = av_parse_video_size(&test->w, &test->h, test->size)) < 0) {
 -        av_log(ctx, AV_LOG_ERROR, "Invalid frame size: '%s'\n", test->size);
 +    test->duration = -1;
 +    if (test->duration_str &&
 +        (ret = av_parse_time(&test->duration, test->duration_str, 1)) < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Invalid duration: '%s'\n", test->duration_str);
          return ret;
      }
  
@@@ -198,127 -149,19 +205,125 @@@ static int request_frame(AVFilterLink *
      return ff_filter_frame(outlink, frame);
  }
  
 -#if CONFIG_TESTSRC_FILTER
 +#if CONFIG_COLOR_FILTER
 +
- #define color_options options
 +AVFILTER_DEFINE_CLASS(color);
  
 -static const char *testsrc_get_name(void *ctx)
 +static void color_fill_picture(AVFilterContext *ctx, AVFrame *picref)
  {
 -    return "testsrc";
 +    TestSourceContext *test = ctx->priv;
 +    ff_fill_rectangle(&test->draw, &test->color,
 +                      picref->data, picref->linesize,
 +                      0, 0, test->w, test->h);
 +}
 +
 +static av_cold int color_init(AVFilterContext *ctx, const char *args)
 +{
 +    TestSourceContext *test = ctx->priv;
-     test->class = &color_class;
 +    test->fill_picture_fn = color_fill_picture;
 +    test->draw_once = 1;
-     av_opt_set(test, "color", "black", 0);
-     return init(ctx, args);
++    return init(ctx, NULL);
 +}
 +
 +static int color_query_formats(AVFilterContext *ctx)
 +{
 +    ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
 +    return 0;
  }
  
 -static const AVClass testsrc_class = {
 -    .class_name = "TestSourceContext",
 -    .item_name  = testsrc_get_name,
 -    .option     = testsrc_options,
 +static int color_config_props(AVFilterLink *inlink)
 +{
 +    AVFilterContext *ctx = inlink->src;
 +    TestSourceContext *test = ctx->priv;
 +    int ret;
 +
 +    ff_draw_init(&test->draw, inlink->format, 0);
 +    ff_draw_color(&test->draw, &test->color, test->color_rgba);
 +
 +    test->w = ff_draw_round_to_sub(&test->draw, 0, -1, test->w);
 +    test->h = ff_draw_round_to_sub(&test->draw, 1, -1, test->h);
 +    if (av_image_check_size(test->w, test->h, 0, ctx) < 0)
 +        return AVERROR(EINVAL);
 +
 +    if ((ret = config_props(inlink)) < 0)
 +        return ret;
 +
 +    av_log(ctx, AV_LOG_VERBOSE, "color:0x%02x%02x%02x%02x\n",
 +           test->color_rgba[0], test->color_rgba[1], test->color_rgba[2], test->color_rgba[3]);
 +    return 0;
 +}
 +
 +static const AVFilterPad color_outputs[] = {
 +    {
 +        .name          = "default",
 +        .type          = AVMEDIA_TYPE_VIDEO,
 +        .request_frame = request_frame,
 +        .config_props  = color_config_props,
 +    },
 +    {  NULL }
 +};
 +
 +AVFilter avfilter_vsrc_color = {
 +    .name        = "color",
 +    .description = NULL_IF_CONFIG_SMALL("Provide an uniformly colored input."),
 +
++    .priv_class = &color_class,
 +    .priv_size = sizeof(TestSourceContext),
 +    .init      = color_init,
 +    .uninit    = uninit,
 +
 +    .query_formats = color_query_formats,
 +    .inputs        = NULL,
 +    .outputs       = color_outputs,
-     .priv_class    = &color_class,
 +};
 +
 +#endif /* CONFIG_COLOR_FILTER */
 +
 +#if CONFIG_NULLSRC_FILTER
 +
 +#define nullsrc_options options
 +AVFILTER_DEFINE_CLASS(nullsrc);
 +
 +static void nullsrc_fill_picture(AVFilterContext *ctx, AVFrame *picref) { }
 +
 +static av_cold int nullsrc_init(AVFilterContext *ctx, const char *args)
 +{
 +    TestSourceContext *test = ctx->priv;
 +
 +    test->class = &nullsrc_class;
 +    test->fill_picture_fn = nullsrc_fill_picture;
++    av_opt_set_defaults(test);
 +    return init(ctx, args);
 +}
 +
 +static const AVFilterPad nullsrc_outputs[] = {
 +    {
 +        .name          = "default",
 +        .type          = AVMEDIA_TYPE_VIDEO,
 +        .request_frame = request_frame,
 +        .config_props  = config_props,
 +    },
 +    { NULL },
 +};
 +
 +AVFilter avfilter_vsrc_nullsrc = {
 +    .name        = "nullsrc",
 +    .description = NULL_IF_CONFIG_SMALL("Null video source, return unprocessed video frames."),
 +    .init       = nullsrc_init,
 +    .uninit     = uninit,
 +    .priv_size  = sizeof(TestSourceContext),
 +    .inputs     = NULL,
 +    .outputs    = nullsrc_outputs,
 +    .priv_class = &nullsrc_class,
  };
  
 +#endif /* CONFIG_NULLSRC_FILTER */
 +
 +#if CONFIG_TESTSRC_FILTER
 +
 +#define testsrc_options options
 +AVFILTER_DEFINE_CLASS(testsrc);
 +
  /**
   * Fill a rectangle with value val.
   *
@@@ -507,7 -340,7 +512,8 @@@ static av_cold int test_init(AVFilterCo
  
      test->class = &testsrc_class;
      test->fill_picture_fn = test_fill_picture;
 -    return init_common(ctx, args);
++    av_opt_set_defaults(test);
 +    return init(ctx, args);
  }
  
  static int test_query_formats(AVFilterContext *ctx)
@@@ -610,10 -450,9 +616,11 @@@ static av_cold int rgbtest_init(AVFilte
  {
      TestSourceContext *test = ctx->priv;
  
 +    test->draw_once = 1;
      test->class = &rgbtestsrc_class;
      test->fill_picture_fn = rgbtest_fill_picture;
 -    return init_common(ctx, args);
++    av_opt_set_defaults(test);
 +    return init(ctx, args);
  }
  
  static int rgbtest_query_formats(AVFilterContext *ctx)
@@@ -664,146 -509,3 +671,147 @@@ AVFilter avfilter_vsrc_rgbtestsrc = 
  };
  
  #endif /* CONFIG_RGBTESTSRC_FILTER */
 +
 +#if CONFIG_SMPTEBARS_FILTER
 +
 +#define smptebars_options options
 +AVFILTER_DEFINE_CLASS(smptebars);
 +
 +static const uint8_t rainbow[7][4] = {
 +    { 191, 191, 191, 255 },     /* gray */
 +    { 191, 191,   0, 255 },     /* yellow */
 +    {   0, 191, 191, 255 },     /* cyan */
 +    {   0, 191,   0, 255 },     /* green */
 +    { 191,   0, 191, 255 },     /* magenta */
 +    { 191,   0,   0, 255 },     /* red */
 +    {   0,   0, 191, 255 },     /* blue */
 +};
 +
 +static const uint8_t wobnair[7][4] = {
 +    {   0,   0, 191, 255 },     /* blue */
 +    {  19,  19,  19, 255 },     /* 7.5% intensity black */
 +    { 191,   0, 191, 255 },     /* magenta */
 +    {  19,  19,  19, 255 },     /* 7.5% intensity black */
 +    {   0, 191, 191, 255 },     /* cyan */
 +    {  19,  19,  19, 255 },     /* 7.5% intensity black */
 +    { 191, 191, 191, 255 },     /* gray */
 +};
 +
 +static const uint8_t white[4] = { 255, 255, 255, 255 };
 +static const uint8_t black[4] = {  19,  19,  19, 255 }; /* 7.5% intensity black */
 +
 +/* pluge pulses */
 +static const uint8_t neg4ire[4] = {   9,   9,   9, 255 }; /*  3.5% intensity black */
 +static const uint8_t pos4ire[4] = {  29,  29,  29, 255 }; /* 11.5% intensity black */
 +
 +/* fudged Q/-I */
 +static const uint8_t i_pixel[4] = {   0,  68, 130, 255 };
 +static const uint8_t q_pixel[4] = {  67,   0, 130, 255 };
 +
 +static void inline draw_bar(TestSourceContext *test, const uint8_t *color,
 +                            unsigned x, unsigned y, unsigned w, unsigned h,
 +                            AVFrame *frame)
 +{
 +    FFDrawColor draw_color;
 +
 +    x = FFMIN(x, test->w - 1);
 +    y = FFMIN(y, test->h - 1);
 +    w = FFMIN(w, test->w - x);
 +    h = FFMIN(h, test->h - y);
 +
 +    av_assert0(x + w <= test->w);
 +    av_assert0(y + h <= test->h);
 +
 +    ff_draw_color(&test->draw, &draw_color, color);
 +    ff_fill_rectangle(&test->draw, &draw_color,
 +                      frame->data, frame->linesize, x, y, w, h);
 +}
 +
 +static void smptebars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
 +{
 +    TestSourceContext *test = ctx->priv;
 +    int r_w, r_h, w_h, p_w, p_h, i, tmp, x = 0;
 +    const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
 +
 +    r_w = FFALIGN((test->w + 6) / 7, 1 << pixdesc->log2_chroma_w);
 +    r_h = FFALIGN(test->h * 2 / 3, 1 << pixdesc->log2_chroma_h);
 +    w_h = FFALIGN(test->h * 3 / 4 - r_h,  1 << pixdesc->log2_chroma_h);
 +    p_w = FFALIGN(r_w * 5 / 4, 1 << pixdesc->log2_chroma_w);
 +    p_h = test->h - w_h - r_h;
 +
 +    for (i = 0; i < 7; i++) {
 +        draw_bar(test, rainbow[i], x, 0,   r_w, r_h, picref);
 +        draw_bar(test, wobnair[i], x, r_h, r_w, w_h, picref);
 +        x += r_w;
 +    }
 +    x = 0;
 +    draw_bar(test, i_pixel, x, r_h + w_h, p_w, p_h, picref);
 +    x += p_w;
 +    draw_bar(test, white, x, r_h + w_h, p_w, p_h, picref);
 +    x += p_w;
 +    draw_bar(test, q_pixel, x, r_h + w_h, p_w, p_h, picref);
 +    x += p_w;
 +    tmp = FFALIGN(5 * r_w - x,  1 << pixdesc->log2_chroma_w);
 +    draw_bar(test, black, x, r_h + w_h, tmp, p_h, picref);
 +    x += tmp;
 +    tmp = FFALIGN(r_w / 3,  1 << pixdesc->log2_chroma_w);
 +    draw_bar(test, neg4ire, x, r_h + w_h, tmp, p_h, picref);
 +    x += tmp;
 +    draw_bar(test, black, x, r_h + w_h, tmp, p_h, picref);
 +    x += tmp;
 +    draw_bar(test, pos4ire, x, r_h + w_h, tmp, p_h, picref);
 +    x += tmp;
 +    draw_bar(test, black, x, r_h + w_h, test->w - x, p_h, picref);
 +}
 +
 +static av_cold int smptebars_init(AVFilterContext *ctx, const char *args)
 +{
 +    TestSourceContext *test = ctx->priv;
 +
 +    test->class = &smptebars_class;
 +    test->fill_picture_fn = smptebars_fill_picture;
 +    test->draw_once = 1;
++    av_opt_set_defaults(test);
 +    return init(ctx, args);
 +}
 +
 +static int smptebars_query_formats(AVFilterContext *ctx)
 +{
 +    ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
 +    return 0;
 +}
 +
 +static int smptebars_config_props(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    TestSourceContext *test = ctx->priv;
 +
 +    ff_draw_init(&test->draw, outlink->format, 0);
 +
 +    return config_props(outlink);
 +}
 +
 +static const AVFilterPad smptebars_outputs[] = {
 +    {
 +        .name          = "default",
 +        .type          = AVMEDIA_TYPE_VIDEO,
 +        .request_frame = request_frame,
 +        .config_props  = smptebars_config_props,
 +    },
 +    { NULL }
 +};
 +
 +AVFilter avfilter_vsrc_smptebars = {
 +    .name      = "smptebars",
 +    .description = NULL_IF_CONFIG_SMALL("Generate SMPTE color bars."),
 +    .priv_size = sizeof(TestSourceContext),
 +    .init      = smptebars_init,
 +    .uninit    = uninit,
 +
 +    .query_formats = smptebars_query_formats,
 +    .inputs        = NULL,
 +    .outputs       = smptebars_outputs,
 +    .priv_class    = &smptebars_class,
 +};
 +
 +#endif  /* CONFIG_SMPTEBARS_FILTER */