/*
* 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:
* Jason Hu <jason.hu@intel.com>
* Zhaohan Ren <zhaohan.ren@intel.com>
*
*/
#include <unistd.h>
#include "psb_xrandr.h"
#include "psb_x11.h"
#include "psb_drv_debug.h"
/* Global variable for xrandr */
psb_xrandr_info_p psb_xrandr_info;
#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 MWM_HINTS_DECORATIONS (1L << 1)
typedef struct {
int flags;
int functions;
int decorations;
int input_mode;
int status;
} MWMHints;
char* location2string(psb_xrandr_location location)
{
switch (location) {
case ABOVE:
return "ABOVE";
break;
case BELOW:
return "BELOW";
break;
case LEFT_OF:
return "LEFT_OF";
break;
case RIGHT_OF:
return "RIGHT_OF";
break;
default:
return "NORMAL";
break;
}
}
static int RRrotation2VArotation(Rotation rotation)
{
switch (rotation) {
case RR_Rotate_0:
return VA_ROTATION_NONE;
case RR_Rotate_90:
return VA_ROTATION_270;
case RR_Rotate_180:
return VA_ROTATION_180;
case RR_Rotate_270:
return VA_ROTATION_90;
}
return 0;
}
static psb_xrandr_crtc_p get_crtc_by_id(RRCrtc crtc_id)
{
psb_xrandr_crtc_p p_crtc;
for (p_crtc = psb_xrandr_info->crtc_head; p_crtc; p_crtc = p_crtc->next)
if (p_crtc->crtc_id == crtc_id)
return p_crtc;
return NULL;
}
static void psb_xrandr_hdmi_property(VADriverContextP ctx)
{
INIT_DRIVER_DATA;
Atom *props;
Atom actual_type;
XRRPropertyInfo *propinfo;
int i, nprop, actual_format;
unsigned long nitems, bytes_after;
char* prop_name;
unsigned char* prop;
/* Check HDMI properties */
props = XRRListOutputProperties(psb_xrandr_info->dpy, psb_xrandr_info->extend_output->output_id, &nprop);
if (!props) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: XRRListOutputProperties failed\n", psb_xrandr_info->extend_output->output_id);
return;
}
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: extend output %08x has %d properties\n", psb_xrandr_info->extend_output->output_id, nprop);
for (i = 0; i < nprop; i++) {
XRRGetOutputProperty(psb_xrandr_info->dpy, psb_xrandr_info->extend_output->output_id, props[i],
0, 100, False, False, AnyPropertyType, &actual_type, &actual_format,
&nitems, &bytes_after, &prop);
propinfo = XRRQueryOutputProperty(psb_xrandr_info->dpy, psb_xrandr_info->extend_output->output_id, props[i]);
if (!propinfo) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: get output %08x prop %08x failed\n", psb_xrandr_info->extend_output->output_id, props[i]);
return;
}
prop_name = XGetAtomName(psb_xrandr_info->dpy, props[i]);
/* Currently all properties are XA_INTEGER, 32 */
if (!strcmp(prop_name, "ExtVideoMode")) {
psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtVideoMode (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode);
} else if (!strcmp(prop_name, "ExtVideoMode_Xres")) {
psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_XRes = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtVideoMode_XRes (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_XRes);
} else if (!strcmp(prop_name, "ExtVideoMode_Yres")) {
psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_YRes = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtVideoMode_YRes (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_YRes);
} else if (!strcmp(prop_name, "ExtVideoMode_X_Offset")) {
psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_X_Offset = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtVideoMode_X_Offset (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_X_Offset);
} else if (!strcmp(prop_name, "ExtVideoMode_Y_Offset")) {
psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_Y_Offset = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtVideoMode_Y_Offset (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_Y_Offset);
} else if (!strcmp(prop_name, "ExtVideoMode_Center")) {
psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_Center = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtVideoMode_Center (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_Center);
} else if (!strcmp(prop_name, "ExtVideoMode_SubTitle")) {
psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_SubTitle = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtVideoMode_SubTitle (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_SubTitle);
} else if (!strcmp(prop_name, "ExtDesktopMode")) {
if ((psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode != EXTENDEDVIDEO) &&
((int)((INT32*)prop)[0] == EXTENDEDVIDEO)) {
driver_data->xrandr_dirty |= PSB_NEW_EXTVIDEO;
}
psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: ExtDesktopMode (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode);
} else if (!strcmp(prop_name, "OverscanMode")) {
psb_xrandr_info->hdmi_extvideo_prop->OverscanMode = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: OverscanMode (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->OverscanMode);
} else if (!strcmp(prop_name, "PANELFITTING")) {
psb_xrandr_info->hdmi_extvideo_prop->PANELFITTING = (int)((INT32*)prop)[0];
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: PANELFITTING (%08x)\n", psb_xrandr_info->hdmi_extvideo_prop->PANELFITTING);
}
}
}
static void psb_xrandr_mipi_location_init(psb_output_device_mode output_device_mode)
{
psb_xrandr_crtc_p local_crtc = NULL, extend_crtc = NULL;
switch (output_device_mode) {
case SINGLE_MIPI0:
psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode = SINGLE;
psb_xrandr_info->local_crtc[0]->location = NORMAL;
return;
case SINGLE_MIPI1:
psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode = SINGLE;
psb_xrandr_info->local_crtc[1]->location = NORMAL;
return;
case MIPI0_MIPI1:
local_crtc = psb_xrandr_info->local_crtc[0];
extend_crtc = psb_xrandr_info->local_crtc[1];
break;
default:
break;
}
if (!local_crtc || !extend_crtc) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Failed to get crtc info\n");
return;
}
/* MIPI1 clone MIPI0 */
if (local_crtc->x == 0 && local_crtc->y == 0 &&
extend_crtc->x == 0 && extend_crtc->y == 0) {
psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode = CLONE;
extend_crtc->location = NORMAL;
} else {
/* MIPI1 entend MIPI0 */
psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode = EXTENDED;
if (local_crtc->y == extend_crtc->height)
extend_crtc->location = ABOVE;
else if (extend_crtc->y == local_crtc->height)
extend_crtc->location = BELOW;
else if (local_crtc->x == extend_crtc->width)
extend_crtc->location = LEFT_OF;
else if (extend_crtc->x == local_crtc->width)
extend_crtc->location = RIGHT_OF;
}
}
static void psb_xrandr_hdmi_location_init(psb_output_device_mode output_device_mode)
{
psb_xrandr_crtc_p local_crtc = NULL, extend_crtc = NULL;
switch (output_device_mode) {
case SINGLE_HDMI:
psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode = SINGLE;
psb_xrandr_info->extend_crtc->location = NORMAL;
return;
case MIPI0_HDMI:
case MIPI0_MIPI1_HDMI:
local_crtc = psb_xrandr_info->local_crtc[0];
extend_crtc = psb_xrandr_info->extend_crtc;
break;
case MIPI1_HDMI:
local_crtc = psb_xrandr_info->local_crtc[1];
extend_crtc = psb_xrandr_info->extend_crtc;
break;
default:
break;
}
if (!local_crtc || !extend_crtc) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Failed to get crtc info\n");
return;
}
if (psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode == CLONE)
psb_xrandr_info->extend_crtc->location = NORMAL;
if (psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode == EXTENDED
|| psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode == EXTENDEDVIDEO) {
if (local_crtc->y == extend_crtc->height)
psb_xrandr_info->extend_crtc->location = ABOVE;
else if (extend_crtc->y == local_crtc->height)
psb_xrandr_info->extend_crtc->location = BELOW;
else if (local_crtc->x == extend_crtc->width)
psb_xrandr_info->extend_crtc->location = LEFT_OF;
else if (extend_crtc->x == local_crtc->width)
psb_xrandr_info->extend_crtc->location = RIGHT_OF;
}
}
static void psb_xrandr_coordinate_init(VADriverContextP ctx)
{
INIT_DRIVER_DATA;
psb_xrandr_output_p p_output;
psb_xrandr_info->output_changed = 1;
for (p_output = psb_xrandr_info->output_head; p_output; p_output = p_output->next) {
if (p_output->connection == RR_Connected) {
if (!strcmp(p_output->name, "MIPI0")) {
if (p_output->crtc) {
psb_xrandr_info->mipi0_enabled = 1;
psb_xrandr_info->local_output[0] = p_output;
psb_xrandr_info->local_crtc[0] = p_output->crtc;
if (psb_xrandr_info->mipi0_rotation != p_output->crtc->rotation) {
psb_xrandr_info->mipi0_rotation = p_output->crtc->rotation;
driver_data->mipi0_rotation = RRrotation2VArotation(psb_xrandr_info->mipi0_rotation);
driver_data->xrandr_dirty |= PSB_NEW_ROTATION;
}
} else {
psb_xrandr_info->mipi0_enabled = 0;
psb_xrandr_info->local_output[0] = NULL;
psb_xrandr_info->local_crtc[0] = NULL;
}
} else if (!strcmp(p_output->name, "MIPI1")) {
if (p_output->crtc) {
psb_xrandr_info->mipi1_enabled = 1;
psb_xrandr_info->local_output[1] = p_output;
psb_xrandr_info->local_crtc[1] = p_output->crtc;
if (psb_xrandr_info->mipi1_rotation != p_output->crtc->rotation) {
psb_xrandr_info->mipi1_rotation = p_output->crtc->rotation;
driver_data->mipi1_rotation = RRrotation2VArotation(psb_xrandr_info->mipi1_rotation);
driver_data->xrandr_dirty |= PSB_NEW_ROTATION;
}
} else {
psb_xrandr_info->mipi1_enabled = 0;
psb_xrandr_info->local_output[1] = NULL;
psb_xrandr_info->local_crtc[1] = NULL;
}
} else if (!strcmp(p_output->name, "TMDS0-1")) {
if (p_output->crtc) {
psb_xrandr_info->hdmi_enabled = 1;
psb_xrandr_info->extend_output = p_output;
psb_xrandr_info->extend_crtc = p_output->crtc;
if (psb_xrandr_info->hdmi_rotation != p_output->crtc->rotation) {
psb_xrandr_info->hdmi_rotation = p_output->crtc->rotation;
driver_data->hdmi_rotation = RRrotation2VArotation(psb_xrandr_info->hdmi_rotation);
driver_data->xrandr_dirty |= PSB_NEW_ROTATION;
}
} else {
psb_xrandr_info->hdmi_enabled = 0;
psb_xrandr_info->extend_output = NULL;
psb_xrandr_info->extend_crtc = NULL;
}
} else if (!strcmp(p_output->name, "LVDS0") && IS_MRST(driver_data)) {
if (p_output->crtc) {
psb_xrandr_info->lvds0_enabled = 1;
psb_xrandr_info->local_output[0] = p_output;
psb_xrandr_info->local_crtc[0] = p_output->crtc;
} else {
psb_xrandr_info->lvds0_enabled = 0;
psb_xrandr_info->local_output[0] = NULL;
psb_xrandr_info->local_crtc[0] = NULL;
}
}
}
}
/* for MRST */
if (IS_MRST(driver_data) && psb_xrandr_info->lvds0_enabled) {
psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode = SINGLE;
psb_xrandr_info->output_device_mode = SINGLE_LVDS0;
psb_xrandr_info->local_crtc[0]->location = NORMAL;
return;
}
/* HDMI + either MIPI0 or MIPI1 */
if (psb_xrandr_info->hdmi_enabled) {
/* Get HDMI properties if it is enabled*/
psb_xrandr_hdmi_property(ctx);
/* Only HDMI */
if (!psb_xrandr_info->mipi0_enabled && !psb_xrandr_info->mipi1_enabled)
psb_xrandr_info->output_device_mode = SINGLE_HDMI;
/* HDMI + MIPI0 */
if (psb_xrandr_info->mipi0_enabled && !psb_xrandr_info->mipi1_enabled)
psb_xrandr_info->output_device_mode = MIPI0_HDMI;
/* HDMI + MIPI1 */
if (!psb_xrandr_info->mipi0_enabled && psb_xrandr_info->mipi1_enabled)
psb_xrandr_info->output_device_mode = MIPI1_HDMI;
/* HDMI + MIPI0 + MIPI1 */
if (psb_xrandr_info->mipi0_enabled && psb_xrandr_info->mipi1_enabled)
psb_xrandr_info->output_device_mode = MIPI0_MIPI1_HDMI;
psb_xrandr_hdmi_location_init(psb_xrandr_info->output_device_mode);
} else {
/* MIPI0 + MIPI1 */
if (psb_xrandr_info->mipi0_enabled && psb_xrandr_info->mipi1_enabled) {
psb_xrandr_info->output_device_mode = MIPI0_MIPI1;
} else {
/* MIPI0/MIPI1 */
if (psb_xrandr_info->mipi0_enabled)
psb_xrandr_info->output_device_mode = SINGLE_MIPI0;
else if (psb_xrandr_info->mipi1_enabled)
psb_xrandr_info->output_device_mode = SINGLE_MIPI1;
}
psb_xrandr_mipi_location_init(psb_xrandr_info->output_device_mode);
}
}
void psb_xrandr_refresh(VADriverContextP ctx)
{
int i;
XRROutputInfo *output_info;
XRRCrtcInfo *crtc_info;
psb_xrandr_crtc_p p_crtc;
psb_xrandr_output_p p_output;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
//deinit crtc
if (psb_xrandr_info->crtc_head) {
while (psb_xrandr_info->crtc_head) {
psb_xrandr_info->crtc_tail = psb_xrandr_info->crtc_head->next;
free(psb_xrandr_info->crtc_head);
psb_xrandr_info->crtc_head = psb_xrandr_info->crtc_tail;
}
psb_xrandr_info->crtc_head = psb_xrandr_info->crtc_tail = NULL;
}
for (i = 0; i < psb_xrandr_info->res->ncrtc; i++) {
crtc_info = XRRGetCrtcInfo(psb_xrandr_info->dpy, psb_xrandr_info->res, psb_xrandr_info->res->crtcs[i]);
if (crtc_info) {
p_crtc = (psb_xrandr_crtc_p)calloc(1, sizeof(psb_xrandr_crtc_s));
if (!p_crtc) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "output of memory\n");
return;
}
if (i == 0)
psb_xrandr_info->crtc_head = psb_xrandr_info->crtc_tail = p_crtc;
p_crtc->crtc_id = psb_xrandr_info->res->crtcs[i];
p_crtc->x = crtc_info->x;
p_crtc->y = crtc_info->y;
p_crtc->width = crtc_info->width;
p_crtc->height = crtc_info->height;
p_crtc->crtc_mode = crtc_info->mode;
p_crtc->noutput = crtc_info->noutput;
p_crtc->rotation = crtc_info->rotation;
psb_xrandr_info->crtc_tail->next = p_crtc;
p_crtc->next = NULL;
psb_xrandr_info->crtc_tail = p_crtc;
} else {
drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to get crtc_info\n");
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return;
}
}
//deinit output
if (psb_xrandr_info->output_head) {
while (psb_xrandr_info->output_head) {
psb_xrandr_info->output_tail = psb_xrandr_info->output_head->next;
free(psb_xrandr_info->output_head);
psb_xrandr_info->output_head = psb_xrandr_info->output_tail;
}
psb_xrandr_info->output_head = psb_xrandr_info->output_tail = NULL;
}
#if 0
//destroy the full-screen window
//FIXME: commited out for X Error message: BadDrawable, need more investigation
if (va_output) {
if (va_output->extend_drawable) {
XDestroyWindow(ctx->native_dpy, va_output->extend_drawable);
va_output->extend_drawable = 0;
texture_priv->extend_dri_init_flag = 0;
}
}
#endif
for (i = 0; i < psb_xrandr_info->res->noutput; i++) {
output_info = XRRGetOutputInfo(psb_xrandr_info->dpy, psb_xrandr_info->res, psb_xrandr_info->res->outputs[i]);
if (output_info) {
p_output = (psb_xrandr_output_p)calloc(1, sizeof(psb_xrandr_output_s));
if (!p_output) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "output of memory\n");
return;
}
if (i == 0)
psb_xrandr_info->output_head = psb_xrandr_info->output_tail = p_output;
p_output->output_id = psb_xrandr_info->res->outputs[i];
p_output->connection = output_info->connection;
if (p_output->connection == RR_Connected)
psb_xrandr_info->nconnected_output++;
strcpy(p_output->name, output_info->name);
if (output_info->crtc)
p_output->crtc = get_crtc_by_id(output_info->crtc);
else
p_output->crtc = NULL;
psb_xrandr_info->output_tail->next = p_output;
p_output->next = NULL;
psb_xrandr_info->output_tail = p_output;
} else {
drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to get output_info\n");
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return;
}
}
psb_xrandr_coordinate_init(ctx);
psb_RecalcRotate(ctx);
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
}
static Bool
outputChangePredicate(Display *display, XEvent *event, char *args)
{
int event_base, error_base;
XRRQueryExtension(psb_xrandr_info->dpy, &event_base, &error_base);
return ((event->type == event_base + RRNotify_OutputChange) ||
((event->type == ClientMessage) &&
(((XClientMessageEvent*)event)->message_type == psb_xrandr_info->psb_exit_atom)));
}
void psb_xrandr_thread(void* arg)
{
VADriverContextP ctx = (VADriverContextP)arg;
INIT_DRIVER_DATA;
int event_base, error_base;
XEvent event;
XRRQueryExtension(psb_xrandr_info->dpy, &event_base, &error_base);
XRRSelectInput(psb_xrandr_info->dpy, psb_xrandr_info->root, RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask | RROutputPropertyNotifyMask);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: psb xrandr thread start\n");
while (1) {
if (XCheckIfEvent(psb_xrandr_info->dpy, (XEvent *)&event, outputChangePredicate, NULL)) {
if (event.type == ClientMessage) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: receive ClientMessage event, thread should exit\n");
XClientMessageEvent *evt;
evt = (XClientMessageEvent*) & event;
if (evt->message_type == psb_xrandr_info->psb_exit_atom) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: xrandr thread exit safely\n");
pthread_exit(NULL);
}
}
switch (event.type - event_base) {
case RRNotify_OutputChange:
XRRUpdateConfiguration(&event);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: receive RRNotify_OutputChange event, refresh output/crtc info\n");
driver_data->xrandr_update = 1;
psb_xrandr_refresh(ctx);
break;
default:
break;
}
}
usleep(200000);
}
}
Window psb_xrandr_create_full_screen_window(unsigned int destx, unsigned int desty, unsigned int destw, unsigned int desth)
{
int x, y, width, height;
Window win;
x = psb_xrandr_info->extend_crtc->x;
y = psb_xrandr_info->extend_crtc->y;
width = psb_xrandr_info->extend_crtc->width;
height = psb_xrandr_info->extend_crtc->height;
if (destw == 0 || desth == 0) {
destw = width;
desth = height;
}
win = XCreateSimpleWindow(psb_xrandr_info->dpy, DefaultRootWindow(psb_xrandr_info->dpy), destx, desty, destw, desth, 0, 0, 0);
MWMHints mwmhints;
Atom MOTIF_WM_HINTS;
mwmhints.flags = MWM_HINTS_DECORATIONS;
mwmhints.decorations = 0; /* MWM_DECOR_BORDER */
MOTIF_WM_HINTS = XInternAtom(psb_xrandr_info->dpy, "_MOTIF_WM_HINTS", False);
XChangeProperty(psb_xrandr_info->dpy, win, MOTIF_WM_HINTS, MOTIF_WM_HINTS, sizeof(long) * 8,
PropModeReplace, (unsigned char*) &mwmhints, sizeof(mwmhints) / sizeof(long));
XSetWindowAttributes attributes;
attributes.override_redirect = 1;
unsigned long valuemask;
valuemask = CWOverrideRedirect ;
XChangeWindowAttributes(psb_xrandr_info->dpy, win, valuemask, &attributes);
XMapWindow(psb_xrandr_info->dpy, win);
XFlush(psb_xrandr_info->dpy);
return win;
}
int psb_xrandr_hdmi_enabled()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
ret = psb_xrandr_info->hdmi_enabled;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
int psb_xrandr_mipi0_enabled()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
ret = psb_xrandr_info->mipi0_enabled;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
int psb_xrandr_mipi1_enabled()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
ret = psb_xrandr_info->mipi1_enabled;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
int psb_xrandr_single_mode()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
ret = (psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode == SINGLE) ? 1 : 0;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
int psb_xrandr_clone_mode()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
ret = (psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode == CLONE) ? 1 : 0;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
int psb_xrandr_extend_mode()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
ret = (psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode == EXTENDED) ? 1 : 0;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
int psb_xrandr_extvideo_mode()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
ret = (psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode == EXTENDEDVIDEO) ? 1 : 0;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
int psb_xrandr_outputchanged()
{
int ret;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
if (psb_xrandr_info->output_changed) {
psb_xrandr_info->output_changed = 0;
ret = 1;
} else
ret = 0;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return ret;
}
VAStatus psb_xrandr_extvideo_prop(unsigned int *xres, unsigned int *yres, unsigned int *xoffset,
unsigned int *yoffset, psb_extvideo_center *center, psb_extvideo_subtitle *subtitle,
unsigned int *overscanmode, unsigned int *pannelfitting)
{
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
if (psb_xrandr_info->hdmi_extvideo_prop->ExtDesktopMode != EXTENDEDVIDEO) {
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return VA_STATUS_ERROR_UNKNOWN;
}
*xres = psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_XRes;
*yres = psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_YRes;
*xoffset = psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_X_Offset;
*yoffset = psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_Y_Offset;
*center = psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_Center;
*subtitle = psb_xrandr_info->hdmi_extvideo_prop->ExtVideoMode_SubTitle;
*pannelfitting = psb_xrandr_info->hdmi_extvideo_prop->PANELFITTING;
*overscanmode = psb_xrandr_info->hdmi_extvideo_prop->OverscanMode;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return VA_STATUS_SUCCESS;
}
VAStatus psb_xrandr_local_crtc_coordinate(psb_output_device *local_device_enabled, int *x, int *y, int *width, int *height, Rotation *rotation)
{
psb_xrandr_crtc_p p_crtc;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
switch (psb_xrandr_info->output_device_mode) {
case SINGLE_LVDS0:
*local_device_enabled = LVDS0;
p_crtc = psb_xrandr_info->local_crtc[0];
break;
case SINGLE_MIPI0:
case MIPI0_MIPI1:
case MIPI0_HDMI:
case MIPI0_MIPI1_HDMI:
*local_device_enabled = MIPI0;
p_crtc = psb_xrandr_info->local_crtc[0];
break;
case SINGLE_MIPI1:
case MIPI1_HDMI:
*local_device_enabled = MIPI1;
p_crtc = psb_xrandr_info->local_crtc[1];
break;
case SINGLE_HDMI:
*local_device_enabled = HDMI;
p_crtc = psb_xrandr_info->extend_crtc;
break;
default:
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: Unknown statue\n");
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return VA_STATUS_ERROR_UNKNOWN;
break;
}
if (p_crtc) {
*x = p_crtc->x;
*y = p_crtc->y;
*width = p_crtc->width;
*height = p_crtc->height;
*rotation = p_crtc->rotation;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: device %08x enabled, crtc %08x coordinate: x = %d, y = %d, widht = %d, height = %d, rotate = %08x\n",
*local_device_enabled, p_crtc->crtc_id, *x, *y, *width + 1, *height + 1, *rotation);
return VA_STATUS_SUCCESS;
} else {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: local device is not available\n");
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return VA_STATUS_ERROR_UNKNOWN;
}
}
VAStatus psb_xrandr_extend_crtc_coordinate(psb_output_device *extend_device_enabled, int *x, int *y, int *width, int *height, psb_xrandr_location *location, Rotation *rotation)
{
psb_xrandr_crtc_p p_crtc;
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
switch (psb_xrandr_info->output_device_mode) {
case MIPI0_MIPI1:
*extend_device_enabled = MIPI1;
p_crtc = psb_xrandr_info->local_crtc[1];
break;
case MIPI0_HDMI:
case MIPI0_MIPI1_HDMI:
case MIPI1_HDMI:
*extend_device_enabled = HDMI;
p_crtc = psb_xrandr_info->extend_crtc;
break;
default:
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: Unknown status, may be extend device is not available\n");
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return VA_STATUS_ERROR_UNKNOWN;
break;
}
if (p_crtc) {
*x = p_crtc->x;
*y = p_crtc->y;
*width = p_crtc->width;
*height = p_crtc->height;
*location = p_crtc->location;
*rotation = p_crtc->rotation;
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: extend device %08x enabled, crtc %08x coordinate: x = %d, y = %d, widht = %d, height = %d, location = %s, rotation = %08x\n",
*extend_device_enabled, p_crtc->crtc_id, *x, *y, *width + 1, *height + 1, location2string(p_crtc->location), *rotation);
} else {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: extend device is not available\n");
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
return VA_STATUS_ERROR_UNKNOWN;
}
return VA_STATUS_SUCCESS;
}
VAStatus psb_xrandr_thread_exit()
{
int ret;
XSelectInput(psb_xrandr_info->dpy, psb_xrandr_info->root, StructureNotifyMask);
XClientMessageEvent xevent;
xevent.type = ClientMessage;
xevent.message_type = psb_xrandr_info->psb_exit_atom;
xevent.window = psb_xrandr_info->root;
xevent.format = 32;
ret = XSendEvent(psb_xrandr_info->dpy, psb_xrandr_info->root, 0, StructureNotifyMask, (XEvent*) & xevent);
XFlush(psb_xrandr_info->dpy);
if (!ret) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: send thread exit event to drawable: failed\n");
return VA_STATUS_ERROR_UNKNOWN;
} else {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: send thread exit event to drawable: success\n");
return VA_STATUS_SUCCESS;
}
}
VAStatus psb_xrandr_thread_create(VADriverContextP ctx)
{
pthread_t id;
INIT_DRIVER_DATA;
psb_xrandr_info->psb_exit_atom = XInternAtom(psb_xrandr_info->dpy, "psb_exit_atom", 0);
pthread_create(&id, NULL, (void*)psb_xrandr_thread, ctx);
driver_data->xrandr_thread_id = id;
return VA_STATUS_SUCCESS;
}
VAStatus psb_xrandr_deinit()
{
#ifdef _FOR_FPGA_
return VA_STATUS_SUCCESS;
#endif
pthread_mutex_lock(&psb_xrandr_info->psb_extvideo_mutex);
//free crtc
if (psb_xrandr_info->crtc_head) {
while (psb_xrandr_info->crtc_head) {
psb_xrandr_info->crtc_tail = psb_xrandr_info->crtc_head->next;
free(psb_xrandr_info->crtc_head);
psb_xrandr_info->crtc_head = psb_xrandr_info->crtc_tail;
}
psb_xrandr_info->crtc_head = psb_xrandr_info->crtc_tail = NULL;
}
//free output
if (psb_xrandr_info->output_head) {
while (psb_xrandr_info->output_head) {
psb_xrandr_info->output_tail = psb_xrandr_info->output_head->next;
free(psb_xrandr_info->output_head);
psb_xrandr_info->output_head = psb_xrandr_info->output_tail;
}
psb_xrandr_info->output_head = psb_xrandr_info->output_tail = NULL;
}
if (psb_xrandr_info->hdmi_extvideo_prop) {
free(psb_xrandr_info->hdmi_extvideo_prop);
}
pthread_mutex_unlock(&psb_xrandr_info->psb_extvideo_mutex);
pthread_mutex_destroy(&psb_xrandr_info->psb_extvideo_mutex);
free(psb_xrandr_info);
return VA_STATUS_SUCCESS;
}
VAStatus psb_xrandr_init(VADriverContextP ctx)
{
int major, minor;
int screen;
psb_xrandr_info = (psb_xrandr_info_p)calloc(1, sizeof(psb_xrandr_info_s));
if (!psb_xrandr_info) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "output of memory\n");
return VA_STATUS_ERROR_UNKNOWN;
}
memset(psb_xrandr_info, 0, sizeof(psb_xrandr_info_s));
psb_xrandr_info->mipi0_rotation = RR_Rotate_0;
psb_xrandr_info->mipi1_rotation = RR_Rotate_0;
psb_xrandr_info->hdmi_rotation = RR_Rotate_0;
psb_xrandr_info->hdmi_extvideo_prop = (psb_extvideo_prop_p)calloc(1, sizeof(psb_extvideo_prop_s));
if (!psb_xrandr_info->hdmi_extvideo_prop) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "output of memory\n");
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
memset(psb_xrandr_info->hdmi_extvideo_prop, 0, sizeof(psb_extvideo_prop_s));
psb_xrandr_info->dpy = (Display *)ctx->native_dpy;
screen = DefaultScreen(psb_xrandr_info->dpy);
if (screen >= ScreenCount(psb_xrandr_info->dpy)) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: Invalid screen number %d (display has %d)\n",
screen, ScreenCount(psb_xrandr_info->dpy));
return VA_STATUS_ERROR_UNKNOWN;
}
psb_xrandr_info->root = RootWindow(psb_xrandr_info->dpy, screen);
if (!XRRQueryVersion(psb_xrandr_info->dpy, &major, &minor)) {
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: RandR extension missing\n");
return VA_STATUS_ERROR_UNKNOWN;
}
psb_xrandr_info->res = XRRGetScreenResources(psb_xrandr_info->dpy, psb_xrandr_info->root);
if (!psb_xrandr_info->res)
drv_debug_msg(VIDEO_DEBUG_ERROR, "Xrandr: failed to get screen resources\n");
pthread_mutex_init(&psb_xrandr_info->psb_extvideo_mutex, NULL);
psb_xrandr_refresh(ctx);
return VA_STATUS_SUCCESS;
}