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

794 lines
22 KiB
C
Raw Normal View History

2010-01-25 16:15:01 +00:00
/*
* gstvaapidisplay.c - VA display abstraction
*
* gstreamer-vaapi (C) 2010 Splitted-Desktop Systems
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
2010-03-19 15:45:21 +00:00
/**
2010-03-24 08:16:32 +00:00
* SECTION:gstvaapidisplay
* @short_description: VA display abstraction
2010-03-19 15:45:21 +00:00
*/
2010-01-25 16:15:01 +00:00
#include "config.h"
2010-03-16 09:15:48 +00:00
#include "gstvaapiutils.h"
2010-01-25 16:15:01 +00:00
#include "gstvaapidisplay.h"
#include "gstvaapidisplay_priv.h"
2010-01-25 16:15:01 +00:00
#define DEBUG 1
#include "gstvaapidebug.h"
2010-01-25 16:15:01 +00:00
2010-03-10 13:13:51 +00:00
GST_DEBUG_CATEGORY(gst_debug_vaapi);
2010-01-25 16:15:01 +00:00
G_DEFINE_TYPE(GstVaapiDisplay, gst_vaapi_display, G_TYPE_OBJECT);
enum {
PROP_0,
2010-03-22 08:44:38 +00:00
PROP_DISPLAY,
PROP_WIDTH,
PROP_HEIGHT
2010-01-25 16:15:01 +00:00
};
2010-03-19 10:42:11 +00:00
/* Append GstVaapiImageFormat to formats array */
static inline void
append_format(GArray *formats, GstVaapiImageFormat format)
{
g_array_append_val(formats, format);
}
/* Append VAImageFormats to formats array */
static void
2010-03-19 10:42:11 +00:00
append_formats(GArray *formats, const VAImageFormat *va_formats, guint n)
{
2010-03-19 10:38:45 +00:00
GstVaapiImageFormat format;
gboolean has_YV12 = FALSE;
gboolean has_I420 = FALSE;
2010-03-19 10:38:45 +00:00
guint i;
for (i = 0; i < n; i++) {
const VAImageFormat * const va_format = &va_formats[i];
2010-03-19 10:38:45 +00:00
format = gst_vaapi_image_format(va_format);
if (!format) {
GST_DEBUG("unsupported format %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS(va_format->fourcc));
continue;
}
2010-03-19 10:38:45 +00:00
switch (format) {
case GST_VAAPI_IMAGE_YV12:
has_YV12 = TRUE;
break;
case GST_VAAPI_IMAGE_I420:
has_I420 = TRUE;
break;
default:
break;
}
2010-03-19 10:42:11 +00:00
append_format(formats, format);
}
/* Append I420 (resp. YV12) format if YV12 (resp. I420) is not
supported by the underlying driver */
2010-03-19 10:42:11 +00:00
if (has_YV12 && !has_I420)
append_format(formats, GST_VAAPI_IMAGE_I420);
else if (has_I420 && !has_YV12)
append_format(formats, GST_VAAPI_IMAGE_YV12);
}
/* Sort image formats. Prefer YUV formats first */
2010-03-19 10:38:45 +00:00
static gint
compare_yuv_formats(gconstpointer a, gconstpointer b)
{
2010-03-19 10:38:45 +00:00
const GstVaapiImageFormat fmt1 = *(GstVaapiImageFormat *)a;
const GstVaapiImageFormat fmt2 = *(GstVaapiImageFormat *)b;
const gboolean is_fmt1_yuv = gst_vaapi_image_format_is_yuv(fmt1);
const gboolean is_fmt2_yuv = gst_vaapi_image_format_is_yuv(fmt2);
if (is_fmt1_yuv != is_fmt2_yuv)
return is_fmt1_yuv ? -1 : 1;
2010-03-19 10:38:45 +00:00
return ((gint)gst_vaapi_image_format_get_score(fmt1) -
(gint)gst_vaapi_image_format_get_score(fmt2));
}
/* Sort subpicture formats. Prefer RGB formats first */
2010-03-19 10:38:45 +00:00
static gint
compare_rgb_formats(gconstpointer a, gconstpointer b)
{
2010-03-19 10:38:45 +00:00
const GstVaapiImageFormat fmt1 = *(GstVaapiImageFormat *)a;
const GstVaapiImageFormat fmt2 = *(GstVaapiImageFormat *)b;
const gboolean is_fmt1_rgb = gst_vaapi_image_format_is_rgb(fmt1);
const gboolean is_fmt2_rgb = gst_vaapi_image_format_is_rgb(fmt2);
if (is_fmt1_rgb != is_fmt2_rgb)
return is_fmt1_rgb ? -1 : 1;
2010-03-19 10:38:45 +00:00
return ((gint)gst_vaapi_image_format_get_score(fmt1) -
(gint)gst_vaapi_image_format_get_score(fmt2));
}
/* Check if profiles array contains profile */
static inline gboolean
find_profile(GArray *profiles, VAProfile profile)
{
guint i;
for (i = 0; i < profiles->len; i++)
if (g_array_index(profiles, VAProfile, i) == profile)
return TRUE;
return FALSE;
}
/* Check if formats array contains format */
static inline gboolean
find_format(GArray *formats, GstVaapiImageFormat format)
{
guint i;
for (i = 0; i < formats->len; i++)
if (g_array_index(formats, GstVaapiImageFormat, i) == format)
return TRUE;
return FALSE;
}
/* Convert formats array to GstCaps */
static GstCaps *
get_caps(GArray *formats)
{
GstVaapiImageFormat format;
GstCaps *out_caps, *caps;
guint i;
out_caps = gst_caps_new_empty();
if (!out_caps)
return NULL;
for (i = 0; i < formats->len; i++) {
format = g_array_index(formats, GstVaapiImageFormat, i);
caps = gst_vaapi_image_format_get_caps(format);
if (caps)
gst_caps_append(out_caps, caps);
}
return out_caps;
}
static void
gst_vaapi_display_calculate_pixel_aspect_ratio(GstVaapiDisplay *display)
{
GstVaapiDisplayPrivate * const priv = display->priv;
gdouble ratio, delta;
gint i, index;
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) (ABS(ratio - ((gdouble)par[idx][0] / par[idx][1])))
delta = DELTA(0);
index = 0;
for (i = 1; i < G_N_ELEMENTS(par); i++) {
const gdouble this_delta = DELTA(i);
if (this_delta < delta) {
index = i;
delta = this_delta;
}
}
#undef DELTA
priv->par_n = par[index][0];
priv->par_d = par[index][1];
}
2010-03-10 12:25:19 +00:00
static void
gst_vaapi_display_destroy(GstVaapiDisplay *display)
{
GstVaapiDisplayPrivate * const priv = display->priv;
if (priv->profiles) {
2010-03-19 10:38:45 +00:00
g_array_free(priv->profiles, TRUE);
2010-03-10 12:25:19 +00:00
priv->profiles = NULL;
}
if (priv->image_formats) {
2010-03-19 10:38:45 +00:00
g_array_free(priv->image_formats, TRUE);
2010-03-10 12:25:19 +00:00
priv->image_formats = NULL;
}
if (priv->subpicture_formats) {
2010-03-19 10:38:45 +00:00
g_array_free(priv->subpicture_formats, TRUE);
2010-03-10 12:25:19 +00:00
priv->subpicture_formats = NULL;
}
if (priv->display) {
vaTerminate(priv->display);
priv->display = NULL;
}
if (priv->create_display) {
GstVaapiDisplayClass *klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
if (klass->close_display)
klass->close_display(display);
}
2010-03-10 12:25:19 +00:00
}
static gboolean
gst_vaapi_display_create(GstVaapiDisplay *display)
{
GstVaapiDisplayPrivate * const priv = display->priv;
2010-03-19 10:38:45 +00:00
gboolean has_errors = TRUE;
VAProfile *profiles = NULL;
VAImageFormat *formats = NULL;
unsigned int *flags = NULL;
gint i, n, major_version, minor_version;
VAStatus status;
2010-03-10 12:25:19 +00:00
if (!priv->display && priv->create_display) {
GstVaapiDisplayClass *klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
if (klass->open_display && !klass->open_display(display))
return FALSE;
2010-03-25 12:39:54 +00:00
if (klass->get_display) {
priv->display = klass->get_display(display);
2010-03-25 12:39:54 +00:00
if (!priv->display)
return FALSE;
}
2010-03-22 08:44:38 +00:00
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);
}
if (!priv->display)
return FALSE;
2010-03-10 12:25:19 +00:00
status = vaInitialize(priv->display, &major_version, &minor_version);
if (!vaapi_check_status(status, "vaInitialize()"))
2010-03-19 10:38:45 +00:00
goto end;
2010-03-10 13:13:51 +00:00
GST_DEBUG("VA-API version %d.%d", major_version, minor_version);
2010-03-10 12:25:19 +00:00
/* VA profiles */
2010-03-19 10:38:45 +00:00
profiles = g_new(VAProfile, vaMaxNumProfiles(priv->display));
if (!profiles)
goto end;
status = vaQueryConfigProfiles(priv->display, profiles, &n);
2010-03-10 12:25:19 +00:00
if (!vaapi_check_status(status, "vaQueryConfigProfiles()"))
2010-03-19 10:38:45 +00:00
goto end;
2010-03-10 12:25:19 +00:00
2010-03-19 10:38:45 +00:00
GST_DEBUG("%d profiles", n);
for (i = 0; i < n; i++)
GST_DEBUG(" %s", string_of_VAProfile(profiles[i]));
priv->profiles = g_array_new(FALSE, FALSE, sizeof(VAProfile));
if (!priv->profiles)
goto end;
g_array_append_vals(priv->profiles, profiles, n);
2010-03-10 12:25:19 +00:00
/* VA image formats */
2010-03-19 10:38:45 +00:00
formats = g_new(VAImageFormat, vaMaxNumImageFormats(priv->display));
if (!formats)
goto end;
status = vaQueryImageFormats(priv->display, formats, &n);
2010-03-10 12:25:19 +00:00
if (!vaapi_check_status(status, "vaQueryImageFormats()"))
2010-03-19 10:38:45 +00:00
goto end;
2010-03-10 12:25:19 +00:00
2010-03-19 10:38:45 +00:00
GST_DEBUG("%d image formats", n);
for (i = 0; i < n; i++)
GST_DEBUG(" %s", string_of_FOURCC(formats[i].fourcc));
2010-03-10 12:25:19 +00:00
2010-03-19 10:38:45 +00:00
priv->image_formats =
g_array_new(FALSE, FALSE, sizeof(GstVaapiImageFormat));
if (!priv->image_formats)
goto end;
append_formats(priv->image_formats, formats, n);
g_array_sort(priv->image_formats, compare_yuv_formats);
2010-03-10 12:25:19 +00:00
/* VA subpicture formats */
2010-03-19 10:38:45 +00:00
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, &n);
2010-03-10 12:25:19 +00:00
if (!vaapi_check_status(status, "vaQuerySubpictureFormats()"))
2010-03-19 10:38:45 +00:00
goto end;
2010-03-19 10:38:45 +00:00
GST_DEBUG("%d subpicture formats", n);
for (i = 0; i < n; i++)
GST_DEBUG(" %s", string_of_FOURCC(formats[i].fourcc));
2010-03-10 12:25:19 +00:00
2010-03-19 10:38:45 +00:00
priv->subpicture_formats =
g_array_new(FALSE, FALSE, sizeof(GstVaapiImageFormat));
if (!priv->subpicture_formats)
goto end;
append_formats(priv->subpicture_formats, formats, n);
g_array_sort(priv->subpicture_formats, compare_rgb_formats);
has_errors = FALSE;
end:
g_free(profiles);
g_free(formats);
g_free(flags);
return !has_errors;
2010-03-10 12:25:19 +00:00
}
2010-03-17 07:59:31 +00:00
static void
gst_vaapi_display_lock_default(GstVaapiDisplay *display)
{
g_static_mutex_lock(&display->priv->mutex);
}
static void
gst_vaapi_display_unlock_default(GstVaapiDisplay *display)
{
g_static_mutex_unlock(&display->priv->mutex);
}
2010-01-25 16:15:01 +00:00
static void
gst_vaapi_display_finalize(GObject *object)
{
2010-03-09 12:00:32 +00:00
GstVaapiDisplay * const display = GST_VAAPI_DISPLAY(object);
2010-01-25 16:15:01 +00:00
2010-03-10 12:25:19 +00:00
gst_vaapi_display_destroy(display);
2010-01-25 16:15:01 +00:00
G_OBJECT_CLASS(gst_vaapi_display_parent_class)->finalize(object);
}
static void
gst_vaapi_display_set_property(
GObject *object,
guint prop_id,
const GValue *value,
2010-03-15 13:32:37 +00:00
GParamSpec *pspec
)
2010-01-25 16:15:01 +00:00
{
2010-03-09 12:00:32 +00:00
GstVaapiDisplay * const display = GST_VAAPI_DISPLAY(object);
2010-01-25 16:15:01 +00:00
switch (prop_id) {
case PROP_DISPLAY:
display->priv->display = g_value_get_pointer(value);
2010-01-25 16:15:01 +00:00
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
gst_vaapi_display_get_property(
GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec
)
2010-01-25 16:15:01 +00:00
{
2010-03-09 12:00:32 +00:00
GstVaapiDisplay * const display = GST_VAAPI_DISPLAY(object);
2010-01-25 16:15:01 +00:00
switch (prop_id) {
case PROP_DISPLAY:
g_value_set_pointer(value, gst_vaapi_display_get_display(display));
break;
2010-03-22 08:44:38 +00:00
case PROP_WIDTH:
g_value_set_uint(value, gst_vaapi_display_get_width(display));
break;
case PROP_HEIGHT:
g_value_set_uint(value, gst_vaapi_display_get_height(display));
break;
2010-01-25 16:15:01 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
gst_vaapi_display_constructed(GObject *object)
{
GstVaapiDisplay * const display = GST_VAAPI_DISPLAY(object);
GObjectClass *parent_class;
display->priv->create_display = display->priv->display == NULL;
gst_vaapi_display_create(display);
parent_class = G_OBJECT_CLASS(gst_vaapi_display_parent_class);
if (parent_class->constructed)
parent_class->constructed(object);
}
2010-01-25 16:15:01 +00:00
static void
gst_vaapi_display_class_init(GstVaapiDisplayClass *klass)
{
GObjectClass * const object_class = G_OBJECT_CLASS(klass);
2010-03-17 07:59:31 +00:00
GstVaapiDisplayClass * const dpy_class = GST_VAAPI_DISPLAY_CLASS(klass);
2010-01-25 16:15:01 +00:00
2010-03-10 13:13:51 +00:00
GST_DEBUG_CATEGORY_INIT(gst_debug_vaapi, "vaapi", 0, "VA-API helper");
2010-01-25 16:15:01 +00:00
g_type_class_add_private(klass, sizeof(GstVaapiDisplayPrivate));
2010-03-17 07:59:31 +00:00
object_class->finalize = gst_vaapi_display_finalize;
object_class->set_property = gst_vaapi_display_set_property;
object_class->get_property = gst_vaapi_display_get_property;
object_class->constructed = gst_vaapi_display_constructed;
dpy_class->lock = gst_vaapi_display_lock_default;
dpy_class->unlock = gst_vaapi_display_unlock_default;
2010-01-25 16:15:01 +00:00
g_object_class_install_property
(object_class,
PROP_DISPLAY,
g_param_spec_pointer("display",
"VA display",
"VA display",
G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
2010-03-22 08:44:38 +00:00
g_object_class_install_property
(object_class,
PROP_WIDTH,
g_param_spec_uint("width",
"Width",
"The display width",
1, G_MAXUINT32, 1,
G_PARAM_READABLE));
g_object_class_install_property
(object_class,
PROP_HEIGHT,
g_param_spec_uint("height",
"height",
"The display height",
1, G_MAXUINT32, 1,
G_PARAM_READABLE));
2010-01-25 16:15:01 +00:00
}
static void
gst_vaapi_display_init(GstVaapiDisplay *display)
{
GstVaapiDisplayPrivate *priv = GST_VAAPI_DISPLAY_GET_PRIVATE(display);
2010-03-19 10:38:45 +00:00
display->priv = priv;
priv->display = NULL;
2010-03-22 08:44:38 +00:00
priv->width = 0;
priv->height = 0;
priv->width_mm = 0;
priv->height_mm = 0;
priv->par_n = 1;
priv->par_d = 1;
2010-03-19 10:38:45 +00:00
priv->profiles = NULL;
priv->image_formats = NULL;
priv->subpicture_formats = NULL;
priv->create_display = TRUE;
2010-03-17 07:59:31 +00:00
g_static_mutex_init(&priv->mutex);
2010-01-25 16:15:01 +00:00
}
2010-03-19 15:45:21 +00:00
/**
* 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
*/
2010-03-10 12:25:19 +00:00
GstVaapiDisplay *
gst_vaapi_display_new_with_display(VADisplay va_display)
2010-01-25 16:15:01 +00:00
{
2010-03-10 12:25:19 +00:00
return g_object_new(GST_VAAPI_TYPE_DISPLAY,
"display", va_display,
NULL);
2010-01-25 16:15:01 +00:00
}
2010-03-19 15:45:21 +00:00
/**
* 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.
*/
2010-03-17 07:59:31 +00:00
void
gst_vaapi_display_lock(GstVaapiDisplay *display)
{
GstVaapiDisplayClass *klass;
g_return_if_fail(GST_VAAPI_IS_DISPLAY(display));
klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
if (klass->lock)
klass->lock(display);
2010-03-17 07:59:31 +00:00
}
2010-03-19 15:45:21 +00:00
/**
* 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.
*/
2010-03-17 07:59:31 +00:00
void
gst_vaapi_display_unlock(GstVaapiDisplay *display)
{
GstVaapiDisplayClass *klass;
g_return_if_fail(GST_VAAPI_IS_DISPLAY(display));
klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
if (klass->unlock)
klass->unlock(display);
2010-03-17 07:59:31 +00:00
}
/**
* 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(GST_VAAPI_IS_DISPLAY(display));
klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
if (klass->sync)
klass->sync(display);
else if (klass->flush)
klass->flush(display);
}
/**
2010-03-29 11:25:20 +00:00
* 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(GST_VAAPI_IS_DISPLAY(display));
klass = GST_VAAPI_DISPLAY_GET_CLASS(display);
if (klass->flush)
klass->flush(display);
}
2010-03-19 15:45:21 +00:00
/**
* gst_vaapi_display_get_display:
* @display: a #GstVaapiDisplay
*
* Returns the #VADisplay bound to @display.
*
* Return value: the #VADisplay
*/
2010-03-10 12:25:19 +00:00
VADisplay
gst_vaapi_display_get_display(GstVaapiDisplay *display)
2010-01-25 16:15:01 +00:00
{
2010-03-10 12:25:19 +00:00
g_return_val_if_fail(GST_VAAPI_IS_DISPLAY(display), NULL);
2010-01-25 16:15:01 +00:00
2010-03-10 12:25:19 +00:00
return display->priv->display;
2010-01-25 16:15:01 +00:00
}
2010-03-22 08:44:38 +00:00
/**
* 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(GST_VAAPI_IS_DISPLAY(display), 0);
return display->priv->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(GST_VAAPI_IS_DISPLAY(display), 0);
return display->priv->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
2010-03-22 08:44:38 +00:00
*
* 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 = display->priv->width;
if (pheight)
*pheight = display->priv->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(GST_VAAPI_IS_DISPLAY(display));
if (par_n)
*par_n = display->priv->par_n;
if (par_d)
*par_d = display->priv->par_d;
}
2010-03-19 15:45:21 +00:00
/**
* gst_vaapi_display_has_profile:
* @display: a #GstVaapiDisplay
* @profile: a #VAProfile
*
* Returns whether VA @display supports @profile.
*
* Return value: %TRUE if VA @display supports @profile
*/
gboolean
gst_vaapi_display_has_profile(GstVaapiDisplay *display, VAProfile profile)
{
g_return_val_if_fail(GST_VAAPI_IS_DISPLAY(display), FALSE);
2010-03-19 10:38:45 +00:00
return find_profile(display->priv->profiles, profile);
}
2010-03-19 15:45:21 +00:00
/**
* 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(GST_VAAPI_IS_DISPLAY(display), NULL);
2010-03-19 10:38:45 +00:00
return get_caps(display->priv->image_formats);
}
2010-03-19 15:45:21 +00:00
/**
* gst_vaapi_display_has_image_format:
* @display: a #GstVaapiDisplay
* @format: a #GstVaapiFormat
*
* 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,
GstVaapiImageFormat format
)
{
g_return_val_if_fail(GST_VAAPI_IS_DISPLAY(display), FALSE);
2010-03-19 10:38:45 +00:00
g_return_val_if_fail(format, FALSE);
2010-03-19 10:38:45 +00:00
return find_format(display->priv->image_formats, format);
}
2010-03-19 15:45:21 +00:00
/**
* 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(GST_VAAPI_IS_DISPLAY(display), NULL);
2010-03-19 10:38:45 +00:00
return get_caps(display->priv->subpicture_formats);
}
2010-03-19 15:45:21 +00:00
/**
* gst_vaapi_display_has_subpicture_format:
* @display: a #GstVaapiDisplay
* @format: a #GstVaapiFormat
*
* Returns whether VA @display supports @format subpicture format.
*
* Return value: %TRUE if VA @display supports @format subpicture format
*/
gboolean
gst_vaapi_display_has_subpicture_format(
GstVaapiDisplay *display,
GstVaapiImageFormat format
)
{
g_return_val_if_fail(GST_VAAPI_IS_DISPLAY(display), FALSE);
2010-03-19 10:38:45 +00:00
g_return_val_if_fail(format, FALSE);
2010-03-19 10:38:45 +00:00
return find_format(display->priv->subpicture_formats, format);
}