/*
* Copyright (c) 2011 Intel Corporation. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Shengquan Yuan <shengquan.yuan@intel.com>
* Zhaohan Ren <zhaohan.ren@intel.com>
* Jason Hu <jason.hu@intel.com>
*
*/
#ifndef ANDROID
#include <X11/Xutil.h>
#include <X11/extensions/Xrandr.h>
#include <va/va_dricommon.h>
#include "x11/psb_x11.h"
#include "x11/psb_xrandr.h"
#endif
#include <va/va_backend.h>
#include <dlfcn.h>
#include <stdlib.h>
#include "psb_output.h"
#include "psb_surface.h"
#include "psb_buffer.h"
#include "psb_surface_ext.h"
#include "pnw_rotate.h"
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <wsbm/wsbm_manager.h>
#include "psb_drv_debug.h"
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <math.h>
#define INIT_DRIVER_DATA psb_driver_data_p driver_data = (psb_driver_data_p) ctx->pDriverData;
#define SURFACE(id) ((object_surface_p) object_heap_lookup( &driver_data->surface_heap, id ))
#define BUFFER(id) ((object_buffer_p) object_heap_lookup( &driver_data->buffer_heap, id ))
#define IMAGE(id) ((object_image_p) object_heap_lookup( &driver_data->image_heap, id ))
#define SUBPIC(id) ((object_subpic_p) object_heap_lookup( &driver_data->subpic_heap, id ))
#define CONTEXT(id) ((object_context_p) object_heap_lookup( &driver_data->context_heap, id ))
/* surfaces link list associated with a subpicture */
typedef struct _subpic_surface {
VASurfaceID surface_id;
struct _subpic_surface *next;
} subpic_surface_s, *subpic_surface_p;
static VAImageFormat psb__SubpicFormat[] = {
psb__ImageRGBA,
//psb__ImageAYUV,
//psb__ImageAI44
};
static VAImageFormat psb__CreateImageFormat[] = {
psb__ImageNV12,
psb__ImageRGBA,
//psb__ImageAYUV,
//psb__ImageAI44,
psb__ImageYV16,
psb__ImageYV32
};
unsigned char *psb_x11_output_init(VADriverContextP ctx);
VAStatus psb_x11_output_deinit(VADriverContextP ctx);
unsigned char *psb_android_output_init(VADriverContextP ctx);
VAStatus psb_android_output_deinit(VADriverContextP ctx);
int psb_coverlay_init(VADriverContextP ctx);
int psb_coverlay_deinit(VADriverContextP ctx);
VAStatus psb_initOutput(VADriverContextP ctx)
{
INIT_DRIVER_DATA;
unsigned char *ws_priv = NULL;
char env_value[1024];
pthread_mutex_init(&driver_data->output_mutex, NULL);
if (psb_parse_config("PSB_VIDEO_PUTSURFACE_DUMMY", &env_value[0]) == 0) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "vaPutSurface: dummy mode, return directly\n");
driver_data->dummy_putsurface = 0;
return VA_STATUS_SUCCESS;
}
if (psb_parse_config("PSB_VIDEO_FPS", &env_value[0]) == 0) {
driver_data->fixed_fps = atoi(env_value);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Throttling at FPS=%d\n", driver_data->fixed_fps);
} else
driver_data->fixed_fps = 0;
driver_data->outputmethod_checkinterval = 1;
if (psb_parse_config("PSB_VIDEO_INTERVAL", &env_value[0]) == 0) {
driver_data->outputmethod_checkinterval = atoi(env_value);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Check output method at %d frames interval\n",
driver_data->outputmethod_checkinterval);
}
driver_data->cur_displaying_surface = VA_INVALID_SURFACE;
driver_data->last_displaying_surface = VA_INVALID_SURFACE;
psb_InitOutLoop(ctx);
#ifdef ANDROID
ws_priv = psb_android_output_init(ctx);
driver_data->is_android = 1;
#else
ws_priv = psb_x11_output_init(ctx);
driver_data->is_android = 0;
#endif
driver_data->ws_priv = ws_priv;
#if 0
//use client textureblit
if (driver_data->ctexture == 1) {
int ret = psb_ctexture_init(ctx);
if (ret != 0)
driver_data->ctexture = 0;
}
#endif
/*
//use texture streaming
if (driver_data->ctexstreaming == 1)
psb_ctexstreaing_init(ctx);
*/
return VA_STATUS_SUCCESS;
}
VAStatus psb_deinitOutput(
VADriverContextP ctx
)
{
INIT_DRIVER_DATA;
#if 0
//use client textureblit
if (driver_data->ctexture == 1)
psb_ctexture_deinit(ctx);
#endif
if (driver_data->coverlay_init) {
psb_coverlay_deinit(ctx);
driver_data->coverlay_init = 0;
}
#ifndef ANDROID
psb_x11_output_deinit(ctx);
#else
psb_android_output_deinit(ctx);
#endif
/* free here, but allocate in window system specific */
free(driver_data->ws_priv);
/*
//use texture streaming
if (driver_data->ctexstreaming == 1)
psb_ctexstreaing_deinit(ctx);
*/
/* clean the displaying surface information in kernel */
#ifndef _FOR_FPGA_
psb_surface_set_displaying(driver_data, 0, 0, NULL);
#endif
pthread_mutex_destroy(&driver_data->output_mutex);
return VA_STATUS_SUCCESS;
}
#ifndef VA_STATUS_ERROR_INVALID_IMAGE_FORMAT
#define VA_STATUS_ERROR_INVALID_IMAGE_FORMAT VA_STATUS_ERROR_UNKNOWN
#endif
static VAImageFormat *psb__VAImageCheckFourCC(
VAImageFormat *src_format,
VAImageFormat *dst_format,
int dst_num
)
{
int i;
if (NULL == src_format || dst_format == NULL) {
return NULL;
}
/* check VAImage at first */
for (i = 0; i < dst_num; i++) {
if (dst_format[i].fourcc == src_format->fourcc)
return &dst_format[i];
}
drv_debug_msg(VIDEO_DEBUG_ERROR, "Unsupport fourcc 0x%x\n", src_format->fourcc);
return NULL;
}
static void psb__VAImageCheckRegion(
object_surface_p surface,
VAImage *image,
int *src_x,
int *src_y,
int *dest_x,
int *dest_y,
int *width,
int *height
)
{
/* check for image */
if (*src_x < 0) *src_x = 0;
if (*src_x > image->width) *src_x = image->width - 1;
if (*src_y < 0) *src_y = 0;
if (*src_y > image->height) *src_y = image->height - 1;
if (((*width) + (*src_x)) > image->width) *width = image->width - *src_x;
if (((*height) + (*src_y)) > image->height) *height = image->height - *src_x;
/* check for surface */
if (*dest_x < 0) *dest_x = 0;
if (*dest_x > surface->width) *dest_x = surface->width - 1;
if (*dest_y < 0) *dest_y = 0;
if (*dest_y > surface->height) *dest_y = surface->height - 1;
if (((*width) + (*dest_x)) > surface->width) *width = surface->width - *dest_x;
if (((*height) + (*dest_y)) > surface->height) *height = surface->height - *dest_x;
}
VAStatus psb_QueryImageFormats(
VADriverContextP __maybe_unused ctx,
VAImageFormat *format_list, /* out */
int *num_formats /* out */
)
{
VAStatus vaStatus = VA_STATUS_SUCCESS;
CHECK_INVALID_PARAM(format_list == NULL);
CHECK_INVALID_PARAM(num_formats == NULL);
memcpy(format_list, psb__CreateImageFormat, sizeof(psb__CreateImageFormat));
*num_formats = PSB_MAX_IMAGE_FORMATS;
return VA_STATUS_SUCCESS;
}
inline int min_POT(int n)
{
if ((n & (n - 1)) == 0) /* already POT */
return n;
return n |= n >> 16, n |= n >> 8, n |= n >> 4, n |= n >> 2, n |= n >> 1, n + 1;
/* return ((((n |= n>>16) |= n>>8) |= n>>4) |= n>>2) |= n>>1, n + 1; */
}
VAStatus psb_CreateImage(
VADriverContextP ctx,
VAImageFormat *format,
int width,
int height,
VAImage *image /* out */
)
{
INIT_DRIVER_DATA;
VAImageID imageID;
object_image_p obj_image;
VAStatus vaStatus = VA_STATUS_SUCCESS;
VAImageFormat *img_fmt;
int pitch_pot;
(void)driver_data;
img_fmt = psb__VAImageCheckFourCC(format, psb__CreateImageFormat,
sizeof(psb__CreateImageFormat) / sizeof(VAImageFormat));
if (img_fmt == NULL)
return VA_STATUS_ERROR_UNKNOWN;
CHECK_INVALID_PARAM(image == NULL);
imageID = object_heap_allocate(&driver_data->image_heap);
obj_image = IMAGE(imageID);
CHECK_ALLOCATION(obj_image);
MEMSET_OBJECT(obj_image, struct object_image_s);
obj_image->image.image_id = imageID;
obj_image->image.format = *img_fmt;
obj_image->subpic_ref = 0;
pitch_pot = min_POT(width);
switch (format->fourcc) {
case VA_FOURCC_NV12: {
obj_image->image.width = width;
obj_image->image.height = height;
obj_image->image.data_size = pitch_pot * height /*Y*/ + 2 * (pitch_pot / 2) * (height / 2);/*UV*/
obj_image->image.num_planes = 2;
obj_image->image.pitches[0] = pitch_pot;
obj_image->image.pitches[1] = pitch_pot;
obj_image->image.offsets[0] = 0;
obj_image->image.offsets[1] = pitch_pot * height;
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'Y';
obj_image->image.component_order[1] = 'U';/* fixed me: packed UV packed here! */
obj_image->image.component_order[2] = 'V';
obj_image->image.component_order[3] = '\0';
break;
}
case VA_FOURCC_AYUV: {
obj_image->image.width = width;
obj_image->image.height = height;
obj_image->image.data_size = 4 * pitch_pot * height;
obj_image->image.num_planes = 1;
obj_image->image.pitches[0] = 4 * pitch_pot;
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'V';
obj_image->image.component_order[1] = 'U';
obj_image->image.component_order[2] = 'Y';
obj_image->image.component_order[3] = 'A';
break;
}
case VA_FOURCC_RGBA: {
obj_image->image.width = width;
obj_image->image.height = height;
obj_image->image.data_size = 4 * pitch_pot * height;
obj_image->image.num_planes = 1;
obj_image->image.pitches[0] = 4 * pitch_pot;
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'R';
obj_image->image.component_order[1] = 'G';
obj_image->image.component_order[2] = 'B';
obj_image->image.component_order[3] = 'A';
break;
}
case VA_FOURCC_AI44: {
obj_image->image.width = width;
obj_image->image.height = height;
obj_image->image.data_size = pitch_pot * height;/* one byte one element */
obj_image->image.num_planes = 1;
obj_image->image.pitches[0] = pitch_pot;
obj_image->image.num_palette_entries = 16;
obj_image->image.entry_bytes = 4; /* AYUV */
obj_image->image.component_order[0] = 'I';
obj_image->image.component_order[1] = 'A';
obj_image->image.component_order[2] = '\0';
obj_image->image.component_order[3] = '\0';
break;
}
case VA_FOURCC_IYUV: {
obj_image->image.width = width;
obj_image->image.height = height;
obj_image->image.data_size = pitch_pot * height /*Y*/ + 2 * (pitch_pot / 2) * (height / 2);/*UV*/
obj_image->image.num_planes = 3;
obj_image->image.pitches[0] = pitch_pot;
obj_image->image.pitches[1] = pitch_pot / 2;
obj_image->image.pitches[2] = pitch_pot / 2;
obj_image->image.offsets[0] = 0;
obj_image->image.offsets[1] = pitch_pot * height;
obj_image->image.offsets[2] = pitch_pot * height + (pitch_pot / 2) * (height / 2);
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'Y';
obj_image->image.component_order[1] = 'U';
obj_image->image.component_order[2] = 'V';
obj_image->image.component_order[3] = '\0';
break;
}
case VA_FOURCC_YV32: {
obj_image->image.width = width;
obj_image->image.height = height;
obj_image->image.data_size = 4 * pitch_pot * height;
obj_image->image.num_planes = 4;
obj_image->image.pitches[0] = pitch_pot;
obj_image->image.pitches[1] = pitch_pot;
obj_image->image.pitches[2] = pitch_pot;
obj_image->image.extra_pitch = pitch_pot;
obj_image->image.offsets[0] = 0;
obj_image->image.offsets[1] = pitch_pot * height;
obj_image->image.offsets[2] = pitch_pot * height * 2;
obj_image->image.extra_offset = pitch_pot * height * 3;
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'V';
obj_image->image.component_order[1] = 'U';
obj_image->image.component_order[2] = 'Y';
obj_image->image.component_order[3] = 'A';
break;
}
default: {
vaStatus = VA_STATUS_ERROR_INVALID_IMAGE_FORMAT;
break;
}
}
if (VA_STATUS_SUCCESS == vaStatus) {
/* create the buffer */
vaStatus = psb__CreateBuffer(driver_data, NULL, VAImageBufferType,
obj_image->image.data_size, 1, NULL, &obj_image->image.buf);
}
obj_image->derived_surface = 0;
if (VA_STATUS_SUCCESS != vaStatus) {
object_heap_free(&driver_data->image_heap, (object_base_p) obj_image);
} else {
memcpy(image, &obj_image->image, sizeof(VAImage));
}
return vaStatus;
}
static int psb_CheckIEDStatus(VADriverContextP ctx)
{
INIT_DRIVER_DATA;
struct drm_lnc_video_getparam_arg arg;
unsigned long temp;
int ret = 0;
/* not settled, we get it from current HW FRAMESKIP flag */
arg.key = IMG_VIDEO_IED_STATE;
arg.value = (uint64_t)((unsigned long) & temp);
ret = drmCommandWriteRead(driver_data->drm_fd, driver_data->getParamIoctlOffset,
&arg, sizeof(arg));
if (ret == 0) {
if (temp == 1) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "IED is enabled, image is encrypted.\n");
return 1;
} else {
return 0;
}
} else {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Failed to call IMG_VIDEO_IED_STATE.\n");
return -1;
}
}
VAStatus psb_DeriveImage(
VADriverContextP ctx,
VASurfaceID surface,
VAImage *image /* out */
)
{
INIT_DRIVER_DATA;
VAStatus vaStatus = VA_STATUS_SUCCESS;
VABufferID bufferID;
object_buffer_p obj_buffer;
VAImageID imageID;
object_image_p obj_image;
object_surface_p obj_surface = SURFACE(surface);
unsigned int fourcc, fourcc_index = ~0, i;
uint32_t srf_buf_ofs = 0;
CHECK_SURFACE(obj_surface);
CHECK_INVALID_PARAM(image == NULL);
/* Can't derive image from reconstrued frame which is in tiled format */
if (obj_surface->is_ref_surface == 1 || obj_surface->is_ref_surface == 2) {
if (getenv("PSB_VIDEO_IGNORE_TILED_FORMAT")) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Ignore tiled memory format" \
"of rec-frames\n");
} else {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Can't derive reference surface" \
"which is tiled format\n");
return VA_STATUS_ERROR_OPERATION_FAILED;
}
}
if (IS_MFLD(driver_data) && (psb_CheckIEDStatus(ctx) == 1)) {
vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
return vaStatus;
}
fourcc = obj_surface->psb_surface->extra_info[4];
for (i = 0; i < PSB_MAX_IMAGE_FORMATS; i++) {
if (psb__CreateImageFormat[i].fourcc == fourcc) {
fourcc_index = i;
break;
}
}
if (i == PSB_MAX_IMAGE_FORMATS) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Can't support the Fourcc\n");
vaStatus = VA_STATUS_ERROR_OPERATION_FAILED;
return vaStatus;
}
/* create the image */
imageID = object_heap_allocate(&driver_data->image_heap);
obj_image = IMAGE(imageID);
CHECK_ALLOCATION(obj_image);
MEMSET_OBJECT(obj_image, struct object_image_s);
/* create a buffer to represent surface buffer */
bufferID = object_heap_allocate(&driver_data->buffer_heap);
obj_buffer = BUFFER(bufferID);
if (NULL == obj_buffer) {
object_heap_free(&driver_data->image_heap, (object_base_p) obj_image);
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
DEBUG_FAILURE;
return vaStatus;
}
MEMSET_OBJECT(obj_buffer, struct object_buffer_s);
obj_buffer->type = VAImageBufferType;
obj_buffer->buffer_data = NULL;
obj_buffer->psb_buffer = &obj_surface->psb_surface->buf;
obj_buffer->size = obj_surface->psb_surface->size;
obj_buffer->max_num_elements = 0;
obj_buffer->alloc_size = obj_buffer->size;
/* fill obj_image data structure */
obj_image->image.image_id = imageID;
obj_image->image.format = psb__CreateImageFormat[fourcc_index];
obj_image->subpic_ref = 0;
obj_image->image.buf = bufferID;
obj_image->image.width = obj_surface->width;
obj_image->image.height = obj_surface->height;
obj_image->image.data_size = obj_surface->psb_surface->size;
srf_buf_ofs = obj_surface->psb_surface->buf.buffer_ofs;
switch (fourcc) {
case VA_FOURCC_NV12: {
obj_image->image.num_planes = 2;
obj_image->image.pitches[0] = obj_surface->psb_surface->stride;
obj_image->image.pitches[1] = obj_surface->psb_surface->stride;
obj_image->image.offsets[0] = srf_buf_ofs;
obj_image->image.offsets[1] = srf_buf_ofs + obj_surface->height * obj_surface->psb_surface->stride;
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'Y';
obj_image->image.component_order[1] = 'U';/* fixed me: packed UV packed here! */
obj_image->image.component_order[2] = 'V';
obj_image->image.component_order[3] = '\0';
break;
}
case VA_FOURCC_YV16: {
obj_image->image.num_planes = 3;
obj_image->image.pitches[0] = obj_surface->psb_surface->stride;
obj_image->image.pitches[1] = obj_surface->psb_surface->stride / 2;
obj_image->image.pitches[2] = obj_surface->psb_surface->stride / 2;
obj_image->image.offsets[0] = srf_buf_ofs;
obj_image->image.offsets[1] = srf_buf_ofs + obj_surface->height * obj_surface->psb_surface->stride;
obj_image->image.offsets[2] = srf_buf_ofs + obj_surface->height * obj_surface->psb_surface->stride * 3 / 2;
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'Y';
obj_image->image.component_order[1] = 'V';/* fixed me: packed UV packed here! */
obj_image->image.component_order[2] = 'U';
obj_image->image.component_order[3] = '\0';
break;
}
case VA_FOURCC_YV32: {
obj_image->image.num_planes = 3;
obj_image->image.pitches[0] = obj_surface->psb_surface->stride;
obj_image->image.pitches[1] = obj_surface->psb_surface->stride;
obj_image->image.pitches[2] = obj_surface->psb_surface->stride;
obj_image->image.offsets[0] = srf_buf_ofs;
obj_image->image.offsets[1] = srf_buf_ofs + obj_surface->height * obj_surface->psb_surface->stride;
obj_image->image.offsets[2] = srf_buf_ofs + obj_surface->height * obj_surface->psb_surface->stride * 2;
obj_image->image.num_palette_entries = 0;
obj_image->image.entry_bytes = 0;
obj_image->image.component_order[0] = 'Y';
obj_image->image.component_order[1] = 'U';/* fixed me: packed UV packed here! */
obj_image->image.component_order[2] = 'V';
obj_image->image.component_order[3] = '\0';
break;
}
default:
break;
}
obj_image->derived_surface = surface; /* this image is derived from a surface */
obj_surface->derived_imgcnt++;
memcpy(image, &obj_image->image, sizeof(VAImage));
return vaStatus;
}
VAStatus psb__destroy_image(psb_driver_data_p driver_data, object_image_p obj_image)
{
VAStatus vaStatus = VA_STATUS_SUCCESS;
if (obj_image->subpic_ref > 0) {
vaStatus = VA_STATUS_ERROR_OPERATION_FAILED;
return vaStatus;
}
object_surface_p obj_surface = SURFACE(obj_image->derived_surface);
if (obj_surface == NULL) { /* destroy the buffer */
object_buffer_p obj_buffer = BUFFER(obj_image->image.buf);
CHECK_BUFFER(obj_buffer);
psb__suspend_buffer(driver_data, obj_buffer);
} else {
object_buffer_p obj_buffer = BUFFER(obj_image->image.buf);
object_heap_free(&driver_data->buffer_heap, &obj_buffer->base);
obj_surface->derived_imgcnt--;
}
object_heap_free(&driver_data->image_heap, (object_base_p) obj_image);
return VA_STATUS_SUCCESS;
}
VAStatus psb_DestroyImage(
VADriverContextP ctx,
VAImageID image
)
{
INIT_DRIVER_DATA
VAStatus vaStatus = VA_STATUS_SUCCESS;
object_image_p obj_image;
obj_image = IMAGE(image);
CHECK_IMAGE(obj_image);
return psb__destroy_image(driver_data, obj_image);
}
VAStatus psb_SetImagePalette(
VADriverContextP ctx,
VAImageID image,
/*
* pointer to an array holding the palette data. The size of the array is
* num_palette_entries * entry_bytes in size. The order of the components
* in the palette is described by the component_order in VAImage struct
*/
unsigned char *palette
)
{
INIT_DRIVER_DATA;
VAStatus vaStatus = VA_STATUS_SUCCESS;
object_image_p obj_image = IMAGE(image);
CHECK_IMAGE(obj_image);
if (obj_image->image.format.fourcc != VA_FOURCC_AI44) {
/* only support AI44 palette */
vaStatus = VA_STATUS_ERROR_OPERATION_FAILED;
return vaStatus;
}
if (obj_image->image.num_palette_entries > 16) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "image.num_palette_entries(%d) is too big\n", obj_image->image.num_palette_entries);
memcpy(obj_image->palette, palette, 16);
} else
memcpy(obj_image->palette, palette, obj_image->image.num_palette_entries * sizeof(unsigned int));
return vaStatus;
}
static VAStatus lnc_unpack_topaz_rec(int src_width, int src_height,
unsigned char *p_srcY, unsigned char *p_srcUV,
unsigned char *p_dstY, unsigned char *p_dstU, unsigned char *p_dstV,
int dstY_stride, int dstU_stride, int dstV_stride,
int surface_height)
{
unsigned char *tmp_dstY = NULL;
unsigned char *tmp_dstUV = NULL;
int n, i, index;
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Unpack reconstructed frame to image\n");
/* do this one column at a time. */
tmp_dstY = (unsigned char *)calloc(1, 16 * src_height);
if (tmp_dstY == NULL)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
tmp_dstUV = (unsigned char*)calloc(1, 16 * src_height / 2);
if (tmp_dstUV == NULL) {
free(tmp_dstY);
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
/* Copy Y data */
for (n = 0; n < src_width / 16; n++) {
memcpy((void*)tmp_dstY, p_srcY, 16 * src_height);
p_srcY += (16 * surface_height);
for (i = 0; i < src_height; i++) {
memcpy(p_dstY + dstY_stride * i + n * 16, tmp_dstY + 16 * i, 16);
}
}
/* Copy U/V data */
for (n = 0; n < src_width / 16; n++) {
memcpy((void*)tmp_dstUV, p_srcUV, 16 * src_height / 2);
p_srcUV += (16 * surface_height / 2);
for (i = 0; i < src_height / 2; i++) {
for (index = 0; index < 8; index++) {
p_dstU[i*dstU_stride + n*8 + index] = tmp_dstUV[index*2 + i*16];
p_dstV[i*dstV_stride + n*8 + index] = tmp_dstUV[index*2 + i*16+1];
}
}
}
if (tmp_dstY)
free(tmp_dstY);
if (tmp_dstUV)
free(tmp_dstUV);
return VA_STATUS_SUCCESS;
}
/*
* Convert the memroy format from tiled to linear
*/
static VAStatus tng_unpack_vsp_rec(
int src_width, int src_height,
unsigned char *p_srcY, unsigned char *p_srcUV,
unsigned char *p_dstY, unsigned char *p_dstU,
int dstY_stride, int dstU_stride, int __maybe_unused dstV_stride,
int __maybe_unused surface_height)
{
unsigned char *tmp_dstY = p_dstY;
unsigned char *tmp_dstU = p_dstU;
int n, t,x,y;
//" Y_address(x,y) = Y_base + (((H +64+63)/64) * (x/64) + (y/64))*4096 + (y%64)*64 + (x%64)
//" U_address(x,y) = UV_base + ((((H+1)/2+32+63)/64) * (x/32) + (y/64))*4096 + (y%64)*64 + (x%32)*2
//" V_address(x,y) = UV_base + ((((H+1)/2+32+63)/64) * (x/32) + (y/64))*4096 + (y%64)*64 + (x%32)*2 + 1
/* Copy Y data */
for (y = 32; y < src_height + 32; y++) {
for (x= 32;x < src_width + 32; x++) {
* tmp_dstY++ = *(p_srcY + (((src_height+64+63)/64) * (x/64) + (y/64))*4096 + (y%64)*64 + (x%64));
}
tmp_dstY += dstY_stride - src_width;
}
/* Copy UV data */
for (y = 16; y < 16 + ((src_height+1)>>1) ; y++) {
for (x= 16;x < 16 + ( (src_width+1)>>1); x++) {
* tmp_dstU++ = * (p_srcUV + ((((src_height+1)/2+32+63)/64) * (x/32) + (y/64))*4096 + (y%64)*64 + (x%32)*2);
* tmp_dstU++ = * (p_srcUV + ((((src_height+1)/2+32+63)/64) * (x/32) + (y/64))*4096 + (y%64)*64 + (x%32)*2 +1);
}
tmp_dstU += dstU_stride - ((src_width));
}
return VA_STATUS_SUCCESS;
}
/*
* Convert the memroy format from tiled to linear
*/
static VAStatus tng_unpack_topaz_rec(
int src_width, int src_height,
unsigned char *p_srcY, unsigned char *p_srcUV,
unsigned char *p_dstY, unsigned char *p_dstU, unsigned char *p_dstV,
int dstY_stride, int __maybe_unused dstU_stride, int __maybe_unused dstV_stride,
int __maybe_unused surface_height)
{
unsigned char *tmp_dstY = p_dstY;
unsigned char *tmp_dstU = p_dstU;
unsigned char *tmp_dstV = p_dstV;
unsigned char *tmp_srcY = p_srcY;
unsigned char *tmp_srcX = p_srcUV;
int i, j, n, t;
int mb_src_y_w = src_width >> 4;
int mb_src_y_h = src_height >> 5;
int mb_src_y_p = src_height - (mb_src_y_h << 5);
/* Copy Y data */
for (j = 0; j < mb_src_y_h; j++) {
tmp_dstY = p_dstY + j * dstY_stride * 32;
for (i = 0; i < mb_src_y_w; i++) {
for (n = 0; n < 32; n++) {
memcpy(tmp_dstY + dstY_stride * n, tmp_srcY,16);
tmp_srcY += 16;
}
tmp_dstY += 16;
}
}
if(mb_src_y_p != 0) {
tmp_dstY = p_dstY + j * dstY_stride * 32;
for (i = 0; i < mb_src_y_w; i++) {
for (n = 0; n < mb_src_y_p; n++) {
memcpy(tmp_dstY + dstY_stride * n, tmp_srcY,16);
tmp_srcY += 16;
}
for (; n < 32; n++) {
tmp_srcY += 16;
}
tmp_dstY += 16;
}
}
for (j = 0; j < mb_src_y_h; j++) {
tmp_dstU = p_dstU + j * dstY_stride * 16;
for (i = 0; i < mb_src_y_w; i++) {
for (n = 0; n < 16; n++) {
for (t = 0; t < 16; t++) {
tmp_dstU[(n * dstY_stride) + t] = tmp_srcX[t];
}
tmp_srcX += 16;
}
tmp_dstU += 16;
}
}
mb_src_y_p >>= 1;
if(mb_src_y_p != 0) {
tmp_dstU = p_dstU + j * dstY_stride * 16;
for (i = 0; i < mb_src_y_w; i++) {
for (n = 0; n < mb_src_y_p; n++) {
for (t = 0; t < 16; t++) {
tmp_dstU[(n * dstY_stride) + t] = tmp_srcX[t];
}
tmp_srcX += 16;
}
for (; n < 16; n++) {
tmp_srcX += 16;
}
tmp_dstU += 16;
}
}
return VA_STATUS_SUCCESS;
}
VAStatus psb_GetImage(
VADriverContextP ctx,
VASurfaceID surface,
int x, /* coordinates of the upper left source pixel */
int y,
unsigned int width, /* width and height of the region */
unsigned int height,
VAImageID image_id
)
{
INIT_DRIVER_DATA;
VAStatus vaStatus = VA_STATUS_SUCCESS;
int ret, src_x = 0, src_y = 0, dest_x = 0, dest_y = 0;
(void)driver_data;
(void)lnc_unpack_topaz_rec;
object_image_p obj_image = IMAGE(image_id);
CHECK_IMAGE(obj_image);
if (IS_MFLD(driver_data) && (psb_CheckIEDStatus(ctx) == 1)) {
vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
return vaStatus;
}
if (obj_image->image.format.fourcc != VA_FOURCC_NV12) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "target VAImage fourcc should be NV12 or IYUV\n");
vaStatus = VA_STATUS_ERROR_OPERATION_FAILED;
return vaStatus;
}
object_surface_p obj_surface = SURFACE(surface);
CHECK_SURFACE(obj_surface);
psb__VAImageCheckRegion(obj_surface, &obj_image->image, &src_x, &src_y, &dest_x, &dest_y,
(int *)&width, (int *)&height);
psb_surface_p psb_surface = obj_surface->psb_surface;
unsigned char *surface_data;
ret = psb_buffer_map(&psb_surface->buf, &surface_data);
if (ret) {
return VA_STATUS_ERROR_UNKNOWN;
}
object_buffer_p obj_buffer = BUFFER(obj_image->image.buf);
CHECK_BUFFER(obj_buffer);
unsigned char *image_data;
ret = psb_buffer_map(obj_buffer->psb_buffer, &image_data);
if (ret) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Map buffer failed\n");
psb_buffer_unmap(&psb_surface->buf);
return VA_STATUS_ERROR_UNKNOWN;
}
image_data += obj_surface->psb_surface->buf.buffer_ofs;
switch (obj_image->image.format.fourcc) {
case VA_FOURCC_NV12: {
unsigned char *src_y, *src_uv, *dst_y, *dst_uv;
unsigned char *dst_u, *dst_v;
unsigned int i;
/*
* For reconstructed frame, tiled to linear conversion
* must be done.
*/
if (obj_surface->is_ref_surface == 1) {
src_y = surface_data + y * psb_surface->stride + x;
src_uv = surface_data + ((height + 0x1f) & (~0x1f)) * width;
dst_y = image_data;
dst_u = image_data + obj_image->image.offsets[1],
dst_v = dst_u + (height * width) / 4;
tng_unpack_topaz_rec(width, height, \
src_y, src_uv, \
dst_y, dst_u, dst_v, \
obj_image->image.pitches[0], \
obj_image->image.width / 2, \
obj_image->image.width / 2, \
obj_surface->height);
} else if (obj_surface->is_ref_surface == 2) {
src_y = surface_data + y * psb_surface->stride + x;
src_uv = surface_data + ((height + 2*32 + 63)/64*64) * ((width + 2*32 + 63)/64*64);
dst_y = image_data;
dst_u = image_data + obj_image->image.offsets[1];
tng_unpack_vsp_rec(width, height, \
src_y, src_uv, \
dst_y, dst_u, \
obj_image->image.pitches[0], \
obj_image->image.pitches[1], \
obj_image->image.pitches[1], \
obj_surface->height);
} else{
/* copy Y plane */
dst_y = image_data;
src_y = surface_data + y * psb_surface->stride + x;
for (i = 0; i < height; i++) {
memcpy(dst_y, src_y, width);
dst_y += obj_image->image.pitches[0];
src_y += psb_surface->stride;
}
/* copy UV plane */
dst_uv = image_data + obj_image->image.offsets[1];
src_uv = surface_data + psb_surface->stride * obj_surface->height + (y / 2) * psb_surface->stride + x;;
for (i = 0; i < obj_image->image.height / 2; i++) {
memcpy(dst_uv, src_uv, width);
dst_uv += obj_image->image.pitches[1];
src_uv += psb_surface->stride;
}
}
break;
}
#if 0
case VA_FOURCC_IYUV: {
unsigned char *source_y, *dst_y;
unsigned char *source_uv, *source_u, *source_v, *dst_u, *dst_v;
unsigned int i;
if (psb_surface->extra_info[4] == VA_FOURCC_IREC) {
/* copy Y plane */
dst_y = image_data + obj_image->image.offsets[0] + src_y * obj_image->image.pitches[0] + src_x;
dst_u = image_data + obj_image->image.offsets[1] + src_y * obj_image->image.pitches[1] + src_x;
dst_v = image_data + obj_image->image.offsets[2] + src_y * obj_image->image.pitches[2] + src_x;
source_y = surface_data + dest_y * psb_surface->stride + dest_x;
source_uv = surface_data + obj_surface->height * psb_surface->stride
+ dest_y * (psb_surface->stride / 2) + dest_x;
vaStatus = lnc_unpack_topaz_rec(width, height, source_y, source_uv,
dst_y, dst_u, dst_v,
obj_image->image.pitches[0],
obj_image->image.pitches[1],
obj_image->image.pitches[2],
obj_surface->height);
}
break;
}
#endif
default:
break;
}
psb_buffer_unmap(obj_buffer->psb_buffer);
psb_buffer_unmap(&psb_surface->buf);
return vaStatus;
}
static VAStatus psb_PutImage2(
VADriverContextP ctx,
VASurfaceID surface,
VAImageID image_id,
int src_x,
int src_y,
unsigned int width,
unsigned int height,
int dest_x,
int dest_y
)
{
INIT_DRIVER_DATA;
VAStatus vaStatus = VA_STATUS_SUCCESS;
int ret;
object_image_p obj_image = IMAGE(image_id);
CHECK_IMAGE(obj_image);
object_surface_p obj_surface = SURFACE(surface);
CHECK_SURFACE(obj_surface);
if (obj_image->image.format.fourcc != VA_FOURCC_NV12) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "target VAImage fourcc should be NV12 or IYUV\n");
vaStatus = VA_STATUS_ERROR_OPERATION_FAILED;
return vaStatus;
}
psb__VAImageCheckRegion(obj_surface, &obj_image->image, &src_x, &src_y, &dest_x, &dest_y,
(int *)&width, (int *)&height);
psb_surface_p psb_surface = obj_surface->psb_surface;
unsigned char *surface_data;
ret = psb_buffer_map(&psb_surface->buf, &surface_data);
if (ret) {
return VA_STATUS_ERROR_UNKNOWN;
}
object_buffer_p obj_buffer = BUFFER(obj_image->image.buf);
CHECK_BUFFER(obj_buffer);
unsigned char *image_data;
ret = psb_buffer_map(obj_buffer->psb_buffer, &image_data);
if (ret) {
psb_buffer_unmap(&psb_surface->buf);
return VA_STATUS_ERROR_UNKNOWN;
}
image_data += obj_surface->psb_surface->buf.buffer_ofs;
switch (obj_image->image.format.fourcc) {
case VA_FOURCC_NV12: {
unsigned char *source_y, *src_uv, *dst_y, *dst_uv;
unsigned int i;
/* copy Y plane */
source_y = image_data + obj_image->image.offsets[0] + src_y * obj_image->image.pitches[0] + src_x;
dst_y = surface_data + dest_y * psb_surface->stride + dest_x;
for (i = 0; i < height; i++) {
memcpy(dst_y, source_y, width);
source_y += obj_image->image.pitches[0];
dst_y += psb_surface->stride;
}
/* copy UV plane */
src_uv = image_data + obj_image->image.offsets[1] + (src_y / 2) * obj_image->image.pitches[1] + src_x;
dst_uv = surface_data + psb_surface->stride * obj_surface->height + (dest_y / 2) * psb_surface->stride + dest_x;
for (i = 0; i < obj_image->image.height / 2; i++) {
memcpy(dst_uv, src_uv, width);
src_uv += obj_image->image.pitches[1];
dst_uv += psb_surface->stride;
}
break;
}
#if 0
case VA_FOURCC_IYUV: {
char *source_y, *dst_y;
char *source_u, *source_v, *dst_u, *dst_v;
unsigned int i;
/* copy Y plane */
source_y = image_data + obj_image->image.offsets[0] + src_y * obj_image->image.pitches[0] + src_x;
source_u = image_data + obj_image->image.offsets[1] + src_y * obj_image->image.pitches[1] + src_x;
source_v = image_data + obj_image->image.offsets[2] + src_y * obj_image->image.pitches[2] + src_x;
dst_y = surface_data + dest_y * psb_surface->stride + dest_x;
dst_u = surface_data + obj_surface->height * psb_surface->stride
+ dest_y * (psb_surface->stride / 2) + dest_x;
dst_v = surface_data + obj_surface->height * psb_surface->stride
+ (obj_surface->height / 2) * (psb_surface->stride / 2)
+ dest_y * (psb_surface->stride / 2) + dest_x;
for (i = 0; i < height; i++) {
memcpy(dst_y, source_y, width);
source_y += obj_image->image.pitches[0];
dst_y += psb_surface->stride;
}
/* copy UV plane */
for (i = 0; i < obj_image->image.height / 2; i++) {
memcpy(dst_u, source_u, width);
memcpy(dst_v, source_v, width);
source_u += obj_image->image.pitches[1];
source_v += obj_image->image.pitches[2];
dst_u += psb_surface->stride / 2;
dst_v += psb_surface->stride / 2;
}
break;
}
#endif
default:
break;
}
psb_buffer_unmap(obj_buffer->psb_buffer);
psb_buffer_unmap(&psb_surface->buf);
return VA_STATUS_SUCCESS;
}
static void psb__VAImageCheckRegion2(
object_surface_p surface,
VAImage *image,
int *src_x,
int *src_y,
unsigned int *src_width,
unsigned int *src_height,
int *dest_x,
int *dest_y,
int *dest_width,
int *dest_height
)
{
/* check for image */
if (*src_x < 0) *src_x = 0;
if (*src_x > image->width) *src_x = image->width - 1;
if (*src_y < 0) *src_y = 0;
if (*src_y > image->height) *src_y = image->height - 1;
if (((*src_width) + (*src_x)) > image->width) *src_width = image->width - *src_x;
if (((*src_height) + (*src_y)) > image->height) *src_height = image->height - *src_x;
/* check for surface */
if (*dest_x < 0) *dest_x = 0;
if (*dest_x > surface->width) *dest_x = surface->width - 1;
if (*dest_y < 0) *dest_y = 0;
if (*dest_y > surface->height) *dest_y = surface->height - 1;
if (((*dest_width) + (*dest_x)) > (int)surface->width) *dest_width = surface->width - *dest_x;
if (((*dest_height) + (*dest_y)) > (int)surface->height) *dest_height = surface->height - *dest_x;
}
VAStatus psb_PutImage(
VADriverContextP ctx,
VASurfaceID surface,
VAImageID image_id,
int src_x,
int src_y,
unsigned int src_width,
unsigned int src_height,
int dest_x,
int dest_y,
unsigned int dest_width,
unsigned int dest_height
)
{
INIT_DRIVER_DATA;
VAStatus vaStatus = VA_STATUS_SUCCESS;
int ret;
CHECK_INVALID_PARAM(((int)src_width == -1) ||
((int)src_height == -1) ||
((int)dest_width == ~0) ||
((int)dest_height == ~0));
if ((src_width == dest_width) && (src_height == dest_height)) {
/* Shortcut if scaling is not required */
return psb_PutImage2(ctx, surface, image_id, src_x, src_y, src_width, src_height, dest_x, dest_y);
}
object_image_p obj_image = IMAGE(image_id);
CHECK_IMAGE(obj_image);
if (obj_image->image.format.fourcc != VA_FOURCC_NV12) {
/* only support NV12 getImage/putImage */
vaStatus = VA_STATUS_ERROR_OPERATION_FAILED;
return vaStatus;
}
object_surface_p obj_surface = SURFACE(surface);
CHECK_SURFACE(obj_surface);
psb__VAImageCheckRegion2(obj_surface, &obj_image->image,
&src_x, &src_y, &src_width, &src_height,
&dest_x, &dest_y, (int *)&dest_width, (int *)&dest_height);
psb_surface_p psb_surface = obj_surface->psb_surface;
unsigned char *surface_data;
ret = psb_buffer_map(&psb_surface->buf, &surface_data);
if (ret) {
return VA_STATUS_ERROR_UNKNOWN;
}
object_buffer_p obj_buffer = BUFFER(obj_image->image.buf);
CHECK_BUFFER(obj_buffer);
unsigned char *image_data;
ret = psb_buffer_map(obj_buffer->psb_buffer, &image_data);
if (ret) {
psb_buffer_unmap(&psb_surface->buf);
return VA_STATUS_ERROR_UNKNOWN;
}
/* just a prototype, the algorithm is ugly and not optimized */
switch (obj_image->image.format.fourcc) {
case VA_FOURCC_NV12: {
unsigned char *source_y, *dst_y;
unsigned short *source_uv, *dst_uv;
unsigned int i, j;
float xratio = (float) src_width / dest_width;
float yratio = (float) src_height / dest_height;
/* dst_y/dst_uv: Y/UV plane of destination */
dst_y = (unsigned char *)(surface_data + dest_y * psb_surface->stride + dest_x);
dst_uv = (unsigned short *)(surface_data + psb_surface->stride * obj_surface->height
+ (dest_y / 2) * psb_surface->stride + dest_x);
for (j = 0; j < dest_height; j++) {
unsigned char *dst_y_tmp = dst_y;
unsigned short *dst_uv_tmp = dst_uv;
for (i = 0; i < dest_width; i++) {
int x = (int)(i * xratio);
int y = (int)(j * yratio);
source_y = image_data + obj_image->image.offsets[0]
+ (src_y + y) * obj_image->image.pitches[0]
+ (src_x + x);
*dst_y_tmp = *source_y;
dst_y_tmp++;
if (((i & 1) == 0)) {
source_uv = (unsigned short *)(image_data + obj_image->image.offsets[1]
+ ((src_y + y) / 2) * obj_image->image.pitches[1])
+ ((src_x + x) / 2);
*dst_uv_tmp = *source_uv;
dst_uv_tmp++;
}
}
dst_y += psb_surface->stride;
if (j & 1)
dst_uv = (unsigned short *)((unsigned char *)dst_uv + psb_surface->stride);
}
break;
}
default:/* will not reach here */
break;
}
psb_buffer_unmap(obj_buffer->psb_buffer);
psb_buffer_unmap(&psb_surface->buf);
return VA_STATUS_SUCCESS;
}
/*
* Link supbicture into one surface, when update is zero, not need to
* update the location information
* The image informatio and its BO of subpicture will copied to surface
* so need to update it when a vaSetSubpictureImage is called
*/
static VAStatus psb__LinkSubpictIntoSurface(
psb_driver_data_p driver_data,
object_surface_p obj_surface,
object_subpic_p obj_subpic,
short src_x,
short src_y,
unsigned short src_w,
unsigned short src_h,
short dest_x,
short dest_y,
unsigned short dest_w,
unsigned short dest_h,
int update /* update subpicture location */
)
{
PsbVASurfaceRec *surface_subpic;
object_image_p obj_image = IMAGE(obj_subpic->image_id);
if (NULL == obj_image) {
return VA_STATUS_ERROR_INVALID_IMAGE;
}
VAImage *image = &obj_image->image;
object_buffer_p obj_buffer = BUFFER(image->buf);
if (NULL == obj_buffer) {
return VA_STATUS_ERROR_INVALID_BUFFER;
}
int found = 0;
if (obj_surface->subpictures != NULL) {
surface_subpic = (PsbVASurfaceRec *)obj_surface->subpictures;
do {
if (surface_subpic->subpic_id == obj_subpic->subpic_id) {
found = 1;
break;
} else
surface_subpic = surface_subpic->next;
} while (surface_subpic);
}
if (found == 0) { /* new node */
if (obj_surface->subpic_count >= PSB_SUBPIC_MAX_NUM) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "can't support so many sub-pictures for the surface\n");
return VA_STATUS_ERROR_UNKNOWN;
}
surface_subpic = (PsbVASurfaceRec *)calloc(1, sizeof(*surface_subpic));
if (NULL == surface_subpic)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
surface_subpic->subpic_id = obj_subpic->subpic_id;
surface_subpic->fourcc = image->format.fourcc;
surface_subpic->size = image->data_size;
surface_subpic->bo = obj_buffer->psb_buffer->drm_buf;
surface_subpic->bufid = wsbmKBufHandle(wsbmKBuf(obj_buffer->psb_buffer->drm_buf));
surface_subpic->pl_flags = obj_buffer->psb_buffer->pl_flags;
surface_subpic->subpic_flags = obj_subpic->flags;
surface_subpic->width = image->width;
surface_subpic->height = image->height;
switch (surface_subpic->fourcc) {
case VA_FOURCC_AYUV:
surface_subpic->stride = image->pitches[0] / 4;
break;
case VA_FOURCC_RGBA:
surface_subpic->stride = image->pitches[0] / 4;
break;
case VA_FOURCC_AI44:
surface_subpic->stride = image->pitches[0];
/* point to Image palette */
surface_subpic->palette_ptr = (PsbAYUVSample8 *) & obj_image->palette[0];
break;
}
if (update) {
surface_subpic->subpic_srcx = src_x;
surface_subpic->subpic_srcy = src_y;
surface_subpic->subpic_dstx = dest_x;
surface_subpic->subpic_dsty = dest_y;
surface_subpic->subpic_srcw = src_w;
surface_subpic->subpic_srch = src_h;
surface_subpic->subpic_dstw = dest_w;
surface_subpic->subpic_dsth = dest_h;
}
if (found == 0) { /* new node, link into the list */
if (NULL == obj_surface->subpictures) {
obj_surface->subpictures = (void *)surface_subpic;
} else { /* insert as the head */
surface_subpic->next = (PsbVASurfacePtr)obj_surface->subpictures;
obj_surface->subpictures = (void *)surface_subpic;
}
obj_surface->subpic_count++;
}
return VA_STATUS_SUCCESS;
}
static VAStatus psb__LinkSurfaceIntoSubpict(
object_subpic_p obj_subpic,
VASurfaceID surface_id
)
{
subpic_surface_s *subpic_surface;
int found = 0;
if (obj_subpic->surfaces != NULL) {
subpic_surface = (subpic_surface_s *)obj_subpic->surfaces;
do {
if (subpic_surface->surface_id == surface_id) {
found = 1;
return VA_STATUS_SUCCESS; /* reture directly */
} else
subpic_surface = subpic_surface->next;
} while (subpic_surface);
}
/* not found */
subpic_surface = (subpic_surface_s *)calloc(1, sizeof(*subpic_surface));
if (NULL == subpic_surface)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
subpic_surface->surface_id = surface_id;
subpic_surface->next = NULL;
if (NULL == obj_subpic->surfaces) {
obj_subpic->surfaces = (void *)subpic_surface;
} else { /* insert as the head */
subpic_surface->next = (subpic_surface_p)obj_subpic->surfaces;
obj_subpic->surfaces = (void *)subpic_surface;
}
return VA_STATUS_SUCCESS;
}
static VAStatus psb__DelinkSubpictFromSurface(
object_surface_p obj_surface,
VASubpictureID subpic_id
)
{
PsbVASurfaceRec *surface_subpic, *pre_surface_subpic = NULL;
int found = 0;
if (obj_surface->subpictures != NULL) {
surface_subpic = (PsbVASurfaceRec *)obj_surface->subpictures;
do {
if (surface_subpic->subpic_id == subpic_id) {
found = 1;
break;
} else {
pre_surface_subpic = surface_subpic;
surface_subpic = surface_subpic->next;
}
} while (surface_subpic);
}
if (found == 1) {
if (pre_surface_subpic == NULL) { /* remove the first node */
obj_surface->subpictures = (void *)surface_subpic->next;
} else {
pre_surface_subpic->next = surface_subpic->next;
}
free(surface_subpic);
obj_surface->subpic_count--;
}
return VA_STATUS_SUCCESS;
}
static VAStatus psb__DelinkSurfaceFromSubpict(
object_subpic_p obj_subpic,
VASurfaceID surface_id
)
{
subpic_surface_s *subpic_surface, *pre_subpic_surface = NULL;
int found = 0;
if (obj_subpic->surfaces != NULL) {
subpic_surface = (subpic_surface_s *)obj_subpic->surfaces;
do {
if (subpic_surface->surface_id == surface_id) {
found = 1;
break;
} else {
pre_subpic_surface = subpic_surface;
subpic_surface = subpic_surface->next;
}
} while (subpic_surface);
}
if (found == 1) {
if (pre_subpic_surface == NULL) { /* remove the first node */
obj_subpic->surfaces = (void *)subpic_surface->next;
} else {
pre_subpic_surface->next = subpic_surface->next;
}
free(subpic_surface);
}
return VA_STATUS_SUCCESS;
}
VAStatus psb_QuerySubpictureFormats(
VADriverContextP __maybe_unused ctx,
VAImageFormat *format_list, /* out */
unsigned int *flags, /* out */
unsigned int *num_formats /* out */
)
{
VAStatus vaStatus = VA_STATUS_SUCCESS;
CHECK_INVALID_PARAM(format_list == NULL);
CHECK_INVALID_PARAM(flags == NULL);
CHECK_INVALID_PARAM(num_formats == NULL);
memcpy(format_list, psb__SubpicFormat, sizeof(psb__SubpicFormat));
*num_formats = PSB_MAX_SUBPIC_FORMATS;
*flags = PSB_SUPPORTED_SUBPIC_FLAGS;
return VA_STATUS_SUCCESS;
}
VAStatus psb_CreateSubpicture(
VADriverContextP ctx,
VAImageID image,
VASubpictureID *subpicture /* out */
)
{
INIT_DRIVER_DATA;
VASubpictureID subpicID;
object_subpic_p obj_subpic;
object_image_p obj_image;
VAStatus vaStatus = VA_STATUS_SUCCESS;
VAImageFormat *img_fmt;
obj_image = IMAGE(image);
CHECK_IMAGE(obj_image);
CHECK_SUBPICTURE(subpicture);
img_fmt = psb__VAImageCheckFourCC(&obj_image->image.format, psb__SubpicFormat,
sizeof(psb__SubpicFormat) / sizeof(VAImageFormat));
if (img_fmt == NULL)
return VA_STATUS_ERROR_UNKNOWN;
subpicID = object_heap_allocate(&driver_data->subpic_heap);
obj_subpic = SUBPIC(subpicID);
CHECK_ALLOCATION(obj_subpic);
MEMSET_OBJECT(obj_subpic, struct object_subpic_s);
obj_subpic->subpic_id = subpicID;
obj_subpic->image_id = obj_image->image.image_id;
obj_subpic->surfaces = NULL;
obj_subpic->global_alpha = 255;
obj_image->subpic_ref ++;
*subpicture = subpicID;
return VA_STATUS_SUCCESS;
}
VAStatus psb__destroy_subpicture(psb_driver_data_p driver_data, object_subpic_p obj_subpic)
{
subpic_surface_s *subpic_surface = (subpic_surface_s *)obj_subpic->surfaces;
VASubpictureID subpicture = obj_subpic->subpic_id;
if (subpic_surface) {
do {
subpic_surface_s *tmp = subpic_surface;
object_surface_p obj_surface = SURFACE(subpic_surface->surface_id);
if (obj_surface) { /* remove subpict from surface */
psb__DelinkSubpictFromSurface(obj_surface, subpicture);
}
subpic_surface = subpic_surface->next;
free(tmp);
} while (subpic_surface);
}
object_heap_free(&driver_data->subpic_heap, (object_base_p) obj_subpic);
return VA_STATUS_SUCCESS;
}
VAStatus psb_DestroySubpicture(
VADriverContextP ctx,
VASubpictureID subpicture
)
{
INIT_DRIVER_DATA;
object_subpic_p obj_subpic;
VAStatus vaStatus = VA_STATUS_SUCCESS;
obj_subpic = SUBPIC(subpicture);
CHECK_SUBPICTURE(obj_subpic);
return psb__destroy_subpicture(driver_data, obj_subpic);
}
VAStatus psb_SetSubpictureImage(
VADriverContextP ctx,
VASubpictureID subpicture,
VAImageID image
)
{
INIT_DRIVER_DATA;
object_subpic_p obj_subpic;
object_image_p obj_image;
VAStatus vaStatus = VA_STATUS_SUCCESS;
subpic_surface_s *subpic_surface;
VAImageFormat *img_fmt;
obj_image = IMAGE(image);
CHECK_IMAGE(obj_image);
img_fmt = psb__VAImageCheckFourCC(&obj_image->image.format,
psb__SubpicFormat,
sizeof(psb__SubpicFormat) / sizeof(VAImageFormat));
CHECK_IMAGE(img_fmt);
obj_subpic = SUBPIC(subpicture);
CHECK_SUBPICTURE(obj_subpic);
object_image_p old_obj_image = IMAGE(obj_subpic->image_id);
if (old_obj_image) {
old_obj_image->subpic_ref--;/* decrease reference count */
}
/* reset the image */
obj_subpic->image_id = obj_image->image.image_id;
obj_image->subpic_ref ++;
/* relink again */
if (obj_subpic->surfaces != NULL) {
/* the subpicture already linked into surfaces
* so not check the return value of psb__LinkSubpictIntoSurface
*/
subpic_surface = (subpic_surface_s *)obj_subpic->surfaces;
do {
object_surface_p obj_surface = SURFACE(subpic_surface->surface_id);
CHECK_SURFACE(obj_surface);
psb__LinkSubpictIntoSurface(driver_data, obj_surface, obj_subpic,
0, 0, 0, 0, 0, 0, 0, 0,
0 /* not update location */
);
subpic_surface = subpic_surface->next;
} while (subpic_surface);
}
return VA_STATUS_SUCCESS;
}
VAStatus psb_SetSubpictureChromakey(
VADriverContextP ctx,
VASubpictureID subpicture,
unsigned int chromakey_min,
unsigned int chromakey_max,
unsigned int chromakey_mask
)
{
INIT_DRIVER_DATA;
(void)driver_data;
/* TODO */
if ((chromakey_mask < chromakey_min) || (chromakey_mask > chromakey_max)) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Invalid chromakey value %d, chromakey value should between min and max\n", chromakey_mask);
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
object_subpic_p obj_subpic = SUBPIC(subpicture);
if (NULL == obj_subpic) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Invalid subpicture value %d\n", subpicture);
return VA_STATUS_ERROR_INVALID_SUBPICTURE;
}
return VA_STATUS_SUCCESS;
}
VAStatus psb_SetSubpictureGlobalAlpha(
VADriverContextP ctx,
VASubpictureID subpicture,
float global_alpha
)
{
INIT_DRIVER_DATA;
if (global_alpha < 0 || global_alpha > 1) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Invalid global alpha value %07f, global alpha value should between 0 and 1\n", global_alpha);
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
object_subpic_p obj_subpic = SUBPIC(subpicture);
if (NULL == obj_subpic) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Invalid subpicture value %d\n", subpicture);
return VA_STATUS_ERROR_INVALID_SUBPICTURE;
}
obj_subpic->global_alpha = global_alpha * 255;
return VA_STATUS_SUCCESS;
}
VAStatus psb__AssociateSubpicture(
VADriverContextP ctx,
VASubpictureID subpicture,
VASurfaceID *target_surfaces,
int num_surfaces,
short src_x, /* upper left offset in subpicture */
short src_y,
unsigned short src_w,
unsigned short src_h,
short dest_x, /* upper left offset in surface */
short dest_y,
unsigned short dest_w,
unsigned short dest_h,
/*
* whether to enable chroma-keying or global-alpha
* see VA_SUBPICTURE_XXX values
*/
unsigned int flags
)
{
INIT_DRIVER_DATA;
object_subpic_p obj_subpic;
VAStatus vaStatus = VA_STATUS_SUCCESS;
int i;
CHECK_INVALID_PARAM(num_surfaces <= 0);
obj_subpic = SUBPIC(subpicture);
CHECK_SUBPICTURE(obj_subpic);
CHECK_SURFACE(target_surfaces);
if (flags & ~PSB_SUPPORTED_SUBPIC_FLAGS) {
#ifdef VA_STATUS_ERROR_FLAG_NOT_SUPPORTED
vaStatus = VA_STATUS_ERROR_FLAG_NOT_SUPPORTED;
#else
vaStatus = VA_STATUS_ERROR_UNKNOWN;
#endif
DEBUG_FAILURE;
return vaStatus;
} else {
/* If flags are ok, copy them to the subpicture object */
obj_subpic->flags = flags;
}
/* Validate input params */
for (i = 0; i < num_surfaces; i++) {
object_surface_p obj_surface = SURFACE(target_surfaces[i]);
CHECK_SURFACE(obj_surface);
}
VASurfaceID *surfaces = target_surfaces;
for (i = 0; i < num_surfaces; i++) {
object_surface_p obj_surface = SURFACE(*surfaces);
if (obj_surface) {
vaStatus = psb__LinkSubpictIntoSurface(driver_data, obj_surface, obj_subpic,
src_x, src_y, src_w, src_h,
dest_x, dest_y, dest_w, dest_h, 1);
if (VA_STATUS_SUCCESS == vaStatus) {
vaStatus = psb__LinkSurfaceIntoSubpict(obj_subpic, *surfaces);
}
CHECK_VASTATUS();/* failed with malloc */
} else {
/* Should never get here */
drv_debug_msg(VIDEO_DEBUG_ERROR, "Invalid surfaces,SurfaceID=0x%x\n", *surfaces);
}
surfaces++;
}
return VA_STATUS_SUCCESS;
}
VAStatus psb_AssociateSubpicture(
VADriverContextP ctx,
VASubpictureID subpicture,
VASurfaceID *target_surfaces,
int num_surfaces,
short src_x, /* upper left offset in subpicture */
short src_y,
unsigned short src_width,
unsigned short src_height,
short dest_x, /* upper left offset in surface */
short dest_y,
unsigned short dest_width,
unsigned short dest_height,
/*
* whether to enable chroma-keying or global-alpha
* see VA_SUBPICTURE_XXX values
*/
unsigned int flags
)
{
return psb__AssociateSubpicture(ctx, subpicture, target_surfaces, num_surfaces,
src_x, src_y, src_width, src_height,
dest_x, dest_y, dest_width, dest_height,
flags
);
}
VAStatus psb_DeassociateSubpicture(
VADriverContextP ctx,
VASubpictureID subpicture,
VASurfaceID *target_surfaces,
int num_surfaces
)
{
INIT_DRIVER_DATA;
object_subpic_p obj_subpic;
VAStatus vaStatus = VA_STATUS_SUCCESS;
object_image_p obj_image;
int i;
CHECK_INVALID_PARAM(num_surfaces <= 0);
obj_subpic = SUBPIC(subpicture);
CHECK_SUBPICTURE(obj_subpic);
CHECK_SURFACE(target_surfaces);
VASurfaceID *surfaces = target_surfaces;
for (i = 0; i < num_surfaces; i++) {
object_surface_p obj_surface = SURFACE(*surfaces);
if (obj_surface) {
psb__DelinkSubpictFromSurface(obj_surface, subpicture);
psb__DelinkSurfaceFromSubpict(obj_subpic, obj_surface->surface_id);
} else {
drv_debug_msg(VIDEO_DEBUG_ERROR, "vaDeassociateSubpicture: Invalid surface, VASurfaceID=0x%08x\n", *surfaces);
}
surfaces++;
}
obj_image = IMAGE(obj_subpic->image_id);
if (obj_image)
obj_image->subpic_ref--;/* decrease reference count */
return VA_STATUS_SUCCESS;
}
void psb_SurfaceDeassociateSubpict(
psb_driver_data_p driver_data,
object_surface_p obj_surface
)
{
PsbVASurfaceRec *surface_subpic = (PsbVASurfaceRec *)obj_surface->subpictures;
if (surface_subpic != NULL) {
do {
PsbVASurfaceRec *tmp = surface_subpic;
object_subpic_p obj_subpic = SUBPIC(surface_subpic->subpic_id);
if (obj_subpic)
psb__DelinkSurfaceFromSubpict(obj_subpic, obj_surface->surface_id);
surface_subpic = surface_subpic->next;
free(tmp);
} while (surface_subpic);
}
}
static VADisplayAttribute psb__DisplayAttribute[] = {
{
VADisplayAttribBrightness,
BRIGHTNESS_MIN,
BRIGHTNESS_MAX,
BRIGHTNESS_DEFAULT_VALUE,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribContrast,
CONTRAST_MIN,
CONTRAST_MAX,
CONTRAST_DEFAULT_VALUE,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribHue,
HUE_MIN,
HUE_MAX,
HUE_DEFAULT_VALUE,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribSaturation,
SATURATION_MIN,
SATURATION_MAX,
SATURATION_DEFAULT_VALUE,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribBackgroundColor,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribRotation,
VA_ROTATION_NONE,
VA_ROTATION_270,
VA_ROTATION_NONE,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribOutofLoopDeblock,
VA_OOL_DEBLOCKING_FALSE,
VA_OOL_DEBLOCKING_TRUE,
VA_OOL_DEBLOCKING_FALSE,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribBlendColor,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribOverlayColorKey,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribOverlayAutoPaintColorKey,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribCSCMatrix,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribRenderDevice,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribRenderMode,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
},
{
VADisplayAttribRenderRect,
0x00000000,
0xffffffff,
0x00000000,
VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE,
NULL
}
};
/*
* Query display attributes
* The caller must provide a "attr_list" array that can hold at
* least vaMaxNumDisplayAttributes() entries. The actual number of attributes
* returned in "attr_list" is returned in "num_attributes".
*/
VAStatus psb_QueryDisplayAttributes(
VADriverContextP __maybe_unused ctx,
VADisplayAttribute *attr_list, /* out */
int *num_attributes /* out */
)
{
VAStatus vaStatus = VA_STATUS_SUCCESS;
CHECK_INVALID_PARAM(attr_list == NULL);
CHECK_INVALID_PARAM(num_attributes == NULL);
*num_attributes = min(*num_attributes, PSB_MAX_DISPLAY_ATTRIBUTES);
memcpy(attr_list, psb__DisplayAttribute, (*num_attributes)*sizeof(VADisplayAttribute));
return VA_STATUS_SUCCESS;
}
/*
* Get display attributes
* This function returns the current attribute values in "attr_list".
* Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
* from vaQueryDisplayAttributes() can have their values retrieved.
*/
VAStatus psb_GetDisplayAttributes(
VADriverContextP ctx,
VADisplayAttribute *attr_list, /* in/out */
int num_attributes
)
{
INIT_DRIVER_DATA;
VADisplayAttribute *p = attr_list;
int i;
VAStatus vaStatus = VA_STATUS_SUCCESS;
CHECK_INVALID_PARAM(attr_list == NULL);
CHECK_INVALID_PARAM(num_attributes <= 0);
for (i = 0; i < num_attributes; i++) {
switch (p->type) {
case VADisplayAttribBrightness:
/* -50*(1<<10) ~ 50*(1<<10) ==> 0~100*/
p->value = (driver_data->brightness.value / (1 << 10)) + 50;
p->min_value = 0;
p->max_value = 100;
break;
case VADisplayAttribContrast:
/* 0 ~ 2*(1<<25) ==> 0~100 */
p->value = (driver_data->contrast.value / (1 << 25)) * 50;
p->min_value = 0;
p->max_value = 100;
break;
case VADisplayAttribHue:
/* -30*(1<<25) ~ 30*(1<<25) ==> 0~100*/
p->value = ((driver_data->hue.value / (1 << 25)) + 30) * 10 / 6;
p->min_value = 0;
p->max_value = 100;
break;
case VADisplayAttribSaturation:
/* 0 ~ 2*(1<<25) ==> 0~100 */
p->value = (driver_data->saturation.value / (1 << 25)) * 50;
p->min_value = 0;
p->max_value = 100;
break;
case VADisplayAttribBackgroundColor:
p->value = driver_data->clear_color;
break;
case VADisplayAttribBlendColor:
p->value = driver_data->blend_color;
break;
case VADisplayAttribOverlayColorKey:
p->value = driver_data->color_key;
p->min_value = 0;
p->max_value = 0xFFFFFF;
break;
case VADisplayAttribOverlayAutoPaintColorKey:
p->value = driver_data->overlay_auto_paint_color_key;
p->min_value = 0;
p->max_value = 1;
break;
case VADisplayAttribRotation:
p->value = driver_data->va_rotate = p->value;
p->min_value = VA_ROTATION_NONE;
p->max_value = VA_ROTATION_270;
break;
case VADisplayAttribOutofLoopDeblock:
p->value = driver_data->is_oold = p->value;
p->min_value = VA_OOL_DEBLOCKING_FALSE;
p->max_value = VA_OOL_DEBLOCKING_TRUE;
break;
case VADisplayAttribCSCMatrix:
p->value = driver_data->load_csc_matrix = p->value;
p->min_value = 0;
p->max_value = 255;
break;
case VADisplayAttribRenderDevice:
p->value = driver_data->render_device = p->value;
p->min_value = 0;
p->max_value = 255;
break;
case VADisplayAttribRenderMode:
p->value = driver_data->render_mode = p->value;
p->min_value = 0;
p->max_value = 255;
break;
case VADisplayAttribRenderRect:
((VARectangle *)(p->value))->x = driver_data->render_rect.x = ((VARectangle *)(p->value))->x;
((VARectangle *)(p->value))->y = driver_data->render_rect.y = ((VARectangle *)(p->value))->y;
((VARectangle *)(p->value))->width = driver_data->render_rect.width = ((VARectangle *)(p->value))->width;
((VARectangle *)(p->value))->height = driver_data->render_rect.height = ((VARectangle *)(p->value))->height;
p->min_value = 0;
p->max_value = 255;
break;
default:
break;
}
p++;
}
return VA_STATUS_SUCCESS;
}
/*
* Set display attributes
* Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
* from vaQueryDisplayAttributes() can be set. If the attribute is not settable or
* the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
*/
#define CLAMP_ATTR(a,max,min) (a>max?max:(a<min?min:a))
VAStatus psb_SetDisplayAttributes(
VADriverContextP ctx,
VADisplayAttribute *attr_list,
int num_attributes
)
{
INIT_DRIVER_DATA;
VAStatus vaStatus = VA_STATUS_SUCCESS;
struct psb_texture_s *texture_priv = &driver_data->ctexture_priv;
PsbPortPrivPtr overlay_priv = (PsbPortPrivPtr)(&driver_data->coverlay_priv);
int j, k;
CHECK_INVALID_PARAM(attr_list == NULL);
VADisplayAttribute *p = attr_list;
int i, update_coeffs = 0;
float *p_tmp;
if (num_attributes <= 0) {
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
for (i = 0; i < num_attributes; i++) {
switch (p->type) {
case VADisplayAttribBrightness:
/* 0~100 ==> -50*(1<<10) ~ 50*(1<<10)*/
driver_data->brightness.value = (p->value - 50) * (1 << 10);
/* 0~100 ==> -50~50 */
overlay_priv->brightness.Value = texture_priv->brightness.Value = p->value - 50;
update_coeffs = 1;
break;
case VADisplayAttribContrast:
/* 0~100 ==> 0 ~ 2*(1<<25) */
driver_data->contrast.value = (p->value / 50) * (1 << 25);
/* 0~100 ==> -100~100 */
overlay_priv->contrast.Value = texture_priv->contrast.Value = p->value * 2 - 100;
update_coeffs = 1;
break;
case VADisplayAttribHue:
/* 0~100 ==> -30*(1<<25) ~ 30*(1<<25) */
driver_data->hue.value = ((p->value * 2 - 100) * 3 / 10) * (1 << 25);
/* 0~100 ==> -30~30 */
overlay_priv->hue.Value = texture_priv->hue.Value = (p->value * 2 - 100) * 3 / 10;
update_coeffs = 1;
break;
case VADisplayAttribSaturation:
/* 0~100 ==> 0 ~ 2*(1<<25) */
driver_data->contrast.value = (p->value / 50) * (1 << 25);
/* 0~100 ==> 100~200 */
overlay_priv->saturation.Value = texture_priv->saturation.Value = p->value + 100;
update_coeffs = 1;
break;
case VADisplayAttribBackgroundColor:
driver_data->clear_color = p->value;
break;
case VADisplayAttribOutofLoopDeblock:
driver_data->is_oold = p->value;
break;
case VADisplayAttribRotation:
driver_data->va_rotate = p->value;
driver_data->rotation_dirty |= PSB_NEW_VA_ROTATION;
break;
case VADisplayAttribCSCMatrix:
driver_data->load_csc_matrix = 1;
p_tmp = (float *)(p->attrib_ptr);
for (j = 0; j < CSC_MATRIX_Y; j++)
for (k = 0; k < CSC_MATRIX_X; k++) {
if (p_tmp)
driver_data->csc_matrix[j][k] = *p_tmp;
p_tmp++;
}
for (j = 0; j < CSC_MATRIX_Y; j++)
for (k = 0; k < CSC_MATRIX_X; k++) {
if (fabs(s601[j*CSC_MATRIX_X+k] - driver_data->csc_matrix[j][k]) > 1e-6) {
break;
}
if (k < CSC_MATRIX_X) {
break;
}
}
if (j == CSC_MATRIX_Y && k == CSC_MATRIX_X) {
driver_data->is_BT601 = 1;
}
break;
case VADisplayAttribColorRange:
driver_data->set_video_range = 1;
driver_data->video_range = (p->value == VA_SOURCE_RANGE_FULL);
break;
case VADisplayAttribBlendColor:
driver_data->blend_color = p->value;
break;
case VADisplayAttribOverlayColorKey:
overlay_priv->colorKey = driver_data->color_key = p->value;
break;
case VADisplayAttribOverlayAutoPaintColorKey:
driver_data->overlay_auto_paint_color_key = p->value;
break;
case VADisplayAttribRenderDevice:
driver_data->render_device = p->value & VA_RENDER_DEVICE_MASK;
case VADisplayAttribRenderMode:
#ifndef ANDROID
if (p->value & VA_RENDER_MODE_EXTERNAL_GPU) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "%s:Invalid parameter.VARenderModeExternalGPU is not supported.\n", __FUNCTION__);
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
if (((p->value & VA_RENDER_MODE_LOCAL_OVERLAY) && (p->value & VA_RENDER_MODE_LOCAL_GPU)) ||
((p->value & VA_RENDER_MODE_EXTERNAL_OVERLAY) && (p->value & VA_RENDER_MODE_EXTERNAL_GPU))) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "%s:Invalid parameter. Conflict setting for VADisplayAttribRenderMode.\n", __FUNCTION__);
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
#endif
driver_data->render_mode = p->value & VA_RENDER_MODE_MASK;
break;
case VADisplayAttribRenderRect:
driver_data->render_rect.x = ((VARectangle *)(p->attrib_ptr))->x;
driver_data->render_rect.y = ((VARectangle *)(p->attrib_ptr))->y;
driver_data->render_rect.width = ((VARectangle *)(p->attrib_ptr))->width;
driver_data->render_rect.height = ((VARectangle *)(p->attrib_ptr))->height;
break;
default:
break;
}
p++;
}
if (update_coeffs) {
/* TODO */
#ifndef ANDROID
texture_priv->update_coeffs = 1;
#endif
}
return VA_STATUS_SUCCESS;
}