mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
1067 lines
28 KiB
C
1067 lines
28 KiB
C
/*
|
|
* gstvaapiimage.c - VA image abstraction
|
|
*
|
|
* Copyright (C) 2010-2011 Splitted-Desktop Systems
|
|
* Author: Gwenole Beauchesne <gwenole.beauchesne@splitted-desktop.com>
|
|
* Copyright (C) 2011-2013 Intel Corporation
|
|
* 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
|
|
*/
|
|
|
|
/**
|
|
* SECTION:gstvaapiimage
|
|
* @short_description: VA image abstraction
|
|
*/
|
|
|
|
#include "sysdeps.h"
|
|
#include "gstvaapicompat.h"
|
|
#include "gstvaapiutils.h"
|
|
#include "gstvaapiimage.h"
|
|
#include "gstvaapiimage_priv.h"
|
|
|
|
#define DEBUG 1
|
|
#include "gstvaapidebug.h"
|
|
|
|
#define SWAP_UINT(a, b) do { \
|
|
guint v = a; \
|
|
a = b; \
|
|
b = v; \
|
|
} while (0)
|
|
|
|
static gboolean
|
|
_gst_vaapi_image_map (GstVaapiImage * image, GstVaapiImageRaw * raw_image);
|
|
|
|
static gboolean _gst_vaapi_image_unmap (GstVaapiImage * image);
|
|
|
|
static gboolean
|
|
_gst_vaapi_image_set_image (GstVaapiImage * image, const VAImage * va_image);
|
|
|
|
/*
|
|
* VAImage wrapper
|
|
*/
|
|
|
|
static gboolean
|
|
vaapi_image_is_linear (const VAImage * va_image)
|
|
{
|
|
guint i, width, height, width2, height2, data_size;
|
|
|
|
for (i = 1; i < va_image->num_planes; i++)
|
|
if (va_image->offsets[i] < va_image->offsets[i - 1])
|
|
return FALSE;
|
|
|
|
width = va_image->width;
|
|
height = va_image->height;
|
|
width2 = (width + 1) / 2;
|
|
height2 = (height + 1) / 2;
|
|
|
|
switch (va_image->format.fourcc) {
|
|
case VA_FOURCC ('N', 'V', '1', '2'):
|
|
case VA_FOURCC ('Y', 'V', '1', '2'):
|
|
case VA_FOURCC ('I', '4', '2', '0'):
|
|
data_size = width * height + 2 * width2 * height2;
|
|
break;
|
|
case VA_FOURCC ('Y', 'U', 'Y', '2'):
|
|
case VA_FOURCC ('U', 'Y', 'V', 'Y'):
|
|
case VA_FOURCC ('R', 'G', '1', '6'):
|
|
data_size = 2 * width * height;
|
|
break;
|
|
case VA_FOURCC ('Y', '8', '0', '0'):
|
|
data_size = width * height;
|
|
break;
|
|
case VA_FOURCC ('A', 'Y', 'U', 'V'):
|
|
case VA_FOURCC ('A', 'R', 'G', 'B'):
|
|
case VA_FOURCC ('R', 'G', 'B', 'A'):
|
|
case VA_FOURCC ('A', 'B', 'G', 'R'):
|
|
case VA_FOURCC ('B', 'G', 'R', 'A'):
|
|
case VA_FOURCC ('X', 'R', 'G', 'B'):
|
|
case VA_FOURCC ('R', 'G', 'B', 'X'):
|
|
case VA_FOURCC ('X', 'B', 'G', 'R'):
|
|
case VA_FOURCC ('B', 'G', 'R', 'X'):
|
|
case VA_FOURCC ('Y', '2', '1', '0'):
|
|
case VA_FOURCC ('Y', '4', '1', '0'):
|
|
case VA_FOURCC ('A', 'R', '3', '0'):
|
|
data_size = 4 * width * height;
|
|
break;
|
|
case VA_FOURCC ('P', '0', '1', '0'):
|
|
data_size = 2 * (width * height + 2 * width2 * height2);
|
|
break;
|
|
case VA_FOURCC ('R', 'G', '2', '4'):
|
|
case VA_FOURCC ('4', '4', '4', 'P'):
|
|
data_size = 3 * width * height;
|
|
break;
|
|
default:
|
|
GST_ERROR ("FIXME: incomplete formats %" GST_FOURCC_FORMAT,
|
|
GST_FOURCC_ARGS (va_image->format.fourcc));
|
|
data_size = G_MAXUINT;
|
|
break;
|
|
}
|
|
return va_image->data_size == data_size;
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_image_free (GstVaapiImage * image)
|
|
{
|
|
GstVaapiDisplay *const display = GST_VAAPI_IMAGE_DISPLAY (image);
|
|
VAImageID image_id;
|
|
VAStatus status;
|
|
|
|
_gst_vaapi_image_unmap (image);
|
|
|
|
image_id = GST_VAAPI_IMAGE_ID (image);
|
|
GST_DEBUG ("image %" GST_VAAPI_ID_FORMAT, GST_VAAPI_ID_ARGS (image_id));
|
|
|
|
if (image_id != VA_INVALID_ID) {
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaDestroyImage (GST_VAAPI_DISPLAY_VADISPLAY (display), image_id);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (!vaapi_check_status (status, "vaDestroyImage()"))
|
|
GST_WARNING ("failed to destroy image %" GST_VAAPI_ID_FORMAT,
|
|
GST_VAAPI_ID_ARGS (image_id));
|
|
GST_VAAPI_IMAGE_ID (image) = VA_INVALID_ID;
|
|
}
|
|
|
|
gst_vaapi_display_replace (&GST_VAAPI_IMAGE_DISPLAY (image), NULL);
|
|
|
|
g_slice_free1 (sizeof (GstVaapiImage), image);
|
|
}
|
|
|
|
static gboolean
|
|
_gst_vaapi_image_create (GstVaapiImage * image, GstVideoFormat format)
|
|
{
|
|
GstVaapiDisplay *const display = GST_VAAPI_IMAGE_DISPLAY (image);
|
|
const VAImageFormat *va_format;
|
|
VAStatus status;
|
|
|
|
if (!gst_vaapi_display_has_image_format (display, format))
|
|
return FALSE;
|
|
|
|
va_format = gst_vaapi_video_format_to_va_format (format);
|
|
if (!va_format)
|
|
return FALSE;
|
|
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaCreateImage (GST_VAAPI_DISPLAY_VADISPLAY (display),
|
|
(VAImageFormat *) va_format,
|
|
image->width, image->height, &image->internal_image);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (status != VA_STATUS_SUCCESS ||
|
|
image->internal_image.format.fourcc != va_format->fourcc)
|
|
return FALSE;
|
|
|
|
image->internal_format = format;
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_vaapi_image_create (GstVaapiImage * image, GstVideoFormat format,
|
|
guint width, guint height)
|
|
{
|
|
const VAImageFormat *va_format;
|
|
VAImageID image_id;
|
|
|
|
image->format = format;
|
|
image->width = width;
|
|
image->height = height;
|
|
|
|
if (!_gst_vaapi_image_create (image, format)) {
|
|
switch (format) {
|
|
case GST_VIDEO_FORMAT_I420:
|
|
format = GST_VIDEO_FORMAT_YV12;
|
|
break;
|
|
case GST_VIDEO_FORMAT_YV12:
|
|
format = GST_VIDEO_FORMAT_I420;
|
|
break;
|
|
default:
|
|
format = 0;
|
|
break;
|
|
}
|
|
if (!format || !_gst_vaapi_image_create (image, format))
|
|
return FALSE;
|
|
}
|
|
image->image = image->internal_image;
|
|
image_id = image->image.image_id;
|
|
|
|
if (image->format != image->internal_format) {
|
|
switch (image->format) {
|
|
case GST_VIDEO_FORMAT_YV12:
|
|
case GST_VIDEO_FORMAT_I420:
|
|
va_format = gst_vaapi_video_format_to_va_format (image->format);
|
|
if (!va_format)
|
|
return FALSE;
|
|
image->image.format = *va_format;
|
|
SWAP_UINT (image->image.offsets[1], image->image.offsets[2]);
|
|
SWAP_UINT (image->image.pitches[1], image->image.pitches[2]);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
image->is_linear = vaapi_image_is_linear (&image->image);
|
|
|
|
GST_DEBUG ("image %" GST_VAAPI_ID_FORMAT, GST_VAAPI_ID_ARGS (image_id));
|
|
GST_VAAPI_IMAGE_ID (image) = image_id;
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_image_init (GstVaapiImage * image, GstVaapiDisplay * display)
|
|
{
|
|
/* TODO(victor): implement image copy mechanism, it's almost
|
|
* there */
|
|
gst_mini_object_init (GST_MINI_OBJECT_CAST (image), 0,
|
|
GST_TYPE_VAAPI_IMAGE, NULL, NULL,
|
|
(GstMiniObjectFreeFunction) gst_vaapi_image_free);
|
|
|
|
GST_VAAPI_IMAGE_DISPLAY (image) = gst_object_ref (display);
|
|
GST_VAAPI_IMAGE_ID (image) = VA_INVALID_ID;
|
|
image->internal_image.image_id = VA_INVALID_ID;
|
|
image->internal_image.buf = VA_INVALID_ID;
|
|
image->image.image_id = VA_INVALID_ID;
|
|
image->image.buf = VA_INVALID_ID;
|
|
image->image_data = NULL;
|
|
image->internal_format = image->format = GST_VIDEO_FORMAT_UNKNOWN;
|
|
image->width = image->height = 0;
|
|
image->is_linear = FALSE;
|
|
}
|
|
|
|
GST_DEFINE_MINI_OBJECT_TYPE (GstVaapiImage, gst_vaapi_image);
|
|
|
|
/**
|
|
* gst_vaapi_image_get_display:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Returns the #GstVaapiDisplay this @image is bound to.
|
|
*
|
|
* Return value: the parent #GstVaapiDisplay object
|
|
*/
|
|
GstVaapiDisplay *
|
|
gst_vaapi_image_get_display (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, NULL);
|
|
return GST_VAAPI_IMAGE_DISPLAY (image);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_new:
|
|
* @display: a #GstVaapiDisplay
|
|
* @format: a #GstVideoFormat
|
|
* @width: the requested image width
|
|
* @height: the requested image height
|
|
*
|
|
* Creates a new #GstVaapiImage with the specified format and
|
|
* dimensions.
|
|
*
|
|
* Return value: the newly allocated #GstVaapiImage object
|
|
*/
|
|
GstVaapiImage *
|
|
gst_vaapi_image_new (GstVaapiDisplay * display,
|
|
GstVideoFormat format, guint width, guint height)
|
|
{
|
|
GstVaapiImage *image;
|
|
|
|
g_return_val_if_fail (width > 0, NULL);
|
|
g_return_val_if_fail (height > 0, NULL);
|
|
|
|
GST_DEBUG ("format %s, size %ux%u", gst_vaapi_video_format_to_string (format),
|
|
width, height);
|
|
|
|
image = g_slice_new (GstVaapiImage);
|
|
if (!image)
|
|
return NULL;
|
|
|
|
gst_vaapi_image_init (image, display);
|
|
|
|
if (!gst_vaapi_image_create (image, format, width, height))
|
|
goto error;
|
|
return image;
|
|
|
|
/* ERRORS */
|
|
error:
|
|
{
|
|
gst_vaapi_image_unref (image);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_new_with_image:
|
|
* @display: a #GstVaapiDisplay
|
|
* @va_image: a VA image
|
|
*
|
|
* Creates a new #GstVaapiImage from a foreign VA image. The image
|
|
* format and dimensions will be extracted from @va_image. This
|
|
* function is mainly used by gst_vaapi_surface_derive_image() to bind
|
|
* a VA image to a #GstVaapiImage object.
|
|
*
|
|
* Return value: the newly allocated #GstVaapiImage object
|
|
*/
|
|
GstVaapiImage *
|
|
gst_vaapi_image_new_with_image (GstVaapiDisplay * display, VAImage * va_image)
|
|
{
|
|
GstVaapiImage *image;
|
|
|
|
g_return_val_if_fail (va_image, NULL);
|
|
g_return_val_if_fail (va_image->image_id != VA_INVALID_ID, NULL);
|
|
g_return_val_if_fail (va_image->buf != VA_INVALID_ID, NULL);
|
|
|
|
GST_DEBUG ("VA image 0x%08x, format %" GST_FOURCC_FORMAT ", size %ux%u",
|
|
va_image->image_id,
|
|
GST_FOURCC_ARGS (va_image->format.fourcc),
|
|
va_image->width, va_image->height);
|
|
|
|
image = g_slice_new (GstVaapiImage);
|
|
if (!image)
|
|
return NULL;
|
|
|
|
gst_vaapi_image_init (image, display);
|
|
|
|
if (!_gst_vaapi_image_set_image (image, va_image))
|
|
goto error;
|
|
return image;
|
|
|
|
/* ERRORS */
|
|
error:
|
|
{
|
|
gst_vaapi_image_unref (image);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_id:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Returns the underlying VAImageID of the @image.
|
|
*
|
|
* Return value: the underlying VA image id
|
|
*/
|
|
GstVaapiID
|
|
gst_vaapi_image_get_id (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, VA_INVALID_ID);
|
|
|
|
return GST_VAAPI_IMAGE_ID (image);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_image:
|
|
* @image: a #GstVaapiImage
|
|
* @va_image: a VA image
|
|
*
|
|
* Fills @va_image with the VA image used internally.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_get_image (GstVaapiImage * image, VAImage * va_image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
|
|
if (va_image)
|
|
*va_image = image->image;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* _gst_vaapi_image_set_image:
|
|
* @image: a #GstVaapiImage
|
|
* @va_image: a VA image
|
|
*
|
|
* Initializes #GstVaapiImage with a foreign VA image. This function
|
|
* will try to "linearize" the VA image. i.e. making sure that the VA
|
|
* image offsets into the data buffer are in increasing order with the
|
|
* number of planes available in the image.
|
|
*
|
|
* This is an internal function used by gst_vaapi_image_new_with_image().
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
_gst_vaapi_image_set_image (GstVaapiImage * image, const VAImage * va_image)
|
|
{
|
|
GstVideoFormat format;
|
|
VAImage alt_va_image;
|
|
const VAImageFormat *alt_va_format;
|
|
|
|
format = gst_vaapi_video_format_from_va_format (&va_image->format);
|
|
if (format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
return FALSE;
|
|
|
|
image->internal_image = *va_image;
|
|
image->internal_format = format;
|
|
image->is_linear = vaapi_image_is_linear (va_image);
|
|
image->image = *va_image;
|
|
image->format = format;
|
|
image->width = va_image->width;
|
|
image->height = va_image->height;
|
|
|
|
GST_VAAPI_IMAGE_ID (image) = va_image->image_id;
|
|
|
|
/* Try to linearize image */
|
|
if (!image->is_linear) {
|
|
switch (format) {
|
|
case GST_VIDEO_FORMAT_I420:
|
|
format = GST_VIDEO_FORMAT_YV12;
|
|
break;
|
|
case GST_VIDEO_FORMAT_YV12:
|
|
format = GST_VIDEO_FORMAT_I420;
|
|
break;
|
|
default:
|
|
format = 0;
|
|
break;
|
|
}
|
|
if (format &&
|
|
(alt_va_format = gst_vaapi_video_format_to_va_format (format))) {
|
|
alt_va_image = *va_image;
|
|
alt_va_image.format = *alt_va_format;
|
|
SWAP_UINT (alt_va_image.offsets[1], alt_va_image.offsets[2]);
|
|
SWAP_UINT (alt_va_image.pitches[1], alt_va_image.pitches[2]);
|
|
if (vaapi_image_is_linear (&alt_va_image)) {
|
|
image->image = alt_va_image;
|
|
image->format = format;
|
|
image->is_linear = TRUE;
|
|
GST_DEBUG ("linearized image to %s format",
|
|
gst_vaapi_video_format_to_string (format));
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_format:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Returns the #GstVideoFormat the @image was created with.
|
|
*
|
|
* Return value: the #GstVideoFormat
|
|
*/
|
|
GstVideoFormat
|
|
gst_vaapi_image_get_format (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, 0);
|
|
|
|
return image->format;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_width:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Returns the @image width.
|
|
*
|
|
* Return value: the image width, in pixels
|
|
*/
|
|
guint
|
|
gst_vaapi_image_get_width (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, 0);
|
|
|
|
return image->width;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_height:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Returns the @image height.
|
|
*
|
|
* Return value: the image height, in pixels.
|
|
*/
|
|
guint
|
|
gst_vaapi_image_get_height (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, 0);
|
|
|
|
return image->height;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_size:
|
|
* @image: a #GstVaapiImage
|
|
* @pwidth: return location for the width, or %NULL
|
|
* @pheight: return location for the height, or %NULL
|
|
*
|
|
* Retrieves the dimensions of a #GstVaapiImage.
|
|
*/
|
|
void
|
|
gst_vaapi_image_get_size (GstVaapiImage * image, guint * pwidth,
|
|
guint * pheight)
|
|
{
|
|
g_return_if_fail (image != NULL);
|
|
|
|
if (pwidth)
|
|
*pwidth = image->width;
|
|
|
|
if (pheight)
|
|
*pheight = image->height;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_is_linear:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Checks whether the @image has data planes allocated from a single
|
|
* buffer and offsets into that buffer are in increasing order with
|
|
* the number of planes.
|
|
*
|
|
* Return value: %TRUE if image data planes are allocated from a single buffer
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_is_linear (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
|
|
return image->is_linear;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_is_mapped:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Checks whether the @image is currently mapped or not.
|
|
*
|
|
* Return value: %TRUE if the @image is mapped
|
|
*/
|
|
static inline gboolean
|
|
_gst_vaapi_image_is_mapped (GstVaapiImage * image)
|
|
{
|
|
return image->image_data != NULL;
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_image_is_mapped (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
|
|
return _gst_vaapi_image_is_mapped (image);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_map:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Maps the image data buffer. The actual pixels are returned by the
|
|
* gst_vaapi_image_get_plane() function.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_map (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
|
|
return _gst_vaapi_image_map (image, NULL);
|
|
}
|
|
|
|
gboolean
|
|
_gst_vaapi_image_map (GstVaapiImage * image, GstVaapiImageRaw * raw_image)
|
|
{
|
|
GstVaapiDisplay *display;
|
|
VAStatus status;
|
|
guint i;
|
|
|
|
if (_gst_vaapi_image_is_mapped (image))
|
|
goto map_success;
|
|
|
|
display = GST_VAAPI_IMAGE_DISPLAY (image);
|
|
if (!display)
|
|
return FALSE;
|
|
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaMapBuffer (GST_VAAPI_DISPLAY_VADISPLAY (display),
|
|
image->image.buf, (void **) &image->image_data);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (!vaapi_check_status (status, "vaMapBuffer()"))
|
|
return FALSE;
|
|
|
|
map_success:
|
|
if (raw_image) {
|
|
const VAImage *const va_image = &image->image;
|
|
raw_image->format = image->format;
|
|
raw_image->width = va_image->width;
|
|
raw_image->height = va_image->height;
|
|
raw_image->num_planes = va_image->num_planes;
|
|
for (i = 0; i < raw_image->num_planes; i++) {
|
|
raw_image->pixels[i] = (guchar *) image->image_data +
|
|
va_image->offsets[i];
|
|
raw_image->stride[i] = va_image->pitches[i];
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_unmap:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Unmaps the image data buffer. Pointers to pixels returned by
|
|
* gst_vaapi_image_get_plane() are then no longer valid.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_unmap (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
|
|
return _gst_vaapi_image_unmap (image);
|
|
}
|
|
|
|
gboolean
|
|
_gst_vaapi_image_unmap (GstVaapiImage * image)
|
|
{
|
|
GstVaapiDisplay *display;
|
|
VAStatus status;
|
|
|
|
if (!_gst_vaapi_image_is_mapped (image))
|
|
return TRUE;
|
|
|
|
display = GST_VAAPI_IMAGE_DISPLAY (image);
|
|
if (!display)
|
|
return FALSE;
|
|
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaUnmapBuffer (GST_VAAPI_DISPLAY_VADISPLAY (display),
|
|
image->image.buf);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (!vaapi_check_status (status, "vaUnmapBuffer()"))
|
|
return FALSE;
|
|
|
|
image->image_data = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_plane_count:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Retrieves the number of planes available in the @image. The @image
|
|
* must be mapped for this function to work properly.
|
|
*
|
|
* Return value: the number of planes available in the @image
|
|
*/
|
|
guint
|
|
gst_vaapi_image_get_plane_count (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, 0);
|
|
g_return_val_if_fail (_gst_vaapi_image_is_mapped (image), 0);
|
|
|
|
return image->image.num_planes;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_plane:
|
|
* @image: a #GstVaapiImage
|
|
* @plane: the requested plane number
|
|
*
|
|
* Retrieves the pixels data to the specified @plane. The @image must
|
|
* be mapped for this function to work properly.
|
|
*
|
|
* Return value: the pixels data of the specified @plane
|
|
*/
|
|
guchar *
|
|
gst_vaapi_image_get_plane (GstVaapiImage * image, guint plane)
|
|
{
|
|
g_return_val_if_fail (image != NULL, NULL);
|
|
g_return_val_if_fail (_gst_vaapi_image_is_mapped (image), NULL);
|
|
g_return_val_if_fail (plane < image->image.num_planes, NULL);
|
|
|
|
return image->image_data + image->image.offsets[plane];
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_pitch:
|
|
* @image: a #GstVaapiImage
|
|
* @plane: the requested plane number
|
|
*
|
|
* Retrieves the line size (stride) of the specified @plane. The
|
|
* @image must be mapped for this function to work properly.
|
|
*
|
|
* Return value: the line size (stride) of the specified plane
|
|
*/
|
|
guint
|
|
gst_vaapi_image_get_pitch (GstVaapiImage * image, guint plane)
|
|
{
|
|
g_return_val_if_fail (image != NULL, 0);
|
|
g_return_val_if_fail (_gst_vaapi_image_is_mapped (image), 0);
|
|
g_return_val_if_fail (plane < image->image.num_planes, 0);
|
|
|
|
return image->image.pitches[plane];
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_data_size:
|
|
* @image: a #GstVaapiImage
|
|
*
|
|
* Retrieves the underlying image data size. This function could be
|
|
* used to determine whether the image has a compatible layout with
|
|
* another image structure.
|
|
*
|
|
* Return value: the whole image data size of the @image
|
|
*/
|
|
guint
|
|
gst_vaapi_image_get_data_size (GstVaapiImage * image)
|
|
{
|
|
g_return_val_if_fail (image != NULL, 0);
|
|
|
|
return image->image.data_size;
|
|
}
|
|
|
|
#include <gst/video/gstvideometa.h>
|
|
|
|
static gboolean
|
|
init_image_from_video_meta (GstVaapiImageRaw * raw_image, GstVideoMeta * vmeta)
|
|
{
|
|
GST_FIXME ("map from GstVideoMeta + add fini_image_from_buffer()");
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
init_image_from_buffer (GstVaapiImageRaw * raw_image, GstBuffer * buffer)
|
|
{
|
|
GstVideoMeta *const vmeta = gst_buffer_get_video_meta (buffer);
|
|
|
|
return vmeta ? init_image_from_video_meta (raw_image, vmeta) : FALSE;
|
|
}
|
|
|
|
/* Copy N lines of an image */
|
|
static inline void
|
|
memcpy_pic (guchar * dst,
|
|
guint dst_stride,
|
|
const guchar * src, guint src_stride, guint len, guint height)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < height; i++) {
|
|
memcpy (dst, src, len);
|
|
dst += dst_stride;
|
|
src += src_stride;
|
|
}
|
|
}
|
|
|
|
/* Copy NV12 images */
|
|
static void
|
|
copy_image_NV12 (GstVaapiImageRaw * dst_image,
|
|
GstVaapiImageRaw * src_image, const GstVaapiRectangle * rect)
|
|
{
|
|
guchar *dst, *src;
|
|
guint dst_stride, src_stride;
|
|
|
|
/* Y plane */
|
|
dst_stride = dst_image->stride[0];
|
|
dst = dst_image->pixels[0] + rect->y * dst_stride + rect->x;
|
|
src_stride = src_image->stride[0];
|
|
src = src_image->pixels[0] + rect->y * src_stride + rect->x;
|
|
memcpy_pic (dst, dst_stride, src, src_stride, rect->width, rect->height);
|
|
|
|
/* UV plane */
|
|
dst_stride = dst_image->stride[1];
|
|
dst = dst_image->pixels[1] + (rect->y / 2) * dst_stride + (rect->x & -2);
|
|
src_stride = src_image->stride[1];
|
|
src = src_image->pixels[1] + (rect->y / 2) * src_stride + (rect->x & -2);
|
|
memcpy_pic (dst, dst_stride, src, src_stride, rect->width, rect->height / 2);
|
|
}
|
|
|
|
/* Copy YV12 images */
|
|
static void
|
|
copy_image_YV12 (GstVaapiImageRaw * dst_image,
|
|
GstVaapiImageRaw * src_image, const GstVaapiRectangle * rect)
|
|
{
|
|
guchar *dst, *src;
|
|
guint dst_stride, src_stride;
|
|
guint i, x, y, w, h;
|
|
|
|
/* Y plane */
|
|
dst_stride = dst_image->stride[0];
|
|
dst = dst_image->pixels[0] + rect->y * dst_stride + rect->x;
|
|
src_stride = src_image->stride[0];
|
|
src = src_image->pixels[0] + rect->y * src_stride + rect->x;
|
|
memcpy_pic (dst, dst_stride, src, src_stride, rect->width, rect->height);
|
|
|
|
/* U/V planes */
|
|
x = rect->x / 2;
|
|
y = rect->y / 2;
|
|
w = rect->width / 2;
|
|
h = rect->height / 2;
|
|
for (i = 1; i < dst_image->num_planes; i++) {
|
|
dst_stride = dst_image->stride[i];
|
|
dst = dst_image->pixels[i] + y * dst_stride + x;
|
|
src_stride = src_image->stride[i];
|
|
src = src_image->pixels[i] + y * src_stride + x;
|
|
memcpy_pic (dst, dst_stride, src, src_stride, w, h);
|
|
}
|
|
}
|
|
|
|
/* Copy YUY2 images */
|
|
static void
|
|
copy_image_YUY2 (GstVaapiImageRaw * dst_image,
|
|
GstVaapiImageRaw * src_image, const GstVaapiRectangle * rect)
|
|
{
|
|
guchar *dst, *src;
|
|
guint dst_stride, src_stride;
|
|
|
|
/* YUV 4:2:2, full vertical resolution */
|
|
dst_stride = dst_image->stride[0];
|
|
dst = dst_image->pixels[0] + rect->y * dst_stride + rect->x * 2;
|
|
src_stride = src_image->stride[0];
|
|
src = src_image->pixels[0] + rect->y * src_stride + rect->x * 2;
|
|
memcpy_pic (dst, dst_stride, src, src_stride, rect->width * 2, rect->height);
|
|
}
|
|
|
|
/* Copy RGBA images */
|
|
static void
|
|
copy_image_RGBA (GstVaapiImageRaw * dst_image,
|
|
GstVaapiImageRaw * src_image, const GstVaapiRectangle * rect)
|
|
{
|
|
guchar *dst, *src;
|
|
guint dst_stride, src_stride;
|
|
|
|
dst_stride = dst_image->stride[0];
|
|
dst = dst_image->pixels[0] + rect->y * dst_stride + rect->x;
|
|
src_stride = src_image->stride[0];
|
|
src = src_image->pixels[0] + rect->y * src_stride + rect->x;
|
|
memcpy_pic (dst, dst_stride, src, src_stride, 4 * rect->width, rect->height);
|
|
}
|
|
|
|
static gboolean
|
|
copy_image (GstVaapiImageRaw * dst_image,
|
|
GstVaapiImageRaw * src_image, const GstVaapiRectangle * rect)
|
|
{
|
|
GstVaapiRectangle default_rect;
|
|
|
|
if (dst_image->format != src_image->format ||
|
|
dst_image->width != src_image->width ||
|
|
dst_image->height != src_image->height)
|
|
return FALSE;
|
|
|
|
if (rect) {
|
|
if (rect->x >= src_image->width ||
|
|
rect->x + rect->width > src_image->width ||
|
|
rect->y >= src_image->height ||
|
|
rect->y + rect->height > src_image->height)
|
|
return FALSE;
|
|
} else {
|
|
default_rect.x = 0;
|
|
default_rect.y = 0;
|
|
default_rect.width = src_image->width;
|
|
default_rect.height = src_image->height;
|
|
rect = &default_rect;
|
|
}
|
|
|
|
switch (dst_image->format) {
|
|
case GST_VIDEO_FORMAT_NV12:
|
|
copy_image_NV12 (dst_image, src_image, rect);
|
|
break;
|
|
case GST_VIDEO_FORMAT_YV12:
|
|
case GST_VIDEO_FORMAT_I420:
|
|
copy_image_YV12 (dst_image, src_image, rect);
|
|
break;
|
|
case GST_VIDEO_FORMAT_YUY2:
|
|
case GST_VIDEO_FORMAT_UYVY:
|
|
copy_image_YUY2 (dst_image, src_image, rect);
|
|
break;
|
|
case GST_VIDEO_FORMAT_ARGB:
|
|
case GST_VIDEO_FORMAT_RGBA:
|
|
case GST_VIDEO_FORMAT_ABGR:
|
|
case GST_VIDEO_FORMAT_BGRA:
|
|
copy_image_RGBA (dst_image, src_image, rect);
|
|
break;
|
|
default:
|
|
GST_ERROR ("unsupported image format for copy");
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_buffer:
|
|
* @image: a #GstVaapiImage
|
|
* @buffer: a #GstBuffer
|
|
* @rect: a #GstVaapiRectangle expressing a region, or %NULL for the
|
|
* whole image
|
|
*
|
|
* Transfers pixels data contained in the @image into the #GstBuffer.
|
|
* Both image structures shall have the same format.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_get_buffer (GstVaapiImage * image,
|
|
GstBuffer * buffer, GstVaapiRectangle * rect)
|
|
{
|
|
GstVaapiImageRaw dst_image, src_image;
|
|
gboolean success;
|
|
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);
|
|
|
|
if (!init_image_from_buffer (&dst_image, buffer))
|
|
return FALSE;
|
|
if (dst_image.format != image->format)
|
|
return FALSE;
|
|
if (dst_image.width != image->width || dst_image.height != image->height)
|
|
return FALSE;
|
|
|
|
if (!_gst_vaapi_image_map (image, &src_image))
|
|
return FALSE;
|
|
|
|
success = copy_image (&dst_image, &src_image, rect);
|
|
|
|
if (!_gst_vaapi_image_unmap (image))
|
|
return FALSE;
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_get_raw:
|
|
* @image: a #GstVaapiImage
|
|
* @dst_image: a #GstVaapiImageRaw
|
|
* @rect: a #GstVaapiRectangle expressing a region, or %NULL for the
|
|
* whole image
|
|
*
|
|
* Transfers pixels data contained in the @image into the #GstVaapiImageRaw.
|
|
* Both image structures shall have the same format.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_get_raw (GstVaapiImage * image,
|
|
GstVaapiImageRaw * dst_image, GstVaapiRectangle * rect)
|
|
{
|
|
GstVaapiImageRaw src_image;
|
|
gboolean success;
|
|
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
|
|
if (!_gst_vaapi_image_map (image, &src_image))
|
|
return FALSE;
|
|
|
|
success = copy_image (dst_image, &src_image, rect);
|
|
|
|
if (!_gst_vaapi_image_unmap (image))
|
|
return FALSE;
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_update_from_buffer:
|
|
* @image: a #GstVaapiImage
|
|
* @buffer: a #GstBuffer
|
|
* @rect: a #GstVaapiRectangle expressing a region, or %NULL for the
|
|
* whole image
|
|
*
|
|
* Transfers pixels data contained in the #GstBuffer into the
|
|
* @image. Both image structures shall have the same format.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_update_from_buffer (GstVaapiImage * image,
|
|
GstBuffer * buffer, GstVaapiRectangle * rect)
|
|
{
|
|
GstVaapiImageRaw dst_image, src_image;
|
|
gboolean success;
|
|
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
g_return_val_if_fail (GST_IS_BUFFER (buffer), FALSE);
|
|
|
|
if (!init_image_from_buffer (&src_image, buffer))
|
|
return FALSE;
|
|
if (src_image.format != image->format)
|
|
return FALSE;
|
|
if (src_image.width != image->width || src_image.height != image->height)
|
|
return FALSE;
|
|
|
|
if (!_gst_vaapi_image_map (image, &dst_image))
|
|
return FALSE;
|
|
|
|
success = copy_image (&dst_image, &src_image, rect);
|
|
|
|
if (!_gst_vaapi_image_unmap (image))
|
|
return FALSE;
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_update_from_raw:
|
|
* @image: a #GstVaapiImage
|
|
* @src_image: a #GstVaapiImageRaw
|
|
* @buffer: a #GstBuffer
|
|
* @rect: a #GstVaapiRectangle expressing a region, or %NULL for the
|
|
* whole image
|
|
*
|
|
* Transfers pixels data contained in the #GstVaapiImageRaw into the
|
|
* @image. Both image structures shall have the same format.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_update_from_raw (GstVaapiImage * image,
|
|
GstVaapiImageRaw * src_image, GstVaapiRectangle * rect)
|
|
{
|
|
GstVaapiImageRaw dst_image;
|
|
gboolean success;
|
|
|
|
g_return_val_if_fail (image != NULL, FALSE);
|
|
|
|
if (!_gst_vaapi_image_map (image, &dst_image))
|
|
return FALSE;
|
|
|
|
success = copy_image (&dst_image, src_image, rect);
|
|
|
|
if (!_gst_vaapi_image_unmap (image))
|
|
return FALSE;
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_image_copy:
|
|
* @dst_image: the target #GstVaapiImage
|
|
* @src_image: the source #GstVaapiImage
|
|
*
|
|
* Copies pixels data from @src_image to @dst_image. Both images shall
|
|
* have the same format and size.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_image_copy (GstVaapiImage * dst_image, GstVaapiImage * src_image)
|
|
{
|
|
GstVaapiImageRaw dst_image_raw, src_image_raw;
|
|
gboolean success = FALSE;
|
|
|
|
g_return_val_if_fail (dst_image != NULL, FALSE);
|
|
g_return_val_if_fail (src_image != NULL, FALSE);
|
|
|
|
if (!_gst_vaapi_image_map (dst_image, &dst_image_raw))
|
|
goto end;
|
|
if (!_gst_vaapi_image_map (src_image, &src_image_raw))
|
|
goto end;
|
|
|
|
success = copy_image (&dst_image_raw, &src_image_raw, NULL);
|
|
|
|
end:
|
|
_gst_vaapi_image_unmap (src_image);
|
|
_gst_vaapi_image_unmap (dst_image);
|
|
return success;
|
|
}
|