tests: inforce gstreamer code-style

1 files changed, 333 insertions, 334 deletions

diff --git a/tests/test-filter.c b/tests/test-filter.c
index 0f681e8d..f8306827 100644
--- a/tests/test-filter.c
+++ b/tests/test-filter.c
@@ -38,419 +38,418 @@ static gchar *g_deinterlace_str;
 static gchar *g_deinterlace_flags_str;
 
 static GOptionEntry g_options[] = {
-    { "src-format", 's',
-      0,
-      G_OPTION_ARG_STRING, &g_src_format_str,
-      "source surface format", NULL },
-    { "crop-rect", 'c',
-      0,
-      G_OPTION_ARG_STRING, &g_crop_rect_str,
-      "cropping rectangle", NULL },
-    { "denoise", 0,
-      0,
-      G_OPTION_ARG_STRING, &g_denoise_str,
-      "set noise reduction level", NULL },
-    { "sharpen", 0,
-      0,
-      G_OPTION_ARG_STRING, &g_sharpen_str,
-      "set sharpening level", NULL },
-    { "deinterlace", 0,
-      0,
-      G_OPTION_ARG_STRING, &g_deinterlace_str,
-      "enable deinterlacing", NULL },
-    { "deinterlace-flags", 0,
-      0,
-      G_OPTION_ARG_STRING, &g_deinterlace_flags_str,
-      "deinterlacing flags", NULL },
-    { NULL, }
+  {"src-format", 's',
+        0,
+        G_OPTION_ARG_STRING, &g_src_format_str,
+      "source surface format", NULL},
+  {"crop-rect", 'c',
+        0,
+        G_OPTION_ARG_STRING, &g_crop_rect_str,
+      "cropping rectangle", NULL},
+  {"denoise", 0,
+        0,
+        G_OPTION_ARG_STRING, &g_denoise_str,
+      "set noise reduction level", NULL},
+  {"sharpen", 0,
+        0,
+        G_OPTION_ARG_STRING, &g_sharpen_str,
+      "set sharpening level", NULL},
+  {"deinterlace", 0,
+        0,
+        G_OPTION_ARG_STRING, &g_deinterlace_str,
+      "enable deinterlacing", NULL},
+  {"deinterlace-flags", 0,
+        0,
+        G_OPTION_ARG_STRING, &g_deinterlace_flags_str,
+      "deinterlacing flags", NULL},
+  {NULL,}
 };
 
 #define APP_ERROR app_error_quark()
 static GQuark
-app_error_quark(void)
+app_error_quark (void)
 {
-    static gsize g_quark;
+  static gsize g_quark;
 
-    if (g_once_init_enter(&g_quark)) {
-        gsize quark = (gsize)g_quark_from_static_string("AppError");
-        g_once_init_leave(&g_quark, quark);
-    }
-    return g_quark;
+  if (g_once_init_enter (&g_quark)) {
+    gsize quark = (gsize) g_quark_from_static_string ("AppError");
+    g_once_init_leave (&g_quark, quark);
+  }
+  return g_quark;
 }
 
-typedef enum {
-    APP_ERROR_NONE,
-    APP_ERROR_CREATE_TEST_SURFACE,
+typedef enum
+{
+  APP_ERROR_NONE,
+  APP_ERROR_CREATE_TEST_SURFACE,
 } AppError;
 
 static inline void
-pause(void)
+pause (void)
 {
-    g_print("Press any key to continue...\n");
-    getchar();
+  g_print ("Press any key to continue...\n");
+  getchar ();
 }
 
 static GstVaapiSurface *
-create_test_surface(GstVaapiDisplay *display, guint width, guint height,
-    guint flags, GError **error_ptr)
+create_test_surface (GstVaapiDisplay * display, guint width, guint height,
+    guint flags, GError ** error_ptr)
 {
-    GstVideoFormat format = GST_VIDEO_FORMAT_I420;
-    GstVaapiSurface *surface = NULL;
-    GstVaapiImage *image = NULL;
-    GError *error = NULL;
-
-    if (g_src_format_str) {
-        format = gst_video_format_from_string(g_src_format_str);
-        if (format == GST_VIDEO_FORMAT_UNKNOWN)
-            goto error_invalid_format;
-    }
+  GstVideoFormat format = GST_VIDEO_FORMAT_I420;
+  GstVaapiSurface *surface = NULL;
+  GstVaapiImage *image = NULL;
+  GError *error = NULL;
 
-    surface = gst_vaapi_surface_new_with_format(display, format, width, height);
-    if (!surface)
-        goto error_create_surface;
+  if (g_src_format_str) {
+    format = gst_video_format_from_string (g_src_format_str);
+    if (format == GST_VIDEO_FORMAT_UNKNOWN)
+      goto error_invalid_format;
+  }
 
-    image = image_generate_full(display, format, width, height, flags);
-    if (!image)
-        goto error_create_image;
+  surface = gst_vaapi_surface_new_with_format (display, format, width, height);
+  if (!surface)
+    goto error_create_surface;
 
-    if (!image_upload(image, surface))
-        goto error_upload_image;
+  image = image_generate_full (display, format, width, height, flags);
+  if (!image)
+    goto error_create_image;
 
-    gst_vaapi_object_unref(image);
-    return surface;
+  if (!image_upload (image, surface))
+    goto error_upload_image;
 
-    /* ERRORS */
+  gst_vaapi_object_unref (image);
+  return surface;
+
+  /* ERRORS */
 error_invalid_format:
-    error = g_error_new(APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
-        "unknown format %s", g_src_format_str);
-    goto error_cleanup;
+  error = g_error_new (APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
+      "unknown format %s", g_src_format_str);
+  goto error_cleanup;
 error_create_surface:
-    error = g_error_new(APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
-        "unsupported format %s", gst_vaapi_video_format_to_string(format));
-    goto error_cleanup;
+  error = g_error_new (APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
+      "unsupported format %s", gst_vaapi_video_format_to_string (format));
+  goto error_cleanup;
 error_create_image:
-    error = g_error_new(APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
-        "unsupported %s image", gst_vaapi_video_format_to_string(format));
-    goto error_cleanup;
+  error = g_error_new (APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
+      "unsupported %s image", gst_vaapi_video_format_to_string (format));
+  goto error_cleanup;
 error_upload_image:
-    error = g_error_new(APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
-        "failed to upload %s image", gst_vaapi_video_format_to_string(format));
-    goto error_cleanup;
+  error = g_error_new (APP_ERROR, APP_ERROR_CREATE_TEST_SURFACE,
+      "failed to upload %s image", gst_vaapi_video_format_to_string (format));
+  goto error_cleanup;
 error_cleanup:
-    if (image)
-        gst_vaapi_object_unref(image);
-    if (surface)
-        gst_vaapi_object_unref(surface);
-    if (error_ptr)
-        *error_ptr = error;
-    else
-        g_error_free(error);
-    return NULL;
+  if (image)
+    gst_vaapi_object_unref (image);
+  if (surface)
+    gst_vaapi_object_unref (surface);
+  if (error_ptr)
+    *error_ptr = error;
+  else
+    g_error_free (error);
+  return NULL;
 }
 
 static void
-dump_operation(GstVaapiFilterOpInfo *op_info)
+dump_operation (GstVaapiFilterOpInfo * op_info)
 {
-    GParamSpec * const pspec = op_info->pspec;
-    GValue value = G_VALUE_INIT;
-    gchar *value_str;
-
-    if (!op_info)
-        return;
-
-    g_print("  %s: ", g_param_spec_get_name(pspec));
-    g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(pspec));
-    g_param_value_set_default(pspec, &value);
-    value_str = g_strdup_value_contents(&value);
-    g_print("%s (default: %s)\n", G_VALUE_TYPE_NAME(&value),
-        value_str ? value_str : "<unknown>");
-    g_free(value_str);
+  GParamSpec *const pspec = op_info->pspec;
+  GValue value = G_VALUE_INIT;
+  gchar *value_str;
+
+  if (!op_info)
+    return;
+
+  g_print ("  %s: ", g_param_spec_get_name (pspec));
+  g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
+  g_param_value_set_default (pspec, &value);
+  value_str = g_strdup_value_contents (&value);
+  g_print ("%s (default: %s)\n", G_VALUE_TYPE_NAME (&value),
+      value_str ? value_str : "<unknown>");
+  g_free (value_str);
 }
 
 static void
-dump_operations(GstVaapiFilter *filter)
+dump_operations (GstVaapiFilter * filter)
 {
-    GPtrArray * const ops = gst_vaapi_filter_get_operations(filter);
-    guint i;
+  GPtrArray *const ops = gst_vaapi_filter_get_operations (filter);
+  guint i;
 
-    if (!ops)
-        return;
+  if (!ops)
+    return;
 
-    g_print("%u operations\n", ops->len);
-    for (i = 0; i < ops->len; i++)
-        dump_operation(g_ptr_array_index(ops, i));
-    g_ptr_array_unref(ops);
+  g_print ("%u operations\n", ops->len);
+  for (i = 0; i < ops->len; i++)
+    dump_operation (g_ptr_array_index (ops, i));
+  g_ptr_array_unref (ops);
 }
 
 static void
-dump_formats(GstVaapiFilter *filter)
+dump_formats (GstVaapiFilter * filter)
 {
-    GArray * const formats = gst_vaapi_filter_get_formats(filter);
-    guint i;
-
-    if (!formats)
-        return;
-
-    g_print("%u formats\n", formats->len);
-    for (i = 0; i < formats->len; i++) {
-        GstVideoFormat format = g_array_index(formats, GstVideoFormat, i);
-        g_print("  %s\n", gst_vaapi_video_format_to_string(format));
-    }
-    g_array_unref(formats);
+  GArray *const formats = gst_vaapi_filter_get_formats (filter);
+  guint i;
+
+  if (!formats)
+    return;
+
+  g_print ("%u formats\n", formats->len);
+  for (i = 0; i < formats->len; i++) {
+    GstVideoFormat format = g_array_index (formats, GstVideoFormat, i);
+    g_print ("  %s\n", gst_vaapi_video_format_to_string (format));
+  }
+  g_array_unref (formats);
 }
 
 static gboolean
-parse_double(const gchar *str, gdouble *out_value_ptr)
+parse_double (const gchar * str, gdouble * out_value_ptr)
 {
-    gchar *endptr = NULL;
-    gdouble out_value;
+  gchar *endptr = NULL;
+  gdouble out_value;
 
-    g_return_val_if_fail(out_value_ptr != NULL, FALSE);
+  g_return_val_if_fail (out_value_ptr != NULL, FALSE);
 
-    errno = 0;
-    out_value = g_ascii_strtod(str, &endptr);
-    if (!endptr || *endptr != '\0' || errno == ERANGE)
-        return FALSE;
+  errno = 0;
+  out_value = g_ascii_strtod (str, &endptr);
+  if (!endptr || *endptr != '\0' || errno == ERANGE)
+    return FALSE;
 
-    *out_value_ptr = out_value;
-    return TRUE;
+  *out_value_ptr = out_value;
+  return TRUE;
 }
 
 static gboolean
-parse_crop_rect(const gchar *str, GstVaapiRectangle *crop_rect)
+parse_crop_rect (const gchar * str, GstVaapiRectangle * crop_rect)
 {
-    if (str) {
-        // Format: <WIDTH> 'x' <HEIGHT>
-        if (sscanf(str, "%ux%u", &crop_rect->width, &crop_rect->height) == 2) {
-            crop_rect->x = 0;
-            crop_rect->y = 0;
-            return TRUE;
-        }
-
-        // Format: '('? <X> ',' <Y> ')'? <WIDTH> 'x' <HEIGHT>
-        if (sscanf(str, "(%d,%d):%ux%u", &crop_rect->x, &crop_rect->y,
-                   &crop_rect->width, &crop_rect->height) == 4 ||
-            sscanf(str, "%d,%d:%ux%u", &crop_rect->x, &crop_rect->y,
-                   &crop_rect->width, &crop_rect->height) == 4)
-            return TRUE;
+  if (str) {
+    // Format: <WIDTH> 'x' <HEIGHT>
+    if (sscanf (str, "%ux%u", &crop_rect->width, &crop_rect->height) == 2) {
+      crop_rect->x = 0;
+      crop_rect->y = 0;
+      return TRUE;
     }
-    return FALSE;
+    // Format: '('? <X> ',' <Y> ')'? <WIDTH> 'x' <HEIGHT>
+    if (sscanf (str, "(%d,%d):%ux%u", &crop_rect->x, &crop_rect->y,
+            &crop_rect->width, &crop_rect->height) == 4 ||
+        sscanf (str, "%d,%d:%ux%u", &crop_rect->x, &crop_rect->y,
+            &crop_rect->width, &crop_rect->height) == 4)
+      return TRUE;
+  }
+  return FALSE;
 }
 
 static gboolean
-parse_enum(const gchar *str, GType type, gint default_value,
-    gint *out_value_ptr)
+parse_enum (const gchar * str, GType type, gint default_value,
+    gint * out_value_ptr)
 {
-    gint out_value = default_value;
+  gint out_value = default_value;
 
-    g_return_val_if_fail(out_value_ptr != NULL, FALSE);
+  g_return_val_if_fail (out_value_ptr != NULL, FALSE);
 
-    if (str) {
-        const GEnumValue *enum_value;
-        GEnumClass * const enum_class = g_type_class_ref(type);
+  if (str) {
+    const GEnumValue *enum_value;
+    GEnumClass *const enum_class = g_type_class_ref (type);
 
-        if (!enum_class)
-            return FALSE;
+    if (!enum_class)
+      return FALSE;
 
-        enum_value = g_enum_get_value_by_nick(enum_class, str);
-        if (enum_value)
-            out_value = enum_value->value;
-        g_type_class_unref(enum_class);
+    enum_value = g_enum_get_value_by_nick (enum_class, str);
+    if (enum_value)
+      out_value = enum_value->value;
+    g_type_class_unref (enum_class);
 
-        if (!enum_value)
-            return FALSE;
-    }
-    *out_value_ptr = out_value;
-    return TRUE;
+    if (!enum_value)
+      return FALSE;
+  }
+  *out_value_ptr = out_value;
+  return TRUE;
 }
 
 static gboolean
-parse_flags(const gchar *str, GType type, guint *out_value_ptr)
+parse_flags (const gchar * str, GType type, guint * out_value_ptr)
 {
-    gchar **tokens = NULL;
-    gint i, value, out_value = 0;
-    gboolean success = FALSE;
-
-    g_return_val_if_fail(out_value_ptr != NULL, FALSE);
-
-    if (str) {
-        tokens = g_strsplit(str, ",", 32);
-        if (!tokens)
-            return FALSE;
-
-        for (i = 0; tokens[i] != NULL; i++) {
-            if (!parse_enum(tokens[i], type, 0, &value))
-                goto end;
-            out_value |= value;
-        }
+  gchar **tokens = NULL;
+  gint i, value, out_value = 0;
+  gboolean success = FALSE;
+
+  g_return_val_if_fail (out_value_ptr != NULL, FALSE);
+
+  if (str) {
+    tokens = g_strsplit (str, ",", 32);
+    if (!tokens)
+      return FALSE;
+
+    for (i = 0; tokens[i] != NULL; i++) {
+      if (!parse_enum (tokens[i], type, 0, &value))
+        goto end;
+      out_value |= value;
     }
-    *out_value_ptr = out_value;
-    success = TRUE;
+  }
+  *out_value_ptr = out_value;
+  success = TRUE;
 
 end:
-    g_strfreev(tokens);
-    return success;
+  g_strfreev (tokens);
+  return success;
 }
 
 static inline gboolean
-parse_deinterlace(const gchar *str, GstVaapiDeinterlaceMethod *deinterlace_ptr)
+parse_deinterlace (const gchar * str,
+    GstVaapiDeinterlaceMethod * deinterlace_ptr)
 {
-    g_return_val_if_fail(deinterlace_ptr != NULL, FALSE);
+  g_return_val_if_fail (deinterlace_ptr != NULL, FALSE);
 
-    if (!str) {
-        *deinterlace_ptr = GST_VAAPI_DEINTERLACE_METHOD_NONE;
-        return TRUE;
-    }
-    return parse_enum(str, GST_VAAPI_TYPE_DEINTERLACE_METHOD,
-        GST_VAAPI_DEINTERLACE_METHOD_NONE, (gint *)deinterlace_ptr);
+  if (!str) {
+    *deinterlace_ptr = GST_VAAPI_DEINTERLACE_METHOD_NONE;
+    return TRUE;
+  }
+  return parse_enum (str, GST_VAAPI_TYPE_DEINTERLACE_METHOD,
+      GST_VAAPI_DEINTERLACE_METHOD_NONE, (gint *) deinterlace_ptr);
 }
 
 static inline gboolean
-parse_deinterlace_flags(const gchar *str, guint *deinterlace_flags_ptr)
+parse_deinterlace_flags (const gchar * str, guint * deinterlace_flags_ptr)
 {
-    return parse_flags(str, GST_VAAPI_TYPE_DEINTERLACE_FLAGS,
-        deinterlace_flags_ptr);
+  return parse_flags (str, GST_VAAPI_TYPE_DEINTERLACE_FLAGS,
+      deinterlace_flags_ptr);
 }
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-    GstVaapiDisplay *display;
-    GstVaapiWindow *window;
-    GstVaapiSurface *src_surface, *dst_surface;
-    GstVaapiFilter *filter = NULL;
-    GstVaapiFilterStatus status;
-    GstVaapiDeinterlaceMethod deinterlace_method;
-    guint deinterlace_flags = 0;
-    guint filter_flags = 0;
-    guint surface_flags = 0;
-    gdouble denoise_level, sharpen_level;
-    GError *error = NULL;
-
-    static const guint src_width        = 320;
-    static const guint src_height       = 240;
-    static const guint dst_width        = 480;
-    static const guint dst_height       = 360;
-    static const guint win_width        = 640;
-    static const guint win_height       = 480;
-
-    if (!video_output_init(&argc, argv, g_options))
-        g_error("failed to initialize video output subsystem");
-
-    if (g_denoise_str && !parse_double(g_denoise_str, &denoise_level))
-        g_error("failed to parse noise reduction level");
-
-    if (g_sharpen_str && !parse_double(g_sharpen_str, &sharpen_level))
-        g_error("failed to parse sharpening level");
-
-    if (!parse_deinterlace(g_deinterlace_str, &deinterlace_method))
-        g_error("failed to parse deinterlace method `%s'", g_deinterlace_str);
-
-    if (!parse_deinterlace_flags(g_deinterlace_flags_str, &deinterlace_flags))
-        g_error("failed to parse deinterlace flags `%s'",
-            g_deinterlace_flags_str);
-
-    display = video_output_create_display(NULL);
-    if (!display)
-        g_error("failed to create VA display");
-
-    window = video_output_create_window(display, win_width, win_height);
-    if (!window)
-        g_error("failed to create window");
-
-    filter = gst_vaapi_filter_new(display);
-    if (!filter)
-        g_error("failed to create video processing pipeline");
-
-    dump_operations(filter);
-    dump_formats(filter);
-
-    if (g_crop_rect_str) {
-        GstVaapiRectangle crop_rect;
-
-        if (!parse_crop_rect(g_crop_rect_str, &crop_rect))
-            g_error("failed to parse cropping rectangle");
-
-        printf("Frame cropping: (%d,%d), size %ux%u\n",
-               crop_rect.x, crop_rect.y, crop_rect.width, crop_rect.height);
-
-        if (!gst_vaapi_filter_set_cropping_rectangle(filter, &crop_rect))
-            g_error("failed to set cropping rectangle");
-    }
-
-    if (g_denoise_str) {
-        printf("Noise reduction level: %f\n", denoise_level);
-
-        if (!gst_vaapi_filter_set_denoising_level(filter, denoise_level))
-            g_error("failed to set denoising level");
-    }
-
-    if (g_sharpen_str) {
-        printf("Sharpening level: %f\n", sharpen_level);
-
-        if (!gst_vaapi_filter_set_sharpening_level(filter, sharpen_level))
-            g_error("failed to set sharpening level");
-    }
-
-    if (deinterlace_method != GST_VAAPI_DEINTERLACE_METHOD_NONE) {
-        printf("Enable deinterlacing: %s\n", g_deinterlace_str);
-
-        if (!gst_vaapi_filter_set_deinterlacing(filter, deinterlace_method,
-                deinterlace_flags))
-            g_error("failed to set deinterlacing method");
-    }
-    else if (deinterlace_flags) {
-        if (deinterlace_flags & GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD)
-            filter_flags = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD;
-        else
-            filter_flags = GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
-    }
-
-    if (deinterlace_method != GST_VAAPI_DEINTERLACE_METHOD_NONE ||
-        deinterlace_flags) {
-        if (!(deinterlace_flags & GST_VAAPI_DEINTERLACE_FLAG_ONEFIELD))
-            surface_flags = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD |
-                GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
-        else if (deinterlace_flags & GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD)
-            surface_flags = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD;
-        else
-            surface_flags = GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
-    }
-
-    src_surface = create_test_surface(display, src_width, src_height,
-        surface_flags, &error);
-    if (!src_surface)
-        g_error("failed to create source VA surface: %s", error->message);
-
-    dst_surface = gst_vaapi_surface_new(display, GST_VAAPI_CHROMA_TYPE_YUV420,
-        dst_width, dst_height);
-    if (!dst_surface)
-        g_error("failed to create target VA surface");
-
-    status = gst_vaapi_filter_process(filter, src_surface, dst_surface,
-        filter_flags);
-    if (status != GST_VAAPI_FILTER_STATUS_SUCCESS)
-        g_error("failed to process video filters");
-
-    gst_vaapi_window_show(window);
-
-    if (!gst_vaapi_window_put_surface(window, dst_surface, NULL, NULL,
-            GST_VAAPI_PICTURE_STRUCTURE_FRAME))
-        g_error("failed to render target surface");
-
-    pause();
-
-    gst_vaapi_filter_unref(filter);
-    gst_vaapi_object_unref(dst_surface);
-    gst_vaapi_object_unref(src_surface);
-    gst_vaapi_window_unref(window);
-    gst_vaapi_display_unref(display);
-    video_output_exit();
-    g_free(g_src_format_str);
-    g_free(g_crop_rect_str);
-    g_free(g_denoise_str);
-    g_free(g_sharpen_str);
-    g_free(g_deinterlace_str);
-    g_free(g_deinterlace_flags_str);
-    return 0;
+  GstVaapiDisplay *display;
+  GstVaapiWindow *window;
+  GstVaapiSurface *src_surface, *dst_surface;
+  GstVaapiFilter *filter = NULL;
+  GstVaapiFilterStatus status;
+  GstVaapiDeinterlaceMethod deinterlace_method;
+  guint deinterlace_flags = 0;
+  guint filter_flags = 0;
+  guint surface_flags = 0;
+  gdouble denoise_level, sharpen_level;
+  GError *error = NULL;
+
+  static const guint src_width = 320;
+  static const guint src_height = 240;
+  static const guint dst_width = 480;
+  static const guint dst_height = 360;
+  static const guint win_width = 640;
+  static const guint win_height = 480;
+
+  if (!video_output_init (&argc, argv, g_options))
+    g_error ("failed to initialize video output subsystem");
+
+  if (g_denoise_str && !parse_double (g_denoise_str, &denoise_level))
+    g_error ("failed to parse noise reduction level");
+
+  if (g_sharpen_str && !parse_double (g_sharpen_str, &sharpen_level))
+    g_error ("failed to parse sharpening level");
+
+  if (!parse_deinterlace (g_deinterlace_str, &deinterlace_method))
+    g_error ("failed to parse deinterlace method `%s'", g_deinterlace_str);
+
+  if (!parse_deinterlace_flags (g_deinterlace_flags_str, &deinterlace_flags))
+    g_error ("failed to parse deinterlace flags `%s'", g_deinterlace_flags_str);
+
+  display = video_output_create_display (NULL);
+  if (!display)
+    g_error ("failed to create VA display");
+
+  window = video_output_create_window (display, win_width, win_height);
+  if (!window)
+    g_error ("failed to create window");
+
+  filter = gst_vaapi_filter_new (display);
+  if (!filter)
+    g_error ("failed to create video processing pipeline");
+
+  dump_operations (filter);
+  dump_formats (filter);
+
+  if (g_crop_rect_str) {
+    GstVaapiRectangle crop_rect;
+
+    if (!parse_crop_rect (g_crop_rect_str, &crop_rect))
+      g_error ("failed to parse cropping rectangle");
+
+    printf ("Frame cropping: (%d,%d), size %ux%u\n",
+        crop_rect.x, crop_rect.y, crop_rect.width, crop_rect.height);
+
+    if (!gst_vaapi_filter_set_cropping_rectangle (filter, &crop_rect))
+      g_error ("failed to set cropping rectangle");
+  }
+
+  if (g_denoise_str) {
+    printf ("Noise reduction level: %f\n", denoise_level);
+
+    if (!gst_vaapi_filter_set_denoising_level (filter, denoise_level))
+      g_error ("failed to set denoising level");
+  }
+
+  if (g_sharpen_str) {
+    printf ("Sharpening level: %f\n", sharpen_level);
+
+    if (!gst_vaapi_filter_set_sharpening_level (filter, sharpen_level))
+      g_error ("failed to set sharpening level");
+  }
+
+  if (deinterlace_method != GST_VAAPI_DEINTERLACE_METHOD_NONE) {
+    printf ("Enable deinterlacing: %s\n", g_deinterlace_str);
+
+    if (!gst_vaapi_filter_set_deinterlacing (filter, deinterlace_method,
+            deinterlace_flags))
+      g_error ("failed to set deinterlacing method");
+  } else if (deinterlace_flags) {
+    if (deinterlace_flags & GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD)
+      filter_flags = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD;
+    else
+      filter_flags = GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
+  }
+
+  if (deinterlace_method != GST_VAAPI_DEINTERLACE_METHOD_NONE ||
+      deinterlace_flags) {
+    if (!(deinterlace_flags & GST_VAAPI_DEINTERLACE_FLAG_ONEFIELD))
+      surface_flags = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD |
+          GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
+    else if (deinterlace_flags & GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD)
+      surface_flags = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD;
+    else
+      surface_flags = GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
+  }
+
+  src_surface = create_test_surface (display, src_width, src_height,
+      surface_flags, &error);
+  if (!src_surface)
+    g_error ("failed to create source VA surface: %s", error->message);
+
+  dst_surface = gst_vaapi_surface_new (display, GST_VAAPI_CHROMA_TYPE_YUV420,
+      dst_width, dst_height);
+  if (!dst_surface)
+    g_error ("failed to create target VA surface");
+
+  status = gst_vaapi_filter_process (filter, src_surface, dst_surface,
+      filter_flags);
+  if (status != GST_VAAPI_FILTER_STATUS_SUCCESS)
+    g_error ("failed to process video filters");
+
+  gst_vaapi_window_show (window);
+
+  if (!gst_vaapi_window_put_surface (window, dst_surface, NULL, NULL,
+          GST_VAAPI_PICTURE_STRUCTURE_FRAME))
+    g_error ("failed to render target surface");
+
+  pause ();
+
+  gst_vaapi_filter_unref (filter);
+  gst_vaapi_object_unref (dst_surface);
+  gst_vaapi_object_unref (src_surface);
+  gst_vaapi_window_unref (window);
+  gst_vaapi_display_unref (display);
+  video_output_exit ();
+  g_free (g_src_format_str);
+  g_free (g_crop_rect_str);
+  g_free (g_denoise_str);
+  g_free (g_sharpen_str);
+  g_free (g_deinterlace_str);
+  g_free (g_deinterlace_flags_str);
+  return 0;
 }