/*
* 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>
*
*/
#include <va/va_backend.h>
#include "psb_surface.h"
#include "psb_output.h"
#include "psb_surface_ext.h"
#include "psb_x11.h"
#include "psb_xrandr.h"
#include "psb_drv_debug.h"
#include <X11/extensions/dpms.h>
#include <wsbm/wsbm_manager.h>
#define INIT_DRIVER_DATA psb_driver_data_p driver_data = (psb_driver_data_p) ctx->pDriverData;
#define INIT_OUTPUT_PRIV psb_x11_output_p output = (psb_x11_output_p)(((psb_driver_data_p)ctx->pDriverData)->ws_priv)
#define SURFACE(id) ((object_surface_p) object_heap_lookup( &driver_data->surface_heap, id ))
static int psb_CheckDrawable(VADriverContextP ctx, Drawable draw);
int (*oldHandler)(Display *, XErrorEvent *) = 0;
static int XErrorFlag = 1;
static int psb_XErrorHandler(Display *dpy, XErrorEvent *event)
{
drv_debug_msg(VIDEO_DEBUG_GENERAL, "XErrorEvent caught in psb_XErrorHandler in psb_xvva.c\n");
if (event->type == 0 && event->request_code == 132 && event->error_code == 11 /* BadAlloc */) {
XErrorFlag = 1;
return 0;
}
return oldHandler(dpy, event);
}
static int GetPortId(VADriverContextP ctx, psb_x11_output_p output)
{
int i, j, k;
unsigned int numAdapt;
int numImages;
XvImageFormatValues *formats;
XvAdaptorInfo *info;
int ret, grab_ret;
Display *dpy = (Display *)ctx->native_dpy;
ret = XvQueryAdaptors(dpy, DefaultRootWindow(dpy), &numAdapt, &info);
/*Force overlay port num equal to one. OverlayC can't be used independently now.*/
/* check for numAdapt before modifying the info[1]. Without this check
* it will cause a memory corruption leading to segfaults */
if (numAdapt > 1)
info[1].num_ports = 1;
if (Success != ret) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Can't find Xvideo adaptor\n");
return -1;
}
grab_ret = XGrabServer(ctx->native_dpy);
for (i = 0; i < numAdapt; i++) {
if ((info[i].type & XvImageMask) == 0)
continue;
formats = XvListImageFormats(dpy, info[i].base_id, &numImages);
for (j = 0; j < numImages; j++) {
if (formats[j].id != FOURCC_XVVA) continue;
for (k = 0; k < info[i].num_ports; k++) {
int ret = XvGrabPort(dpy, info[i].base_id + k, CurrentTime);
if (Success == ret) {
/* for textured adaptor 0 */
if (i == 0)
output->textured_portID = info[i].base_id + k;
/* for overlay adaptor 1 */
if (i == 1)
output->overlay_portID = info[i].base_id + k;
break;
}
}
}
XFree(formats);
}
if (grab_ret != 0)
XUngrabServer(ctx->native_dpy);
if ((output->textured_portID == 0) && (output->overlay_portID == 0)) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Can't detect any usable Xv XVVA port\n");
return -1;
}
return 0;
}
VAStatus psb_init_xvideo(VADriverContextP ctx, psb_x11_output_p output)
{
#ifdef _FOR_FPGA_
return VA_STATUS_SUCCESS;
#endif
INIT_DRIVER_DATA;
int dummy, ret;
output->textured_portID = output->overlay_portID = 0;
if (GetPortId(ctx, output)) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Grab Xvideo port failed, fallback to software vaPutSurface.\n");
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
if (output->textured_portID)
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Detected textured Xvideo port_id = %d.\n", (unsigned int)output->textured_portID);
if (output->overlay_portID)
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Detected overlay Xvideo port_id = %d.\n", (unsigned int)output->overlay_portID);
output->sprite_enabled = 0;
if (getenv("PSB_SPRITE_ENABLE")) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "use sprite plane to playback rotated protected video\n");
output->sprite_enabled = 1;
}
output->ignore_dpm = 1;
if (getenv("PSB_VIDEO_DPMS_HACK")) {
if (DPMSQueryExtension((Display *)ctx->native_dpy, &dummy, &dummy)
&& DPMSCapable((Display *)ctx->native_dpy)) {
BOOL onoff;
CARD16 state;
DPMSInfo((Display *)ctx->native_dpy, &state, &onoff);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "DPMS is %s, monitor state=%s\n", onoff ? "enabled" : "disabled",
(state == DPMSModeOn) ? "on" : (
(state == DPMSModeOff) ? "off" : (
(state == DPMSModeStandby) ? "standby" : (
(state == DPMSModeSuspend) ? "suspend" : "unknow"))));
if (onoff)
output->ignore_dpm = 0;
}
}
/* by default, overlay Xv */
if (output->textured_portID)
driver_data->output_method = PSB_PUTSURFACE_TEXTURE;
if (output->overlay_portID)
driver_data->output_method = PSB_PUTSURFACE_OVERLAY;
ret = psb_xrandr_init(ctx);
if (ret != 0) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to initialize psb xrandr error # %d\n", __func__, ret);
return VA_STATUS_ERROR_UNKNOWN;
}
return VA_STATUS_SUCCESS;
}
VAStatus psb_deinit_xvideo(VADriverContextP ctx)
{
INIT_DRIVER_DATA;
INIT_OUTPUT_PRIV;
if (output->gc) {
XFreeGC((Display *)ctx->native_dpy, output->gc);
output->gc = NULL;
}
if (output->extend_gc) {
XFreeGC((Display *)ctx->native_dpy, output->extend_gc);
output->extend_gc = NULL;
}
if (output->textured_xvimage) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Destroy XvImage for texture Xv\n");
XFree(output->textured_xvimage);
output->textured_xvimage = NULL;
}
if (output->overlay_xvimage) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Destroy XvImage for overlay Xv\n");
XFree(output->overlay_xvimage);
output->textured_xvimage = NULL;
}
if (output->textured_portID) {
if ((output->using_port == USING_TEXTURE_PORT) && output->output_drawable
&& (psb_CheckDrawable(ctx, output->output_drawable) == 0)) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Deinit: stop textured Xvideo\n");
XvStopVideo((Display *)ctx->native_dpy, output->textured_portID, output->output_drawable);
}
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Deinit: ungrab textured Xvideo port\n");
XvUngrabPort((Display *)ctx->native_dpy, output->textured_portID, CurrentTime);
output->textured_portID = 0;
}
if (output->overlay_portID) {
if ((output->using_port == USING_OVERLAY_PORT) && output->output_drawable
&& (psb_CheckDrawable(ctx, output->output_drawable) == 0)) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Deinit: stop overlay Xvideo\n");
XvStopVideo((Display *)ctx->native_dpy, output->overlay_portID, output->output_drawable);
}
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Deinit: ungrab overlay Xvideo port\n");
XvUngrabPort((Display *)ctx->native_dpy, output->overlay_portID, CurrentTime);
output->overlay_portID = 0;
}
if (driver_data->use_xrandr_thread && driver_data->xrandr_thread_id) {
psb_xrandr_thread_exit();
pthread_join(driver_data->xrandr_thread_id, NULL);
driver_data->xrandr_thread_id = 0;
}
psb_xrandr_deinit();
output->using_port = 0;
output->output_drawable = 0;
output->extend_drawable = 0;
#ifndef _FOR_FPGA_
XSync((Display *)ctx->native_dpy, False);
#endif
return VA_STATUS_SUCCESS;
}
static void psb_surface_init(
psb_driver_data_p driver_data,
PsbVASurfaceRec *srf,
int fourcc, int bpp, int w, int h, int stride, int size, unsigned int pre_add,
struct _WsbmBufferObject *bo, int flags
)
{
memset(srf, 0, sizeof(*srf));
srf->fourcc = fourcc;
srf->bo = bo;
if (bo != NULL) {
srf->bufid = wsbmKBufHandle(wsbmKBuf(bo));
srf->pl_flags = wsbmBOPlacementHint(bo);
}
/*
if (srf->pl_flags & DRM_PSB_FLAG_MEM_CI)
srf->reserved_phyaddr = driver_data->camera_phyaddr;
if (srf->pl_flags & DRM_PSB_FLAG_MEM_RAR)
srf->reserved_phyaddr = driver_data->rar_phyaddr;
*/
srf->bytes_pp = bpp;
srf->width = w;
srf->pre_add = pre_add;
if ((flags == VA_TOP_FIELD) || (flags == VA_BOTTOM_FIELD)) {
if (driver_data->output_method == PSB_PUTSURFACE_FORCE_OVERLAY
|| driver_data->output_method == PSB_PUTSURFACE_OVERLAY) {
srf->height = h;
srf->stride = stride;
} else {
srf->height = h / 2;
srf->stride = stride * 2;
}
if (flags == VA_BOTTOM_FIELD)
srf->pre_add += stride;
} else {
srf->height = h;
srf->stride = stride;
}
srf->size = size;
if (flags == VA_CLEAR_DRAWABLE) {
srf->clear_color = driver_data->clear_color; /* color */
return;
}
}
#if 0
#define WINDOW 1
#define PIXMAP 0
/* return 0 for no rotation, 1 for rotation occurs */
/* XRRGetScreenInfo has significant performance drop */
static int psb__CheckCurrentRotation(VADriverContextP ctx)
{
Rotation current_rotation;
XRRScreenConfiguration *scrn_cfg;
scrn_cfg = XRRGetScreenInfo((Display *)ctx->native_dpy, DefaultRootWindow((Display *)ctx->native_dpy));
XRRConfigCurrentConfiguration(scrn_cfg, ¤t_rotation);
XRRFreeScreenConfigInfo(scrn_cfg);
return (current_rotation & 0x0f);
}
/* Check drawable type, 1 for window, 0 for pixmap
* Have significant performance drop in XFCE environment
*/
static void psb__CheckDrawableType(Display *dpy, Window win, Drawable draw, int *type_ret)
{
unsigned int child_num;
Window root_return;
Window parent_return;
Window *child_return;
int i;
if (win == draw) {
*type_ret = 1;
return;
}
XQueryTree(dpy, win, &root_return, &parent_return, &child_return, &child_num);
if (!child_num)
return;
for (i = 0; i < child_num; i++)
psb__CheckDrawableType(dpy, child_return[i], draw, type_ret);
}
#endif
static int psb_CheckDrawable(VADriverContextP ctx, Drawable draw)
{
INIT_DRIVER_DATA;
INIT_OUTPUT_PRIV;
Atom xvDrawable = XInternAtom((Display *)ctx->native_dpy, "XV_DRAWABLE", 0);
int val = 0;
driver_data->drawable_info = 0;
if (output->overlay_portID) {
XvSetPortAttribute((Display *)ctx->native_dpy, output->overlay_portID, xvDrawable, draw);
XvGetPortAttribute((Display *)ctx->native_dpy, output->overlay_portID, xvDrawable, &val);
} else if (output->textured_portID) {
XvSetPortAttribute((Display *)ctx->native_dpy, output->textured_portID, xvDrawable, draw);
XvGetPortAttribute((Display *)ctx->native_dpy, output->textured_portID, xvDrawable, &val);
}
driver_data->drawable_info = val;
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Get xvDrawable = 0x%08x\n", val);
if (driver_data->drawable_info == XVDRAWABLE_INVALID_DRAWABLE)
return -1;
return 0;
}
static int psb__CheckPutSurfaceXvPort(
VADriverContextP ctx,
VASurfaceID surface,
Drawable draw, /* X Drawable */
short srcx,
short srcy,
unsigned short srcw,
unsigned short srch,
short destx,
short desty,
unsigned short destw,
unsigned short desth,
VARectangle *cliprects, /* client supplied clip list */
unsigned int number_cliprects, /* number of clip rects in the clip list */
unsigned int flags /* de-interlacing flags */
)
{
INIT_DRIVER_DATA;
INIT_OUTPUT_PRIV;
object_surface_p obj_surface = SURFACE(surface);
uint32_t buf_pl;
/* silent klockwork */
if (obj_surface && obj_surface->psb_surface)
buf_pl = obj_surface->psb_surface->buf.pl_flags;
else
return -1;
if (flags & VA_CLEAR_DRAWABLE)
return 0;
if (output->overlay_portID == 0) { /* no overlay usable */
driver_data->output_method = PSB_PUTSURFACE_TEXTURE;
return 0;
}
if (driver_data->output_method == PSB_PUTSURFACE_FORCE_OVERLAY) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Force Overlay Xvideo for PutSurface\n");
return 0;
}
if ((driver_data->output_method == PSB_PUTSURFACE_FORCE_TEXTURE)) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Force Textured Xvideo for PutSurface\n");
return 0;
}
if (((buf_pl & (WSBM_PL_FLAG_TT)) == 0) /* buf not in TT/RAR or CI */
|| (obj_surface->width > 1920) /* overlay have isue to support >1920xXXX resolution */
|| (obj_surface->subpic_count > 0) /* overlay can't support subpicture */
/* || (flags & (VA_TOP_FIELD|VA_BOTTOM_FIELD))*/
) {
driver_data->output_method = PSB_PUTSURFACE_TEXTURE;
return 0;
}
/* Here should be overlay XV by defaut after overlay is stable */
driver_data->output_method = PSB_PUTSURFACE_OVERLAY;
/* driver_data->output_method = PSB_PUTSURFACE_TEXTURE; */
/*
*Query Overlay Adaptor by XvDrawable Attribute to know current
* Xrandr information:rotation/downscaling
* also set target drawable(window vs pixmap) into XvDrawable
* to levage Xserver to determiate it is Pixmap or Window
*/
/*
*ROTATE_90: 0x2, ROTATE_180: 0x4, ROTATE_270:0x8
*Overlay adopator can support video rotation,
*but its performance is lower than texture video path.
*When video protection and rotation are required (use RAR buffer),
*only overlay adaptor will be used.
*other attribute like down scaling and pixmap, use texture adaptor
*/
if (driver_data->drawable_info
& (XVDRAWABLE_ROTATE_180 | XVDRAWABLE_ROTATE_90 | XVDRAWABLE_ROTATE_270)) {
driver_data->output_method = PSB_PUTSURFACE_TEXTURE;
}
if (driver_data->drawable_info & (XVDRAWABLE_PIXMAP | XVDRAWABLE_REDIRECT_WINDOW))
driver_data->output_method = PSB_PUTSURFACE_TEXTURE;
if (srcw >= destw * 8 || srch >= desth * 8)
driver_data->output_method = PSB_PUTSURFACE_TEXTURE;
return 0;
}
static int psb__CheckGCXvImage(
VADriverContextP ctx,
VASurfaceID surface,
Drawable draw,
XvImage **xvImage,
XvPortID *port_id,
unsigned int flags /* de-interlacing flags */
)
{
INIT_DRIVER_DATA;
INIT_OUTPUT_PRIV;
object_surface_p obj_surface = SURFACE(surface); /* surface already checked */
if (output->output_drawable != draw) {
if (output->gc)
XFreeGC((Display *)ctx->native_dpy, output->gc);
output->gc = XCreateGC((Display *)ctx->native_dpy, draw, 0, NULL);
output->output_drawable = draw;
}
if (flags & VA_CLEAR_DRAWABLE) {
if (output->textured_portID && (output->using_port == USING_TEXTURE_PORT)) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Clear drawable, and stop textured Xvideo\n");
XvStopVideo((Display *)ctx->native_dpy, output->textured_portID, draw);
}
if (output->overlay_portID && (output->using_port == USING_OVERLAY_PORT)) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Clear drawable, and stop overlay Xvideo\n");
XvStopVideo((Display *)ctx->native_dpy, output->overlay_portID, draw);
}
output->using_port = 0;
XSetForeground((Display *)ctx->native_dpy, output->gc, driver_data->clear_color);
return 0;
}
if ((driver_data->output_method == PSB_PUTSURFACE_FORCE_OVERLAY) ||
(driver_data->output_method == PSB_PUTSURFACE_OVERLAY)) {
/* use OVERLAY XVideo */
if (obj_surface &&
((output->output_width != obj_surface->width) ||
(output->output_height != obj_surface->height) ||
(!output->overlay_xvimage))) {
if (output->overlay_xvimage)
XFree(output->overlay_xvimage);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Create new XvImage for overlay\n");
output->overlay_xvimage = XvCreateImage((Display *)ctx->native_dpy, output->overlay_portID,
FOURCC_XVVA, 0,
obj_surface->width, obj_surface->height);
output->overlay_xvimage->data = (char *) & output->imgdata_vasrf;
output->output_width = obj_surface->width;
output->output_height = obj_surface->height;
}
*xvImage = output->overlay_xvimage;
*port_id = output->overlay_portID;
if ((output->textured_portID) && (output->using_port == USING_TEXTURE_PORT)) { /* stop texture port */
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Using overlay xvideo, stop textured xvideo\n");
XvStopVideo((Display *)ctx->native_dpy, output->textured_portID, draw);
XSync((Display *)ctx->native_dpy, False);
}
output->using_port = USING_OVERLAY_PORT;
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Using Overlay Xvideo (%d) for PutSurface\n", output->textured_portID);
return 0;
}
if ((driver_data->output_method == PSB_PUTSURFACE_FORCE_TEXTURE) ||
(driver_data->output_method == PSB_PUTSURFACE_TEXTURE)) {
/* use Textured XVideo */
if (obj_surface &&
((output->output_width != obj_surface->width) ||
(output->output_height != obj_surface->height ||
(!output->textured_xvimage)))) {
if (output->textured_xvimage)
XFree(output->textured_xvimage);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Create new XvImage for overlay\n");
output->textured_xvimage = XvCreateImage((Display *)ctx->native_dpy, output->textured_portID, FOURCC_XVVA, 0,
obj_surface->width, obj_surface->height);
output->textured_xvimage->data = (char *) & output->imgdata_vasrf;
output->output_width = obj_surface->width;
output->output_height = obj_surface->height;
}
*xvImage = output->textured_xvimage;
*port_id = output->textured_portID;
if ((output->overlay_portID) && (output->using_port == USING_OVERLAY_PORT)) { /* stop overlay port */
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Using textured xvideo, stop Overlay xvideo\n");
XvStopVideo((Display *)ctx->native_dpy, output->overlay_portID, draw);
XSync((Display *)ctx->native_dpy, False);
output->using_port = USING_TEXTURE_PORT;
}
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Using Texture Xvideo (%d) for PutSurface\n", output->textured_portID);
return 0;
}
return 0;
}
static int psb_force_dpms_on(VADriverContextP ctx)
{
BOOL onoff;
CARD16 state;
DPMSInfo((Display *)ctx->native_dpy, &state, &onoff);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "DPMS is %s, monitor state=%s\n", onoff ? "enabled" : "disabled",
(state == DPMSModeOn) ? "on" : (
(state == DPMSModeOff) ? "off" : (
(state == DPMSModeStandby) ? "standby" : (
(state == DPMSModeSuspend) ? "suspend" : "unknow"))));
if (onoff && (state != DPMSModeOn)) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "DPMS is enabled, and monitor isn't DPMSModeOn, force it on\n");
DPMSForceLevel((Display *)ctx->native_dpy, DPMSModeOn);
}
return 0;
}
VAStatus psb_check_rotatesurface(
VADriverContextP ctx,
unsigned short rotate_width,
unsigned short rotate_height,
unsigned int protected,
int fourcc
)
{
INIT_DRIVER_DATA;
INIT_OUTPUT_PRIV;
VAStatus vaStatus = VA_STATUS_SUCCESS;
object_surface_p obj_rotate_surface;
unsigned int flags = protected? IS_PROTECTED : 0;
if (output->rotate_surface) {
obj_rotate_surface = SURFACE(output->rotate_surfaceID);
if (obj_rotate_surface &&
((obj_rotate_surface->width != rotate_width)
|| (obj_rotate_surface->height != rotate_height))) {
psb_surface_destroy(output->rotate_surface);
free(output->rotate_surface);
object_heap_free(&driver_data->surface_heap, (object_base_p)obj_rotate_surface);
output->rotate_surface = NULL;
}
}
if (output->rotate_surface == NULL) {
output->rotate_surfaceID = object_heap_allocate(&driver_data->surface_heap);
obj_rotate_surface = SURFACE(output->rotate_surfaceID);
if (NULL == obj_rotate_surface) {
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
DEBUG_FAILURE;
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
obj_rotate_surface->surface_id = output->rotate_surfaceID;
obj_rotate_surface->context_id = -1;
obj_rotate_surface->width = rotate_width;
obj_rotate_surface->height = rotate_height;
obj_rotate_surface->subpictures = NULL;
obj_rotate_surface->subpic_count = 0;
obj_rotate_surface->derived_imgcnt = 0;
output->rotate_surface = (psb_surface_p) calloc(1, sizeof(struct psb_surface_s));
if (NULL == output->rotate_surface) {
object_heap_free(&driver_data->surface_heap, (object_base_p) obj_rotate_surface);
obj_rotate_surface->surface_id = VA_INVALID_SURFACE;
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
DEBUG_FAILURE;
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
flags |= IS_ROTATED;
vaStatus = psb_surface_create(driver_data, rotate_width, rotate_height,
fourcc, flags, output->rotate_surface);
if (VA_STATUS_SUCCESS != vaStatus) {
free(obj_rotate_surface->psb_surface);
object_heap_free(&driver_data->surface_heap, (object_base_p) obj_rotate_surface);
obj_rotate_surface->surface_id = VA_INVALID_SURFACE;
DEBUG_FAILURE;
return vaStatus;
}
obj_rotate_surface->psb_surface = output->rotate_surface;
}
return vaStatus;
}
VAStatus psb_putsurface_xvideo(
VADriverContextP ctx,
VASurfaceID surface,
Drawable draw,
short srcx,
short srcy,
unsigned short srcw,
unsigned short srch,
short destx,
short desty,
unsigned short destw,
unsigned short desth,
VARectangle *cliprects, /* client supplied clip list */
unsigned int number_cliprects, /* number of clip rects in the clip list */
unsigned int flags /* de-interlacing flags */
)
{
INIT_DRIVER_DATA;
INIT_OUTPUT_PRIV;
VAStatus vaStatus = VA_STATUS_SUCCESS;
PsbVASurfaceRec *subpic_surface;
PsbXvVAPutSurfacePtr vaPtr;
XvPortID portID = 0;
XvImage *xvImage = NULL;
object_surface_p obj_surface = SURFACE(surface);
psb_surface_p psb_surface;
int i = 0, j;
if (obj_surface) /* silent klockwork, we already check it */
psb_surface = obj_surface->psb_surface;
else
return VA_STATUS_ERROR_UNKNOWN;
/* Catch X protocol errors with our own error handler */
if (oldHandler == 0)
oldHandler = XSetErrorHandler(psb_XErrorHandler);
if (XErrorFlag == 1) {
if (psb_CheckDrawable(ctx, draw) != 0) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "vaPutSurface: invalidate drawable\n");
return VA_STATUS_ERROR_UNKNOWN;
}
drv_debug_msg(VIDEO_DEBUG_GENERAL, "ran psb_CheckDrawable the first time!\n");
XErrorFlag = 0;
}
/* check display configuration for every 100 frames */
if ((driver_data->frame_count % 100) == 0) {
if (psb_CheckDrawable(ctx, draw) != 0) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "vaPutSurface: invalidate drawable\n");
return VA_STATUS_ERROR_UNKNOWN;
}
drv_debug_msg(VIDEO_DEBUG_GENERAL, "ran psb_CheckDrawable the first time!\n");
}
psb__CheckPutSurfaceXvPort(ctx, surface, draw,
srcx, srcy, srcw, srch,
destx, desty, destw, desth,
cliprects, number_cliprects, flags);
psb__CheckGCXvImage(ctx, surface, draw, &xvImage, &portID, flags);
if (flags & VA_CLEAR_DRAWABLE) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Clean draw with color 0x%08x\n", driver_data->clear_color);
XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, destx, desty, destw, desth);
XSync((Display *)ctx->native_dpy, False);
XFreeGC((Display *)ctx->native_dpy, output->gc);
output->gc = NULL;
output->output_drawable = 0;
XSync((Display *)ctx->native_dpy, False);
driver_data->cur_displaying_surface = VA_INVALID_SURFACE;
driver_data->last_displaying_surface = VA_INVALID_SURFACE;
obj_surface->display_timestamp = 0;
return vaStatus;
}
vaPtr = (PsbXvVAPutSurfacePtr)xvImage->data;
vaPtr->flags = flags;
vaPtr->num_subpicture = obj_surface->subpic_count;
vaPtr->num_clipbox = number_cliprects;
for (j = 0; j < number_cliprects; j++) {
vaPtr->clipbox[j].x = cliprects[j].x;
vaPtr->clipbox[j].y = cliprects[j].y;
vaPtr->clipbox[j].width = cliprects[j].width;
vaPtr->clipbox[j].height = cliprects[j].height;
}
psb_surface_init(driver_data, &vaPtr->src_srf, VA_FOURCC_NV12, 2,
obj_surface->width, obj_surface->height,
psb_surface->stride, psb_surface->size,
psb_surface->buf.buffer_ofs, /* for surface created from RAR/camera device memory
* all surfaces share one BO but with different offset
* pass the offset as the "pre_add"
*/
psb_surface->buf.drm_buf, flags);
if ((driver_data->output_method == PSB_PUTSURFACE_OVERLAY)
&& (driver_data->drawable_info & (XVDRAWABLE_ROTATE_180 | XVDRAWABLE_ROTATE_90 | XVDRAWABLE_ROTATE_270))) {
unsigned int rotate_width, rotate_height;
int fourcc;
if (output->sprite_enabled)
fourcc = VA_FOURCC_RGBA;
else
fourcc = VA_FOURCC_NV12;
if (driver_data->drawable_info & (XVDRAWABLE_ROTATE_90 | XVDRAWABLE_ROTATE_270)) {
rotate_width = obj_surface->height;
rotate_height = obj_surface->width;
} else {
rotate_width = obj_surface->width;
rotate_height = obj_surface->height;
}
unsigned int protected = vaPtr->src_srf.pl_flags & 0;
vaStatus = psb_check_rotatesurface(ctx, rotate_width, rotate_height, protected, fourcc);
if (VA_STATUS_SUCCESS != vaStatus)
return vaStatus;
psb_surface_init(driver_data, &vaPtr->dst_srf, fourcc, 4,
rotate_width, rotate_height,
output->rotate_surface->stride, output->rotate_surface->size,
output->rotate_surface->buf.buffer_ofs, /* for surface created from RAR/camera device memory
* all surfaces share one BO but with different offset
* pass the offset as the "pre_add"
*/
output->rotate_surface->buf.drm_buf, 0);
}
subpic_surface = obj_surface->subpictures;
while (subpic_surface) {
PsbVASurfaceRec *tmp = &vaPtr->subpic_srf[i++];
memcpy(tmp, subpic_surface, sizeof(*tmp));
/* reload palette for paletted subpicture
* palete_ptr point to image palette
*/
if (subpic_surface->palette_ptr)
memcpy(&tmp->palette[0], subpic_surface->palette_ptr, 16 * sizeof(PsbAYUVSample8));
subpic_surface = subpic_surface->next;
}
if (output->ignore_dpm == 0)
psb_force_dpms_on(ctx);
XvPutImage((Display *)ctx->native_dpy, portID, draw, output->gc, xvImage,
srcx, srcy, srcw, srch, destx, desty, destw, desth);
XFlush((Display *)ctx->native_dpy);
//XSync((Display *)ctx->native_dpy, False);
if (portID == output->overlay_portID) {
if (driver_data->cur_displaying_surface != VA_INVALID_SURFACE)
driver_data->last_displaying_surface = driver_data->cur_displaying_surface;
obj_surface->display_timestamp = GetTickCount();
driver_data->cur_displaying_surface = surface;
} else {
driver_data->cur_displaying_surface = VA_INVALID_SURFACE;
driver_data->last_displaying_surface = VA_INVALID_SURFACE;
obj_surface->display_timestamp = 0;
}
return vaStatus;
}