gstreamer/tests/test-filter.c

452 lines
13 KiB
C
Raw Normal View History

/*
* test-filter.c - Test GstVaapiFilter
*
* Copyright (C) 2010-2011 Splitted-Desktop Systems
* Author: Gwenole Beauchesne <gwenole.beauchesne@splitted-desktop.com>
* Copyright (C) 2012-2013 Intel Corporation
* Author: Halley Zhao <halley.zhao@intel.com>
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "gst/vaapi/sysdeps.h"
#include <errno.h>
#include <gst/vaapi/gstvaapifilter.h>
#include <gst/vaapi/gstvaapiwindow.h>
#include "image.h"
#include "output.h"
static gchar *g_src_format_str;
static gchar *g_crop_rect_str;
static gchar *g_denoise_str;
static gchar *g_sharpen_str;
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, }
};
#define APP_ERROR app_error_quark()
static GQuark
app_error_quark(void)
{
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;
}
typedef enum {
APP_ERROR_NONE,
APP_ERROR_CREATE_TEST_SURFACE,
} AppError;
static inline void
pause(void)
{
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)
{
GstVideoFormat format = GST_VIDEO_FORMAT_I420;
GstVaapiSurface *surface = NULL;
GstVaapiImage *image = NULL;
GError *error = NULL;
if (g_src_format_str) {
format = gst_vaapi_video_format_from_string(g_src_format_str);
if (format == GST_VIDEO_FORMAT_UNKNOWN)
goto error_invalid_format;
}
surface = gst_vaapi_surface_new_with_format(display, format, width, height);
if (!surface)
goto error_create_surface;
image = image_generate_full(display, format, width, height, flags);
if (!image)
goto error_create_image;
if (!image_upload(image, surface))
goto error_upload_image;
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_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_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_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_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;
}
static void
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);
}
static void
dump_operations(GstVaapiFilter *filter)
{
GPtrArray * const ops = gst_vaapi_filter_get_operations(filter);
guint i;
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);
}
static void
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);
}
static gboolean
parse_double(const gchar *str, gdouble *out_value_ptr)
{
gchar *endptr = NULL;
gdouble out_value;
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;
*out_value_ptr = out_value;
return TRUE;
}
static gboolean
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;
}
return FALSE;
}
static gboolean
parse_enum(const gchar *str, GType type, gint default_value,
gint *out_value_ptr)
{
gint out_value = default_value;
g_return_val_if_fail(out_value_ptr != NULL, FALSE);
if (str) {
GEnumClass * const enum_class = g_type_class_ref(type);
if (!enum_class)
return FALSE;
const GEnumValue * const 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;
}
static gboolean
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;
}
}
*out_value_ptr = out_value;
success = TRUE;
end:
g_strfreev(tokens);
return success;
}
static inline gboolean
parse_deinterlace(const gchar *str, GstVaapiDeinterlaceMethod *deinterlace_ptr)
{
g_return_val_if_fail(deinterlace_ptr != NULL, FALSE);
return str && 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)
{
return parse_flags(str, GST_VAAPI_TYPE_DEINTERLACE_FLAGS,
deinterlace_flags_ptr);
}
int
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;
}