gstreamer/gst-libs/gst/vaapi/gstvaapidisplay.c

/*
 *  gstvaapidisplay.c - VA display abstraction
 *
 *  Copyright (C) 2010-2011 Splitted-Desktop Systems
 *  Copyright (C) 2011-2013 Intel Corporation
 *
 *  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
 */

/**
 * SECTION:gstvaapidisplay
 * @short_description: VA display abstraction
 */

#include "sysdeps.h"
#include <string.h>
#include "gstvaapiutils.h"
#include "gstvaapivalue.h"
#include "gstvaapidisplay.h"
#include "gstvaapidisplay_priv.h"
#include "gstvaapiworkarounds.h"
#include "gstvaapiversion.h"

#define DEBUG 1
#include "gstvaapidebug.h"

GST_DEBUG_CATEGORY(gst_debug_vaapi);

/* Ensure those symbols are actually defined in the resulting libraries */
#undef gst_vaapi_display_ref
#undef gst_vaapi_display_unref
#undef gst_vaapi_display_replace

typedef struct _GstVaapiConfig GstVaapiConfig;
struct _GstVaapiConfig {
    GstVaapiProfile     profile;
    GstVaapiEntrypoint  entrypoint;
};

typedef struct _GstVaapiProperty GstVaapiProperty;
struct _GstVaapiProperty {
    const gchar        *name;
    VADisplayAttribute  attribute;
    gint                old_value;
};

typedef struct _GstVaapiFormatInfo GstVaapiFormatInfo;
struct _GstVaapiFormatInfo {
    GstVideoFormat      format;
    guint               flags;
};

#define DEFAULT_RENDER_MODE     GST_VAAPI_RENDER_MODE_TEXTURE
#define DEFAULT_ROTATION        GST_VAAPI_ROTATION_0

enum {
    PROP_0,

    PROP_RENDER_MODE,
    PROP_ROTATION,
    PROP_HUE,
    PROP_SATURATION,
    PROP_BRIGHTNESS,
    PROP_CONTRAST,

    N_PROPERTIES
};

static GstVaapiDisplayCache *g_display_cache = NULL;

static GParamSpec *g_properties[N_PROPERTIES] = { NULL, };

static void
gst_vaapi_display_properties_init(void);

static gboolean
get_attribute(GstVaapiDisplay *display, VADisplayAttribType type, gint *value);

static gboolean
set_attribute(GstVaapiDisplay *display, VADisplayAttribType type, gint value);

static gboolean
get_color_balance(GstVaapiDisplay *display, guint prop_id, gfloat *v);

static gboolean
set_color_balance(GstVaapiDisplay *display, guint prop_id, gfloat v);

static void
libgstvaapi_init_once(void)
{
    static gsize g_once = FALSE;

    if (!g_once_init_enter(&g_once))
        return;

    GST_DEBUG_CATEGORY_INIT(gst_debug_vaapi, "vaapi", 0, "VA-API helper");

    /* Dump gstreamer-vaapi version for debugging purposes */
    GST_INFO("gstreamer-vaapi version %s", GST_VAAPI_VERSION_ID);

    gst_vaapi_display_properties_init();

    g_once_init_leave(&g_once, TRUE);
}

static inline GstVaapiDisplayCache *
get_display_cache(void)
{
    if (!g_display_cache)
        g_display_cache = gst_vaapi_display_cache_new();
    return g_display_cache;
}

GstVaapiDisplayCache *
gst_vaapi_display_get_cache(void)
{
    return get_display_cache();
}

static void
free_display_cache(void)
{
    if (!g_display_cache)
        return;
    if (gst_vaapi_display_cache_get_size(g_display_cache) > 0)
        return;
    gst_vaapi_display_cache_free(g_display_cache);
    g_display_cache = NULL;
}

/* GstVaapiDisplayType enumerations */
GType
gst_vaapi_display_type_get_type(void)
{
    static GType g_type = 0;

    static const GEnumValue display_types[] = {
        { GST_VAAPI_DISPLAY_TYPE_ANY,
          "Auto detection", "any" },
#if USE_X11
        { GST_VAAPI_DISPLAY_TYPE_X11,
          "VA/X11 display", "x11" },
#endif
#if USE_GLX
        { GST_VAAPI_DISPLAY_TYPE_GLX,
          "VA/GLX display", "glx" },
#endif
#if USE_WAYLAND
        { GST_VAAPI_DISPLAY_TYPE_WAYLAND,
          "VA/Wayland display", "wayland" },
#endif
#if USE_DRM
        { GST_VAAPI_DISPLAY_TYPE_DRM,
          "VA/DRM display", "drm" },
#endif
        { 0, NULL, NULL },
    };

    if (!g_type)
        g_type = g_enum_register_static("GstVaapiDisplayType", display_types);
    return g_type;
}

/* Append GstVideoFormat to formats array */
static inline void
append_format(GArray *formats, GstVideoFormat format, guint flags)
{
    GstVaapiFormatInfo fi;

    fi.format = format;
    fi.flags = flags;
    g_array_append_val(formats, fi);
}

/* Append VAImageFormats to formats array */
static void
append_formats(GArray *formats, const VAImageFormat *va_formats,
    guint *flags, guint n)
{
    GstVideoFormat format;
    const GstVaapiFormatInfo *YV12_fip = NULL;
    const GstVaapiFormatInfo *I420_fip = NULL;
    guint i;

    for (i = 0; i < n; i++) {
        const VAImageFormat * const va_format = &va_formats[i];
        const GstVaapiFormatInfo **fipp;

        format = gst_video_format_from_va_format(va_format);
        if (format == GST_VIDEO_FORMAT_UNKNOWN) {
            GST_DEBUG("unsupported format %" GST_FOURCC_FORMAT,
                      GST_FOURCC_ARGS(va_format->fourcc));
            continue;
        }
        append_format(formats, format, flags ? flags[i] : 0);

        switch (format) {
        case GST_VIDEO_FORMAT_YV12:
            fipp = &YV12_fip;
            break;
        case GST_VIDEO_FORMAT_I420:
            fipp = &I420_fip;
            break;
        default:
            fipp = NULL;
            break;
        }
        if (fipp)
            *fipp = &g_array_index(formats, GstVaapiFormatInfo,
                formats->len - 1);
    }

    /* Append I420 (resp. YV12) format if YV12 (resp. I420) is not
       supported by the underlying driver */
    if (YV12_fip && !I420_fip)
        append_format(formats, GST_VIDEO_FORMAT_I420, YV12_fip->flags);
    else if (I420_fip && !YV12_fip)
        append_format(formats, GST_VIDEO_FORMAT_YV12, I420_fip->flags);
}

/* Sort image formats. Prefer YUV formats first */
static gint
compare_yuv_formats(gconstpointer a, gconstpointer b)
{
    const GstVideoFormat fmt1 = ((GstVaapiFormatInfo *)a)->format;
    const GstVideoFormat fmt2 = ((GstVaapiFormatInfo *)b)->format;

    const gboolean is_fmt1_yuv = gst_video_format_is_yuv(fmt1);
    const gboolean is_fmt2_yuv = gst_video_format_is_yuv(fmt2);

    if (is_fmt1_yuv != is_fmt2_yuv)
        return is_fmt1_yuv ? -1 : 1;

    return ((gint)gst_video_format_get_score(fmt1) -
            (gint)gst_video_format_get_score(fmt2));
}

/* Sort subpicture formats. Prefer RGB formats first */
static gint
compare_rgb_formats(gconstpointer a, gconstpointer b)
{
    const GstVideoFormat fmt1 = ((GstVaapiFormatInfo *)a)->format;
    const GstVideoFormat fmt2 = ((GstVaapiFormatInfo *)b)->format;

    const gboolean is_fmt1_rgb = gst_video_format_is_rgb(fmt1);
    const gboolean is_fmt2_rgb = gst_video_format_is_rgb(fmt2);

    if (is_fmt1_rgb != is_fmt2_rgb)
        return is_fmt1_rgb ? -1 : 1;

    return ((gint)gst_video_format_get_score(fmt1) -
            (gint)gst_video_format_get_score(fmt2));
}

/* Check if configs array contains profile at entrypoint */
static inline gboolean
find_config(
    GArray             *configs,
    GstVaapiProfile     profile,
    GstVaapiEntrypoint  entrypoint
)
{
    GstVaapiConfig *config;
    guint i;

    if (!configs)
        return FALSE;

    for (i = 0; i < configs->len; i++) {
        config = &g_array_index(configs, GstVaapiConfig, i);
        if (config->profile == profile && config->entrypoint == entrypoint)
            return TRUE;
    }
    return FALSE;
}

/* HACK: append H.263 Baseline profile if MPEG-4:2 Simple profile is supported */
static void
append_h263_config(GArray *configs)
{
    GstVaapiConfig *config, tmp_config;
    GstVaapiConfig *mpeg4_simple_config = NULL;
    GstVaapiConfig *h263_baseline_config = NULL;
    guint i;

    if (!WORKAROUND_H263_BASELINE_DECODE_PROFILE)
        return;

    if (!configs)
        return;

    for (i = 0; i < configs->len; i++) {
        config = &g_array_index(configs, GstVaapiConfig, i);
        if (config->profile == GST_VAAPI_PROFILE_MPEG4_SIMPLE)
            mpeg4_simple_config = config;
        else if (config->profile == GST_VAAPI_PROFILE_H263_BASELINE)
            h263_baseline_config = config;
    }

    if (mpeg4_simple_config && !h263_baseline_config) {
        tmp_config = *mpeg4_simple_config;
        tmp_config.profile = GST_VAAPI_PROFILE_H263_BASELINE;
        g_array_append_val(configs, tmp_config);
    }
}

/* Convert configs array to profiles as GstCaps */
static GstCaps *
get_profile_caps(GArray *configs)
{
    GstVaapiConfig *config;
    GstCaps *out_caps, *caps;
    guint i;

    if (!configs)
        return NULL;

    out_caps = gst_caps_new_empty();
    if (!out_caps)
        return NULL;

    for (i = 0; i < configs->len; i++) {
        config = &g_array_index(configs, GstVaapiConfig, i);
        caps   = gst_vaapi_profile_get_caps(config->profile);
        if (caps)
            out_caps = gst_caps_merge(out_caps, caps);
    }
    return out_caps;
}

/* Find format info */
static const GstVaapiFormatInfo *
find_format_info(GArray *formats, GstVideoFormat format)
{
    const GstVaapiFormatInfo *fip;
    guint i;

    for (i = 0; i < formats->len; i++) {
        fip = &g_array_index(formats, GstVaapiFormatInfo, i);
        if (fip->format == format)
            return fip;
    }
    return NULL;
}

/* Check if formats array contains format */
static inline gboolean
find_format(GArray *formats, GstVideoFormat format)
{
    return find_format_info(formats, format) != NULL;
}

/* Convert formats array to GstCaps */
static GstCaps *
get_format_caps(GArray *formats)
{
    const GstVaapiFormatInfo *fip;
    GstCaps *out_caps, *caps;
    guint i;

    out_caps = gst_caps_new_empty();
    if (!out_caps)
        return NULL;

    for (i = 0; i < formats->len; i++) {
        fip = &g_array_index(formats, GstVaapiFormatInfo, i);
        caps = gst_video_format_to_caps(fip->format);
        if (caps)
            gst_caps_append(out_caps, caps);
    }
    return out_caps;
}

/* Find display attribute */
static const GstVaapiProperty *
find_property(GArray *properties, const gchar *name)
{
    GstVaapiProperty *prop;
    guint i;

    if (!name)
        return NULL;

    for (i = 0; i < properties->len; i++) {
        prop = &g_array_index(properties, GstVaapiProperty, i);
        if (strcmp(prop->name, name) == 0)
            return prop;
    }
    return NULL;
}

#if 0
static const GstVaapiProperty *
find_property_by_type(GArray *properties, VADisplayAttribType type)
{
    GstVaapiProperty *prop;
    guint i;

    for (i = 0; i < properties->len; i++) {
        prop = &g_array_index(properties, GstVaapiProperty, i);
        if (prop->attribute.type == type)
            return prop;
    }
    return NULL;
}
#endif

static inline const GstVaapiProperty *
find_property_by_pspec(GstVaapiDisplay *display, GParamSpec *pspec)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);

    return find_property(priv->properties, pspec->name);
}

static guint
find_property_id(const gchar *name)
{
    typedef struct {
        const gchar *name;
        guint id;
    } property_map;

    static const property_map g_property_map[] = {
        { GST_VAAPI_DISPLAY_PROP_RENDER_MODE,   PROP_RENDER_MODE },
        { GST_VAAPI_DISPLAY_PROP_ROTATION,      PROP_ROTATION    },
        { GST_VAAPI_DISPLAY_PROP_HUE,           PROP_HUE         },
        { GST_VAAPI_DISPLAY_PROP_SATURATION,    PROP_SATURATION  },
        { GST_VAAPI_DISPLAY_PROP_BRIGHTNESS,    PROP_BRIGHTNESS  },
        { GST_VAAPI_DISPLAY_PROP_CONTRAST,      PROP_CONTRAST    },
        { NULL, }
    };

    const property_map *m;
    for (m = g_property_map; m->name != NULL; m++) {
        if (strcmp(m->name, name) == 0)
            return m->id;
    }
    return 0;
}

static void
gst_vaapi_display_calculate_pixel_aspect_ratio(GstVaapiDisplay *display)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);
    gdouble ratio, delta;
    gint i, j, index, windex;

    static const gint par[][2] = {
        {1, 1},         /* regular screen            */
        {16, 15},       /* PAL TV                    */
        {11, 10},       /* 525 line Rec.601 video    */
        {54, 59},       /* 625 line Rec.601 video    */
        {64, 45},       /* 1280x1024 on 16:9 display */
        {5, 3},         /* 1280x1024 on  4:3 display */
        {4, 3}          /*  800x600  on 16:9 display */
    };

    /* First, calculate the "real" ratio based on the X values;
     * which is the "physical" w/h divided by the w/h in pixels of the
     * display */
    if (!priv->width || !priv->height || !priv->width_mm || !priv->height_mm)
        ratio = 1.0;
    else
        ratio = (gdouble)(priv->width_mm * priv->height) /
            (priv->height_mm * priv->width);
    GST_DEBUG("calculated pixel aspect ratio: %f", ratio);

    /* Now, find the one from par[][2] with the lowest delta to the real one */
#define DELTA(idx, w) (ABS(ratio - ((gdouble)par[idx][w] / par[idx][!(w)])))
    delta  = DELTA(0, 0);
    index  = 0;
    windex = 0;

    for (i = 1; i < G_N_ELEMENTS(par); i++) {
        for (j = 0; j < 2; j++) {
            const gdouble this_delta = DELTA(i, j);
            if (this_delta < delta) {
                index  = i;
                windex = j;
                delta  = this_delta;
            }
        }
    }
#undef DELTA

    priv->par_n = par[index][windex];
    priv->par_d = par[index][windex ^ 1];
}

static void
gst_vaapi_display_destroy(GstVaapiDisplay *display)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);

    if (priv->decoders) {
        g_array_free(priv->decoders, TRUE);
        priv->decoders = NULL;
    }

    if (priv->encoders) {
        g_array_free(priv->encoders, TRUE);
        priv->encoders = NULL;
    }

    if (priv->image_formats) {
        g_array_free(priv->image_formats, TRUE);
        priv->image_formats = NULL;
    }

    if (priv->subpicture_formats) {
        g_array_free(priv->subpicture_formats, TRUE);
        priv->subpicture_formats = NULL;
    }

    if (priv->properties) {
        g_array_free(priv->properties, TRUE);
        priv->properties = NULL;
    }

    if (priv->display) {
        if (!priv->parent)
            vaTerminate(priv->display);
        priv->display = NULL;
    }

    if (!priv->use_foreign_display) {
        GstVaapiDisplayClass *klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
        if (klass->close_display)
            klass->close_display(display);
    }

    gst_vaapi_display_replace_internal(&priv->parent, NULL);

    if (g_display_cache) {
        gst_vaapi_display_cache_remove(get_display_cache(), display);
        free_display_cache();
    }
}

static gboolean
gst_vaapi_display_create(GstVaapiDisplay *display,
    GstVaapiDisplayInitType init_type, gpointer init_value)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);
    const GstVaapiDisplayClass * const klass =
        GST_VAAPI_DISPLAY_GET_CLASS(display);
    GstVaapiDisplayCache *cache;
    gboolean            has_errors      = TRUE;
    VADisplayAttribute *display_attrs   = NULL;
    VAProfile          *profiles        = NULL;
    VAEntrypoint       *entrypoints     = NULL;
    VAImageFormat      *formats         = NULL;
    unsigned int       *flags           = NULL;
    gint                i, j, n, num_entrypoints, major_version, minor_version;
    VAStatus            status;
    GstVaapiDisplayInfo info;
    const GstVaapiDisplayInfo *cached_info = NULL;

    memset(&info, 0, sizeof(info));
    info.display = display;
    info.display_type = priv->display_type;

    switch (init_type) {
    case GST_VAAPI_DISPLAY_INIT_FROM_VA_DISPLAY:
        info.va_display = init_value;
        priv->display = init_value;
        priv->use_foreign_display = TRUE;
        break;
    case GST_VAAPI_DISPLAY_INIT_FROM_DISPLAY_NAME:
        if (klass->open_display && !klass->open_display(display, init_value))
            return FALSE;
        goto create_display;
    case GST_VAAPI_DISPLAY_INIT_FROM_NATIVE_DISPLAY:
        if (klass->bind_display && !klass->bind_display(display, init_value))
            return FALSE;
        // fall-through
    create_display:
        if (!klass->get_display || !klass->get_display(display, &info))
            return FALSE;
        priv->display = info.va_display;
        priv->display_type = info.display_type;
        if (klass->get_size)
            klass->get_size(display, &priv->width, &priv->height);
        if (klass->get_size_mm)
            klass->get_size_mm(display, &priv->width_mm, &priv->height_mm);
        gst_vaapi_display_calculate_pixel_aspect_ratio(display);
        break;
    }
    if (!priv->display)
        return FALSE;

    cache = get_display_cache();
    if (!cache)
        return FALSE;
    cached_info = gst_vaapi_display_cache_lookup_by_va_display(cache,
        info.va_display);
    if (cached_info) {
        gst_vaapi_display_replace_internal(&priv->parent,
            cached_info->display);
        priv->display_type = cached_info->display_type;
    }

    if (!priv->parent) {
        status = vaInitialize(priv->display, &major_version, &minor_version);
        if (!vaapi_check_status(status, "vaInitialize()"))
            goto end;
        GST_DEBUG("VA-API version %d.%d", major_version, minor_version);
    }

    /* VA profiles */
    profiles = g_new(VAProfile, vaMaxNumProfiles(priv->display));
    if (!profiles)
        goto end;
    entrypoints = g_new(VAEntrypoint, vaMaxNumEntrypoints(priv->display));
    if (!entrypoints)
        goto end;
    status = vaQueryConfigProfiles(priv->display, profiles, &n);
    if (!vaapi_check_status(status, "vaQueryConfigProfiles()"))
        goto end;

    GST_DEBUG("%d profiles", n);
    for (i = 0; i < n; i++) {
#if VA_CHECK_VERSION(0,34,0)
        /* Introduced in VA/VPP API */
        if (profiles[i] == VAProfileNone)
            continue;
#endif
        GST_DEBUG("  %s", string_of_VAProfile(profiles[i]));
    }

    priv->decoders = g_array_new(FALSE, FALSE, sizeof(GstVaapiConfig));
    if (!priv->decoders)
        goto end;
    priv->encoders = g_array_new(FALSE, FALSE, sizeof(GstVaapiConfig));
    if (!priv->encoders)
        goto end;

    for (i = 0; i < n; i++) {
        GstVaapiConfig config;

        config.profile = gst_vaapi_profile(profiles[i]);
        if (!config.profile)
            continue;

        status = vaQueryConfigEntrypoints(
            priv->display,
            profiles[i],
            entrypoints, &num_entrypoints
        );
        if (!vaapi_check_status(status, "vaQueryConfigEntrypoints()"))
            continue;

        for (j = 0; j < num_entrypoints; j++) {
            config.entrypoint = gst_vaapi_entrypoint(entrypoints[j]);
            switch (config.entrypoint) {
            case GST_VAAPI_ENTRYPOINT_VLD:
            case GST_VAAPI_ENTRYPOINT_IDCT:
            case GST_VAAPI_ENTRYPOINT_MOCO:
                g_array_append_val(priv->decoders, config);
                break;
            case GST_VAAPI_ENTRYPOINT_SLICE_ENCODE:
                g_array_append_val(priv->encoders, config);
                break;
            }
        }
    }
    append_h263_config(priv->decoders);

    /* VA display attributes */
    display_attrs =
        g_new(VADisplayAttribute, vaMaxNumDisplayAttributes(priv->display));
    if (!display_attrs)
        goto end;

    n = 0; /* XXX: workaround old GMA500 bug */
    status = vaQueryDisplayAttributes(priv->display, display_attrs, &n);
    if (!vaapi_check_status(status, "vaQueryDisplayAttributes()"))
        goto end;

    priv->properties = g_array_new(FALSE, FALSE, sizeof(GstVaapiProperty));
    if (!priv->properties)
        goto end;

    GST_DEBUG("%d display attributes", n);
    for (i = 0; i < n; i++) {
        VADisplayAttribute * const attr = &display_attrs[i];
        GstVaapiProperty prop;
        gint value;

        GST_DEBUG("  %s", string_of_VADisplayAttributeType(attr->type));

        switch (attr->type) {
#if !VA_CHECK_VERSION(0,34,0)
        case VADisplayAttribDirectSurface:
            prop.name = GST_VAAPI_DISPLAY_PROP_RENDER_MODE;
            break;
#endif
        case VADisplayAttribRenderMode:
            prop.name = GST_VAAPI_DISPLAY_PROP_RENDER_MODE;
            break;
        case VADisplayAttribRotation:
            prop.name = GST_VAAPI_DISPLAY_PROP_ROTATION;
            break;
        case VADisplayAttribHue:
            prop.name = GST_VAAPI_DISPLAY_PROP_HUE;
            break;
        case VADisplayAttribSaturation:
            prop.name = GST_VAAPI_DISPLAY_PROP_SATURATION;
            break;
        case VADisplayAttribBrightness:
            prop.name = GST_VAAPI_DISPLAY_PROP_BRIGHTNESS;
            break;
        case VADisplayAttribContrast:
            prop.name = GST_VAAPI_DISPLAY_PROP_CONTRAST;
            break;
        default:
            prop.name = NULL;
            break;
        }
        if (!prop.name)
            continue;

        /* Assume the attribute is really supported if we can get the
         * actual and current value */
        if (!get_attribute(display, attr->type, &value))
            continue;

        /* Some drivers (e.g. EMGD) have completely random initial
         * values */
        if (value < attr->min_value || value > attr->max_value)
            continue;

        prop.attribute = *attr;
        prop.old_value = value;
        g_array_append_val(priv->properties, prop);
    }

    /* VA image formats */
    formats = g_new(VAImageFormat, vaMaxNumImageFormats(priv->display));
    if (!formats)
        goto end;
    status = vaQueryImageFormats(priv->display, formats, &n);
    if (!vaapi_check_status(status, "vaQueryImageFormats()"))
        goto end;

    GST_DEBUG("%d image formats", n);
    for (i = 0; i < n; i++)
        GST_DEBUG("  %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS(formats[i].fourcc));

    priv->image_formats =
        g_array_new(FALSE, FALSE, sizeof(GstVaapiFormatInfo));
    if (!priv->image_formats)
        goto end;
    append_formats(priv->image_formats, formats, NULL, n);
    g_array_sort(priv->image_formats, compare_yuv_formats);

    /* VA subpicture formats */
    n = vaMaxNumSubpictureFormats(priv->display);
    formats = g_renew(VAImageFormat, formats, n);
    flags   = g_new(guint, n);
    if (!formats || !flags)
        goto end;
    status = vaQuerySubpictureFormats(priv->display, formats, flags, (guint *)&n);
    if (!vaapi_check_status(status, "vaQuerySubpictureFormats()"))
        goto end;

    GST_DEBUG("%d subpicture formats", n);
    for (i = 0; i < n; i++) {
        GST_DEBUG("  %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS(formats[i].fourcc));
        flags[i] = to_GstVaapiSubpictureFlags(flags[i]);
    }

    priv->subpicture_formats =
        g_array_new(FALSE, FALSE, sizeof(GstVaapiFormatInfo));
    if (!priv->subpicture_formats)
        goto end;
    append_formats(priv->subpicture_formats, formats, flags, n);
    g_array_sort(priv->subpicture_formats, compare_rgb_formats);

    if (!cached_info) {
        if (!gst_vaapi_display_cache_add(cache, &info))
            goto end;
    }

    has_errors = FALSE;
end:
    g_free(display_attrs);
    g_free(profiles);
    g_free(entrypoints);
    g_free(formats);
    g_free(flags);
    return !has_errors;
}

static void
gst_vaapi_display_lock_default(GstVaapiDisplay *display)
{
    GstVaapiDisplayPrivate *priv = GST_VAAPI_DISPLAY_GET_PRIVATE(display);

    if (priv->parent)
        priv = GST_VAAPI_DISPLAY_GET_PRIVATE(priv->parent);
    g_rec_mutex_lock(&priv->mutex);
}

static void
gst_vaapi_display_unlock_default(GstVaapiDisplay *display)
{
    GstVaapiDisplayPrivate *priv = GST_VAAPI_DISPLAY_GET_PRIVATE(display);

    if (priv->parent)
        priv = GST_VAAPI_DISPLAY_GET_PRIVATE(priv->parent);
    g_rec_mutex_unlock(&priv->mutex);
}

static void
gst_vaapi_display_init(GstVaapiDisplay *display)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);
    const GstVaapiDisplayClass * const dpy_class =
        GST_VAAPI_DISPLAY_GET_CLASS(display);

    priv->display_type  = GST_VAAPI_DISPLAY_TYPE_ANY;
    priv->par_n         = 1;
    priv->par_d         = 1;

    g_rec_mutex_init(&priv->mutex);

    if (dpy_class->init)
        dpy_class->init(display);
}

static void
gst_vaapi_display_finalize(GstVaapiDisplay *display)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);

    gst_vaapi_display_destroy(display);
    g_rec_mutex_clear(&priv->mutex);
}

void
gst_vaapi_display_class_init(GstVaapiDisplayClass *klass)
{
    GstVaapiMiniObjectClass * const object_class =
        GST_VAAPI_MINI_OBJECT_CLASS(klass);
    GstVaapiDisplayClass * const dpy_class = GST_VAAPI_DISPLAY_CLASS(klass);

    libgstvaapi_init_once();

    object_class->size          = sizeof(GstVaapiDisplay);
    object_class->finalize      = (GDestroyNotify)gst_vaapi_display_finalize;
    dpy_class->lock             = gst_vaapi_display_lock_default;
    dpy_class->unlock           = gst_vaapi_display_unlock_default;
}

static void
gst_vaapi_display_properties_init(void)
{
    /**
     * GstVaapiDisplay:render-mode:
     *
     * The VA display rendering mode, expressed as a #GstVaapiRenderMode.
     */
    g_properties[PROP_RENDER_MODE] =
        g_param_spec_enum(GST_VAAPI_DISPLAY_PROP_RENDER_MODE,
                          "render mode",
                          "The display rendering mode",
                          GST_VAAPI_TYPE_RENDER_MODE,
                          DEFAULT_RENDER_MODE,
                          G_PARAM_READWRITE);

    /**
     * GstVaapiDisplay:rotation:
     *
     * The VA display rotation mode, expressed as a #GstVaapiRotation.
     */
    g_properties[PROP_ROTATION] =
        g_param_spec_enum(GST_VAAPI_DISPLAY_PROP_ROTATION,
                          "rotation",
                          "The display rotation mode",
                          GST_VAAPI_TYPE_ROTATION,
                          DEFAULT_ROTATION,
                          G_PARAM_READWRITE);

    /**
     * GstVaapiDisplay:hue:
     *
     * The VA display hue, expressed as a float value. Range is -180.0
     * to 180.0. Default value is 0.0 and represents no modification.
     */
    g_properties[PROP_HUE] =
        g_param_spec_float(GST_VAAPI_DISPLAY_PROP_HUE,
                           "hue",
                           "The display hue value",
                           -180.0, 180.0, 0.0,
                           G_PARAM_READWRITE);

    /**
     * GstVaapiDisplay:saturation:
     *
     * The VA display saturation, expressed as a float value. Range is
     * 0.0 to 2.0. Default value is 1.0 and represents no modification.
     */
    g_properties[PROP_SATURATION] =
        g_param_spec_float(GST_VAAPI_DISPLAY_PROP_SATURATION,
                           "saturation",
                           "The display saturation value",
                           0.0, 2.0, 1.0,
                           G_PARAM_READWRITE);

    /**
     * GstVaapiDisplay:brightness:
     *
     * The VA display brightness, expressed as a float value. Range is
     * -1.0 to 1.0. Default value is 0.0 and represents no modification.
     */
    g_properties[PROP_BRIGHTNESS] =
        g_param_spec_float(GST_VAAPI_DISPLAY_PROP_BRIGHTNESS,
                           "brightness",
                           "The display brightness value",
                           -1.0, 1.0, 0.0,
                           G_PARAM_READWRITE);

    /**
     * GstVaapiDisplay:contrast:
     *
     * The VA display contrast, expressed as a float value. Range is
     * 0.0 to 2.0. Default value is 1.0 and represents no modification.
     */
    g_properties[PROP_CONTRAST] =
        g_param_spec_float(GST_VAAPI_DISPLAY_PROP_CONTRAST,
                           "contrast",
                           "The display contrast value",
                           0.0, 2.0, 1.0,
                           G_PARAM_READWRITE);
}

static inline const GstVaapiDisplayClass *
gst_vaapi_display_class(void)
{
    static GstVaapiDisplayClass g_class;
    static gsize g_class_init = FALSE;

    if (g_once_init_enter(&g_class_init)) {
        gst_vaapi_display_class_init(&g_class);
        g_once_init_leave(&g_class_init, TRUE);
    }
    return &g_class;
}

GstVaapiDisplay *
gst_vaapi_display_new(const GstVaapiDisplayClass *klass,
    GstVaapiDisplayInitType init_type, gpointer init_value)
{
    GstVaapiDisplay *display;

    display = (GstVaapiDisplay *)
        gst_vaapi_mini_object_new0(GST_VAAPI_MINI_OBJECT_CLASS(klass));
    if (!display)
        return NULL;

    gst_vaapi_display_init(display);
    if (!gst_vaapi_display_create(display, init_type, init_value))
        goto error;
    return display;

error:
    gst_vaapi_display_unref_internal(display);
    return NULL;
}

/**
 * gst_vaapi_display_new_with_display:
 * @va_display: a #VADisplay
 *
 * Creates a new #GstVaapiDisplay, using @va_display as the VA
 * display.
 *
 * Return value: the newly created #GstVaapiDisplay object
 */
GstVaapiDisplay *
gst_vaapi_display_new_with_display(VADisplay va_display)
{
    GstVaapiDisplayCache * const cache = get_display_cache();
    const GstVaapiDisplayInfo *info;

    g_return_val_if_fail(va_display != NULL, NULL);
    g_return_val_if_fail(cache != NULL, NULL);

    info = gst_vaapi_display_cache_lookup_by_va_display(cache, va_display);
    if (info)
        return gst_vaapi_display_ref_internal(info->display);

    return gst_vaapi_display_new(gst_vaapi_display_class(),
        GST_VAAPI_DISPLAY_INIT_FROM_VA_DISPLAY, va_display);
}

/**
 * gst_vaapi_display_ref:
 * @display: a #GstVaapiDisplay
 *
 * Atomically increases the reference count of the given @display by one.
 *
 * Returns: The same @display argument
 */
GstVaapiDisplay *
gst_vaapi_display_ref(GstVaapiDisplay *display)
{
    return gst_vaapi_display_ref_internal(display);
}

/**
 * gst_vaapi_display_unref:
 * @display: a #GstVaapiDisplay
 *
 * Atomically decreases the reference count of the @display by one. If
 * the reference count reaches zero, the display will be free'd.
 */
void
gst_vaapi_display_unref(GstVaapiDisplay *display)
{
    gst_vaapi_display_unref_internal(display);
}

/**
 * gst_vaapi_display_replace:
 * @old_display_ptr: a pointer to a #GstVaapiDisplay
 * @new_display: a #GstVaapiDisplay
 *
 * Atomically replaces the display display held in @old_display_ptr
 * with @new_display. This means that @old_display_ptr shall reference
 * a valid display. However, @new_display can be NULL.
 */
void
gst_vaapi_display_replace(GstVaapiDisplay **old_display_ptr,
    GstVaapiDisplay *new_display)
{
    gst_vaapi_display_replace_internal(old_display_ptr, new_display);
}

/**
 * gst_vaapi_display_lock:
 * @display: a #GstVaapiDisplay
 *
 * Locks @display. If @display is already locked by another thread,
 * the current thread will block until @display is unlocked by the
 * other thread.
 */
void
gst_vaapi_display_lock(GstVaapiDisplay *display)
{
    GstVaapiDisplayClass *klass;

    g_return_if_fail(display != NULL);

    klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
    if (klass->lock)
        klass->lock(display);
}

/**
 * gst_vaapi_display_unlock:
 * @display: a #GstVaapiDisplay
 *
 * Unlocks @display. If another thread is blocked in a
 * gst_vaapi_display_lock() call for @display, it will be woken and
 * can lock @display itself.
 */
void
gst_vaapi_display_unlock(GstVaapiDisplay *display)
{
    GstVaapiDisplayClass *klass;

    g_return_if_fail(display != NULL);

    klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
    if (klass->unlock)
        klass->unlock(display);
}

/**
 * gst_vaapi_display_sync:
 * @display: a #GstVaapiDisplay
 *
 * Flushes any requests queued for the windowing system and waits until
 * all requests have been handled. This is often used for making sure
 * that the display is synchronized with the current state of the program.
 *
 * This is most useful for X11. On windowing systems where requests are
 * handled synchronously, this function will do nothing.
 */
void
gst_vaapi_display_sync(GstVaapiDisplay *display)
{
    GstVaapiDisplayClass *klass;

    g_return_if_fail(display != NULL);

    klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
    if (klass->sync)
        klass->sync(display);
    else if (klass->flush)
        klass->flush(display);
}

/**
 * gst_vaapi_display_flush:
 * @display: a #GstVaapiDisplay
 *
 * Flushes any requests queued for the windowing system.
 *
 * This is most useful for X11. On windowing systems where requests
 * are handled synchronously, this function will do nothing.
 */
void
gst_vaapi_display_flush(GstVaapiDisplay *display)
{
    GstVaapiDisplayClass *klass;

    g_return_if_fail(display != NULL);

    klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
    if (klass->flush)
        klass->flush(display);
}

/**
 * gst_vaapi_display_get_display:
 * @display: a #GstVaapiDisplay
 *
 * Returns the #GstVaapiDisplayType bound to @display.
 *
 * Return value: the #GstVaapiDisplayType
 */
GstVaapiDisplayType
gst_vaapi_display_get_display_type(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, GST_VAAPI_DISPLAY_TYPE_ANY);

    return GST_VAAPI_DISPLAY_GET_PRIVATE(display)->display_type;
}

/**
 * gst_vaapi_display_get_display:
 * @display: a #GstVaapiDisplay
 *
 * Returns the #VADisplay bound to @display.
 *
 * Return value: the #VADisplay
 */
VADisplay
gst_vaapi_display_get_display(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, NULL);

    return GST_VAAPI_DISPLAY_GET_PRIVATE(display)->display;
}

/**
 * gst_vaapi_display_get_width:
 * @display: a #GstVaapiDisplay
 *
 * Retrieves the width of a #GstVaapiDisplay.
 *
 * Return value: the width of the @display, in pixels
 */
guint
gst_vaapi_display_get_width(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, 0);

    return GST_VAAPI_DISPLAY_GET_PRIVATE(display)->width;
}

/**
 * gst_vaapi_display_get_height:
 * @display: a #GstVaapiDisplay
 *
 * Retrieves the height of a #GstVaapiDisplay
 *
 * Return value: the height of the @display, in pixels
 */
guint
gst_vaapi_display_get_height(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, 0);

    return GST_VAAPI_DISPLAY_GET_PRIVATE(display)->height;
}

/**
 * gst_vaapi_display_get_size:
 * @display: a #GstVaapiDisplay
 * @pwidth: return location for the width, or %NULL
 * @pheight: return location for the height, or %NULL
 *
 * Retrieves the dimensions of a #GstVaapiDisplay.
 */
void
gst_vaapi_display_get_size(GstVaapiDisplay *display, guint *pwidth, guint *pheight)
{
    g_return_if_fail(GST_VAAPI_DISPLAY(display));

    if (pwidth)
        *pwidth = GST_VAAPI_DISPLAY_GET_PRIVATE(display)->width;

    if (pheight)
        *pheight = GST_VAAPI_DISPLAY_GET_PRIVATE(display)->height;
}

/**
 * gst_vaapi_display_get_pixel_aspect_ratio:
 * @display: a #GstVaapiDisplay
 * @par_n: return location for the numerator of pixel aspect ratio, or %NULL
 * @par_d: return location for the denominator of pixel aspect ratio, or %NULL
 *
 * Retrieves the pixel aspect ratio of a #GstVaapiDisplay.
 */
void
gst_vaapi_display_get_pixel_aspect_ratio(
    GstVaapiDisplay *display,
    guint           *par_n,
    guint           *par_d
)
{
    g_return_if_fail(display != NULL);

    if (par_n)
        *par_n = GST_VAAPI_DISPLAY_GET_PRIVATE(display)->par_n;

    if (par_d)
        *par_d = GST_VAAPI_DISPLAY_GET_PRIVATE(display)->par_d;
}

/**
 * gst_vaapi_display_get_decode_caps:
 * @display: a #GstVaapiDisplay
 *
 * Gets the supported profiles for decoding as #GstCaps capabilities.
 *
 * Return value: a newly allocated #GstCaps object, possibly empty
 */
GstCaps *
gst_vaapi_display_get_decode_caps(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, NULL);

    return get_profile_caps(GST_VAAPI_DISPLAY_GET_PRIVATE(display)->decoders);
}

/**
 * gst_vaapi_display_has_decoder:
 * @display: a #GstVaapiDisplay
 * @profile: a #VAProfile
 * @entrypoint: a #GstVaaiEntrypoint
 *
 * Returns whether VA @display supports @profile for decoding at the
 * specified @entrypoint.
 *
 * Return value: %TRUE if VA @display supports @profile for decoding.
 */
gboolean
gst_vaapi_display_has_decoder(
    GstVaapiDisplay    *display,
    GstVaapiProfile     profile,
    GstVaapiEntrypoint  entrypoint
)
{
    g_return_val_if_fail(display != NULL, FALSE);

    return find_config(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->decoders, profile, entrypoint);
}

/**
 * gst_vaapi_display_get_encode_caps:
 * @display: a #GstVaapiDisplay
 *
 * Gets the supported profiles for decoding as #GstCaps capabilities.
 *
 * Return value: a newly allocated #GstCaps object, possibly empty
 */
GstCaps *
gst_vaapi_display_get_encode_caps(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, NULL);

    return get_profile_caps(GST_VAAPI_DISPLAY_GET_PRIVATE(display)->encoders);
}

/**
 * gst_vaapi_display_has_encoder:
 * @display: a #GstVaapiDisplay
 * @profile: a #VAProfile
 * @entrypoint: a #GstVaapiEntrypoint
 *
 * Returns whether VA @display supports @profile for encoding at the
 * specified @entrypoint.
 *
 * Return value: %TRUE if VA @display supports @profile for encoding.
 */
gboolean
gst_vaapi_display_has_encoder(
    GstVaapiDisplay    *display,
    GstVaapiProfile     profile,
    GstVaapiEntrypoint  entrypoint
)
{
    g_return_val_if_fail(display != NULL, FALSE);

    return find_config(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->encoders, profile, entrypoint);
}

/**
 * gst_vaapi_display_get_image_caps:
 * @display: a #GstVaapiDisplay
 *
 * Gets the supported image formats for gst_vaapi_surface_get_image()
 * or gst_vaapi_surface_put_image() as #GstCaps capabilities.
 *
 * Note that this method does not necessarily map image formats
 * returned by vaQueryImageFormats(). The set of capabilities can be
 * stripped down, if gstreamer-vaapi does not support the format, or
 * expanded to cover compatible formats not exposed by the underlying
 * driver. e.g. I420 can be supported even if the driver only exposes
 * YV12.
 *
 * Return value: a newly allocated #GstCaps object, possibly empty
 */
GstCaps *
gst_vaapi_display_get_image_caps(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, NULL);

    return get_format_caps(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->image_formats);
}

/**
 * gst_vaapi_display_has_image_format:
 * @display: a #GstVaapiDisplay
 * @format: a #GstVideoFormat
 *
 * Returns whether VA @display supports @format image format.
 *
 * Return value: %TRUE if VA @display supports @format image format
 */
gboolean
gst_vaapi_display_has_image_format(
    GstVaapiDisplay    *display,
    GstVideoFormat      format
)
{
    g_return_val_if_fail(display != NULL, FALSE);
    g_return_val_if_fail(format, FALSE);

    if (find_format(
            GST_VAAPI_DISPLAY_GET_PRIVATE(display)->image_formats, format))
        return TRUE;

    /* XXX: try subpicture formats since some drivers could report a
     * set of VA image formats that is not a superset of the set of VA
     * subpicture formats
     */
    return find_format(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->subpicture_formats, format);
}

/**
 * gst_vaapi_display_get_subpicture_caps:
 * @display: a #GstVaapiDisplay
 *
 * Gets the supported subpicture formats as #GstCaps capabilities.
 *
 * Note that this method does not necessarily map subpicture formats
 * returned by vaQuerySubpictureFormats(). The set of capabilities can
 * be stripped down if gstreamer-vaapi does not support the
 * format. e.g. this is the case for paletted formats like IA44.
 *
 * Return value: a newly allocated #GstCaps object, possibly empty
 */
GstCaps *
gst_vaapi_display_get_subpicture_caps(GstVaapiDisplay *display)
{
    g_return_val_if_fail(display != NULL, NULL);

    return get_format_caps(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->subpicture_formats);
}

/**
 * gst_vaapi_display_has_subpicture_format:
 * @display: a #GstVaapiDisplay
 * @format: a #GstVideoFormat
 * @flags_ptr: pointer to #GstVaapiSubpictureFlags, or zero
 *
 * Returns whether VA @display supports @format subpicture format with
 * the supplied @flags.
 *
 * Return value: %TRUE if VA @display supports @format subpicture format
 */
gboolean
gst_vaapi_display_has_subpicture_format(
    GstVaapiDisplay    *display,
    GstVideoFormat      format,
    guint              *flags_ptr
)
{
    const GstVaapiFormatInfo *fip;

    g_return_val_if_fail(display != NULL, FALSE);
    g_return_val_if_fail(format, FALSE);

    fip = find_format_info(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->subpicture_formats, format);
    if (!fip)
        return FALSE;

    if (flags_ptr)
        *flags_ptr = fip->flags;
    return TRUE;
}

/**
 * gst_vaapi_display_has_property:
 * @display: a #GstVaapiDisplay
 * @name: the property name to check
 *
 * Returns whether VA @display supports the requested property. The
 * check is performed against the property @name. So, the client
 * application may perform this check only once and cache this
 * information.
 *
 * Return value: %TRUE if VA @display supports property @name
 */
gboolean
gst_vaapi_display_has_property(GstVaapiDisplay *display, const gchar *name)
{
    g_return_val_if_fail(display != NULL, FALSE);
    g_return_val_if_fail(name, FALSE);

    return find_property(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->properties, name) != NULL;
}

gboolean
gst_vaapi_display_get_property(GstVaapiDisplay *display, const gchar *name,
    GValue *out_value)
{
    const GstVaapiProperty *prop;

    g_return_val_if_fail(display != NULL, FALSE);
    g_return_val_if_fail(name != NULL, FALSE);
    g_return_val_if_fail(out_value != NULL, FALSE);

    prop = find_property(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->properties, name);
    if (!prop)
        return FALSE;

    switch (prop->attribute.type) {
    case VADisplayAttribRenderMode: {
        GstVaapiRenderMode mode;
        if (!gst_vaapi_display_get_render_mode(display, &mode))
            return FALSE;
        g_value_init(out_value, GST_VAAPI_TYPE_RENDER_MODE);
        g_value_set_enum(out_value, mode);
        break;
    }
    case VADisplayAttribRotation: {
        GstVaapiRotation rotation;
        rotation = gst_vaapi_display_get_rotation(display);
        g_value_init(out_value, GST_VAAPI_TYPE_ROTATION);
        g_value_set_enum(out_value, rotation);
        break;
    }
    case VADisplayAttribHue:
    case VADisplayAttribSaturation:
    case VADisplayAttribBrightness:
    case VADisplayAttribContrast: {
        gfloat value;
        if (!get_color_balance(display, find_property_id(name), &value))
            return FALSE;
        g_value_init(out_value, G_TYPE_FLOAT);
        g_value_set_float(out_value, value);
        break;
    }
    default:
        GST_WARNING("unsupported property '%s'", name);
        return FALSE;
    }
    return TRUE;
}

gboolean
gst_vaapi_display_set_property(GstVaapiDisplay *display, const gchar *name,
    const GValue *value)
{
    const GstVaapiProperty *prop;

    g_return_val_if_fail(display != NULL, FALSE);
    g_return_val_if_fail(name != NULL, FALSE);
    g_return_val_if_fail(value != NULL, FALSE);

    prop = find_property(
        GST_VAAPI_DISPLAY_GET_PRIVATE(display)->properties, name);
    if (!prop)
        return FALSE;

    switch (prop->attribute.type) {
    case VADisplayAttribRenderMode: {
        GstVaapiRenderMode mode;
        if (!G_VALUE_HOLDS(value, GST_VAAPI_TYPE_RENDER_MODE))
            return FALSE;
        mode = g_value_get_enum(value);
        return gst_vaapi_display_set_render_mode(display, mode);
    }
    case VADisplayAttribRotation: {
        GstVaapiRotation rotation;
        if (!G_VALUE_HOLDS(value, GST_VAAPI_TYPE_ROTATION))
            return FALSE;
        rotation = g_value_get_enum(value);
        return gst_vaapi_display_set_rotation(display, rotation);
    }
    case VADisplayAttribHue:
    case VADisplayAttribSaturation:
    case VADisplayAttribBrightness:
    case VADisplayAttribContrast: {
        gfloat v;
        if (!G_VALUE_HOLDS(value, G_TYPE_FLOAT))
            return FALSE;
        v = g_value_get_float(value);
        return set_color_balance(display, find_property_id(name), v);
    }
    default:
        break;
    }

    GST_WARNING("unsupported property '%s'", name);
    return FALSE;
}

static gboolean
get_attribute(GstVaapiDisplay *display, VADisplayAttribType type, gint *value)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);
    VADisplayAttribute attr;
    VAStatus status;

    attr.type  = type;
    attr.flags = VA_DISPLAY_ATTRIB_GETTABLE;
    status = vaGetDisplayAttributes(priv->display, &attr, 1);
    if (!vaapi_check_status(status, "vaGetDisplayAttributes()"))
        return FALSE;
    *value = attr.value;
    return TRUE;
}

static gboolean
set_attribute(GstVaapiDisplay *display, VADisplayAttribType type, gint value)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);
    VADisplayAttribute attr;
    VAStatus status;

    attr.type  = type;
    attr.value = value;
    attr.flags = VA_DISPLAY_ATTRIB_SETTABLE;
    status = vaSetDisplayAttributes(priv->display, &attr, 1);
    if (!vaapi_check_status(status, "vaSetDisplayAttributes()"))
        return FALSE;
    return TRUE;
}

static gboolean
get_render_mode_VADisplayAttribRenderMode(
    GstVaapiDisplay    *display,
    GstVaapiRenderMode *pmode
)
{
    gint modes, devices;

    if (!get_attribute(display, VADisplayAttribRenderDevice, &devices))
        return FALSE;
    if (!devices)
        return FALSE;
    if (!get_attribute(display, VADisplayAttribRenderMode, &modes))
        return FALSE;

    /* Favor "overlay" mode since it is the most restrictive one */
    if (modes & (VA_RENDER_MODE_LOCAL_OVERLAY|VA_RENDER_MODE_EXTERNAL_OVERLAY))
        *pmode = GST_VAAPI_RENDER_MODE_OVERLAY;
    else
        *pmode = GST_VAAPI_RENDER_MODE_TEXTURE;
    return TRUE;
}

static gboolean
get_render_mode_VADisplayAttribDirectSurface(
    GstVaapiDisplay    *display,
    GstVaapiRenderMode *pmode
)
{
#if VA_CHECK_VERSION(0,34,0)
    /* VADisplayAttribDirectsurface was removed in VA-API >= 0.34.0 */
    return FALSE;
#else
    gint direct_surface;

    if (!get_attribute(display, VADisplayAttribDirectSurface, &direct_surface))
        return FALSE;
    if (direct_surface)
        *pmode = GST_VAAPI_RENDER_MODE_OVERLAY;
    else
        *pmode = GST_VAAPI_RENDER_MODE_TEXTURE;
    return TRUE;
#endif
}

static gboolean
get_render_mode_default(
    GstVaapiDisplay    *display,
    GstVaapiRenderMode *pmode
)
{
    GstVaapiDisplayPrivate * const priv =
        GST_VAAPI_DISPLAY_GET_PRIVATE(display);

    switch (priv->display_type) {
#if USE_WAYLAND
    case GST_VAAPI_DISPLAY_TYPE_WAYLAND:
        /* wl_buffer mapped from VA surface through vaGetSurfaceBufferWl() */
        *pmode = GST_VAAPI_RENDER_MODE_OVERLAY;
        break;
#endif
#if USE_DRM
    case GST_VAAPI_DISPLAY_TYPE_DRM:
        /* vaGetSurfaceBufferDRM() returns the underlying DRM buffer handle */
        *pmode = GST_VAAPI_RENDER_MODE_OVERLAY;
        break;
#endif
    default:
        /* This includes VA/X11 and VA/GLX modes */
        *pmode = DEFAULT_RENDER_MODE;
        break;
    }
    return TRUE;
}

/**
 * gst_vaapi_display_get_render_mode:
 * @display: a #GstVaapiDisplay
 * @pmode: return location for the VA @display rendering mode
 *
 * Returns the current VA @display rendering mode.
 *
 * Return value: %TRUE if VA @display rendering mode could be determined
 */
gboolean
gst_vaapi_display_get_render_mode(
    GstVaapiDisplay    *display,
    GstVaapiRenderMode *pmode
)
{
    g_return_val_if_fail(display != NULL, FALSE);

    /* Try with render-mode attribute */
    if (get_render_mode_VADisplayAttribRenderMode(display, pmode))
        return TRUE;

    /* Try with direct-surface attribute */
    if (get_render_mode_VADisplayAttribDirectSurface(display, pmode))
        return TRUE;

    /* Default: determine from the display type */
    return get_render_mode_default(display, pmode);
}

/**
 * gst_vaapi_display_set_render_mode:
 * @display: a #GstVaapiDisplay
 * @mode: the #GstVaapiRenderMode to set
 *
 * Sets the VA @display rendering mode to the supplied @mode. This
 * function returns %FALSE if the rendering mode could not be set,
 * e.g. run-time switching rendering mode is not supported.
 *
 * Return value: %TRUE if VA @display rendering @mode could be changed
 *   to the requested value
 */
gboolean
gst_vaapi_display_set_render_mode(
    GstVaapiDisplay   *display,
    GstVaapiRenderMode mode
)
{
    gint modes, devices;

    g_return_val_if_fail(display != NULL, FALSE);

    if (!get_attribute(display, VADisplayAttribRenderDevice, &devices))
        return FALSE;

    modes = 0;
    switch (mode) {
    case GST_VAAPI_RENDER_MODE_OVERLAY:
        if (devices & VA_RENDER_DEVICE_LOCAL)
            modes |= VA_RENDER_MODE_LOCAL_OVERLAY;
        if (devices & VA_RENDER_DEVICE_EXTERNAL)
            modes |= VA_RENDER_MODE_EXTERNAL_OVERLAY;
        break;
    case GST_VAAPI_RENDER_MODE_TEXTURE:
        if (devices & VA_RENDER_DEVICE_LOCAL)
            modes |= VA_RENDER_MODE_LOCAL_GPU;
        if (devices & VA_RENDER_DEVICE_EXTERNAL)
            modes |= VA_RENDER_MODE_EXTERNAL_GPU;
        break;
    }
    if (!modes)
        return FALSE;
    if (!set_attribute(display, VADisplayAttribRenderMode, modes))
        return FALSE;
    return TRUE;
}

/**
 * gst_vaapi_display_get_rotation:
 * @display: a #GstVaapiDisplay
 *
 * Returns the current VA @display rotation angle. If the VA driver
 * does not support "rotation" display attribute, then the display is
 * assumed to be un-rotated.
 *
 * Return value: the current #GstVaapiRotation value
 */
GstVaapiRotation
gst_vaapi_display_get_rotation(GstVaapiDisplay *display)
{
    gint value;

    g_return_val_if_fail(display != NULL, DEFAULT_ROTATION);

    if (!get_attribute(display, VADisplayAttribRotation, &value))
        value = VA_ROTATION_NONE;
    return to_GstVaapiRotation(value);
}

/**
 * gst_vaapi_display_set_rotation:
 * @display: a #GstVaapiDisplay
 * @rotation: the #GstVaapiRotation value to set
 *
 * Sets the VA @display rotation angle to the supplied @rotation
 * value. This function returns %FALSE if the rotation angle could not
 * be set, e.g. the VA driver does not allow to change the display
 * rotation angle.
 *
 * Return value: %TRUE if VA @display rotation angle could be changed
 *   to the requested value
 */
gboolean
gst_vaapi_display_set_rotation(
    GstVaapiDisplay *display,
    GstVaapiRotation rotation
)
{
    guint value;

    g_return_val_if_fail(display != NULL, FALSE);

    value = from_GstVaapiRotation(rotation);
    if (!set_attribute(display, VADisplayAttribRotation, value))
        return FALSE;
    return TRUE;
}

/* Get color balance attributes */
static gboolean
get_color_balance(GstVaapiDisplay *display, guint prop_id, gfloat *v)
{
    GParamSpecFloat * const pspec = G_PARAM_SPEC_FLOAT(g_properties[prop_id]);
    const GstVaapiProperty *prop;
    const VADisplayAttribute *attr;
    gfloat out_value;
    gint value;

    if (!pspec)
        return FALSE;

    prop = find_property_by_pspec(display, &pspec->parent_instance);
    if (!prop)
        return FALSE;
    attr = &prop->attribute;

    if (!get_attribute(display, attr->type, &value))
        return FALSE;

    /* Scale wrt. the medium ("default") value */
    out_value = pspec->default_value;
    if (value > attr->value)
        out_value += ((gfloat)(value - attr->value) /
                      (attr->max_value - attr->value) *
                      (pspec->maximum - pspec->default_value));
    else if (value < attr->value)
        out_value -= ((gfloat)(attr->value - value) /
                      (attr->value - attr->min_value) *
                      (pspec->default_value - pspec->minimum));
    *v = out_value;
    return TRUE;
}

/* Set color balance attribute */
static gboolean
set_color_balance(GstVaapiDisplay *display, guint prop_id, gfloat v)
{
    GParamSpecFloat * const pspec = G_PARAM_SPEC_FLOAT(g_properties[prop_id]);
    const GstVaapiProperty *prop;
    const VADisplayAttribute *attr;
    gint value;

    if (!pspec)
        return FALSE;

    prop = find_property_by_pspec(display, &pspec->parent_instance);
    if (!prop)
        return FALSE;
    attr = &prop->attribute;

    /* Scale wrt. the medium ("default") value */
    value = attr->value;
    if (v > pspec->default_value)
        value += ((v - pspec->default_value) /
                  (pspec->maximum - pspec->default_value) *
                  (attr->max_value - attr->value));
    else if (v < pspec->default_value)
        value -= ((pspec->default_value - v) /
                  (pspec->default_value - pspec->minimum) *
                  (attr->value - attr->min_value));
    if (!set_attribute(display, attr->type, value))
        return FALSE;
    return TRUE;
}