int video_canvas_set_palette(video_canvas_t *c, struct palette_s *palette)
{
#ifdef HAVE_XVIDEO
/* Apply color settings to XVideo. */
if (c->videoconfig->hwscale && c->xv_image) {
int i;
Display *dpy = x11ui_get_display_ptr();
for (i = 0; i < (int)(sizeof(xv_settings) / sizeof(xv_settings[0])); i++) {
/* Map from VICE [0,2000] to XVideo [xv_min, xv_max]. */
int v_min = 0, v_max = 2000;
int v_zero = (v_min + v_max) / 2;
int v_range = v_max - v_min;
int xv_zero = (xv_settings[i].min + xv_settings[i].max) / 2;
int xv_range = xv_settings[i].max - xv_settings[i].min;
int xv_val = (*xv_settings[i].value - v_zero) * xv_range / v_range + xv_zero;
if (!xv_settings[i].atom) {
continue;
}
XvSetPortAttribute(dpy, c->xv_port, xv_settings[i].atom, xv_val);
}
}
#endif
c->palette = palette;
return uicolor_set_palette(c, palette);
}
/*****************************************************************************
* XVideoSetAttribute
*****************************************************************************
* This function can be used to set attributes, e.g. XV_BRIGHTNESS and
* XV_CONTRAST. "f_value" should be in the range of 0 to 1.
*****************************************************************************/
static void XVideoSetAttribute( vout_thread_t *p_vout,
char *attr_name, float f_value )
{
int i_attrib;
XvAttribute *p_attrib;
Display *p_display = p_vout->p_sys->p_display;
int i_xvport = p_vout->p_sys->i_xvport;
p_attrib = XvQueryPortAttributes( p_display, i_xvport, &i_attrib );
do
{
i_attrib--;
if( i_attrib >= 0 && !strcmp( p_attrib[ i_attrib ].name, attr_name ) )
{
int i_sv = f_value * ( p_attrib[ i_attrib ].max_value
- p_attrib[ i_attrib ].min_value + 1 )
+ p_attrib[ i_attrib ].min_value;
XvSetPortAttribute( p_display, i_xvport,
XInternAtom( p_display, attr_name, False ), i_sv );
break;
}
} while( i_attrib > 0 );
if( p_attrib )
XFree( p_attrib );
}
static int get_colourkey( void )
{
Atom atom;
XvAttribute *attr;
int value;
int nattr;
attr = XvQueryPortAttributes( display, xv_port, &nattr );
if( attr ) {
if( nattr ) {
int k;
for( k = 0; k < nattr; k++ ) {
if( (attr[ k ].flags & XvSettable) && (attr[ k ].flags & XvGettable)) {
if( !strcmp( attr[ k ].name, "XV_COLORKEY" ) ) {
atom = XInternAtom( display, "XV_COLORKEY", False );
if( atom != None ) {
XvGetPortAttribute( display, xv_port, atom, &value );
XvSetPortAttribute( display, xv_port, atom, value );
XvGetPortAttribute( display, xv_port, atom, &value );
XFree( attr );
return value;
}
}
}
}
}
XFree( attr );
}
return 0;
}
// Try to enable vsync for xv.
// Returns -1 if not available, 0 on failure and 1 on success.
static int xv_enable_vsync(struct vo *vo)
{
struct xvctx *ctx = vo->priv;
Atom xv_atom = xv_intern_atom_if_exists(vo, "XV_SYNC_TO_VBLANK");
if (xv_atom == None)
return -1;
return XvSetPortAttribute(vo->x11->display, ctx->xv_port, xv_atom, 1)
== Success;
}
void QX11VideoSurface::setAttribute(const char *attribute, int value, int minimum, int maximum)
{
if (m_portId != 0) {
Display *display = QX11Info::display();
Atom atom = XInternAtom(display, attribute, True);
XvSetPortAttribute(
display, m_portId, atom, redistribute(value, -100, 100, minimum, maximum));
}
}
static int xv_set_eq(struct vo *vo, uint32_t xv_port, const char *name,
int value)
{
MP_VERBOSE(vo, "xv_set_eq called! (%s, %d)\n", name, value);
int min, max;
int atom = xv_find_atom(vo, xv_port, name, false, &min, &max);
if (atom != None) {
// -100 -> min
// 0 -> (max+min)/2
// +100 -> max
int port_value = (value + 100) * (max - min) / 200 + min;
XvSetPortAttribute(vo->x11->display, xv_port, atom, port_value);
return VO_TRUE;
}
return VO_FALSE;
}
bool
XVWindow::InitColorkey()
{
if( XV_COLORKEY != None ) {
if ( XvGetPortAttribute(_display,_XVPort, XV_COLORKEY, &_colorKey) == Success )
PTRACE(4, "XVideo\tUsing colorkey " << _colorKey );
else {
PTRACE(1, "XVideo\tCould not get colorkey! Maybe the selected Xv port has no overlay." );
return false;
}
if ( XV_AUTOPAINT_COLORKEY != None ) {
if ( XvSetPortAttribute( _display, _XVPort, XV_AUTOPAINT_COLORKEY, 1 ) == Success )
PTRACE(4, "XVideo\tColorkey method: AUTOPAINT");
else {
_paintColorKey = true;
PTRACE(4, "XVideo\tFailed to set XV_AUTOPAINT_COLORKEY");
PTRACE(4, "XVideo\tColorkey method: MANUAL");
}
}
else {
_paintColorKey = true;
PTRACE(4, "XVideo\tXV_AUTOPAINT_COLORKEY not supported");
PTRACE(4, "XVideo\tColorkey method: MANUAL");
}
}
else {
PTRACE(4, "XVideo\tColorkey method: NONE");
}
return true;
}
//------------------------------------
//
//------------------------------------
uint8_t GUI_XvInit(GUI_WindowInfo * window, uint32_t w, uint32_t h)
{
unsigned int ver, rel, req, ev, err;
unsigned int port, adaptors;
static XvAdaptorInfo *ai;
static XvAdaptorInfo *curai;
#if 0
win = gtk_widget_get_parent_window(window);
xv_display = GDK_WINDOW_XDISPLAY(win);
// xv_win= RootWindow(xv_display,0);
xv_win = GDK_WINDOW_XWINDOW(GTK_WIDGET(window)->window);
#endif
xv_display=(Display *)window->display;
xv_win=window->window;
#define WDN xv_display
xv_port = 0;
if (Success != XvQueryExtension(WDN, &ver, &rel, &req, &ev, &err))
{
printf("\n Query Extension failed\n");
goto failed;
}
/* check for Xvideo support */
if (Success != XvQueryAdaptors(WDN,
DefaultRootWindow(WDN), &adaptors, &ai))
{
printf("\n Query Adaptor failed\n");
goto failed;
}
curai = ai;
XvFormat *formats;
// Dump infos
port = 0;
for (uint16_t i = 0; (!port) && (i < adaptors); i++)
{
/*
XvPortID base_id;
unsigned long num_ports;
char type;
char *name;
unsigned long num_formats;
XvFormat *formats;
unsigned long num_adaptors;
*/
#ifdef VERBOSE_XV
printf("\n_______________________________\n");
printf("\n Adaptor : %d", i);
printf("\n Base ID : %ld", curai->base_id);
printf("\n Nb Port : %lu", curai->num_ports);
printf("\n Type : %d,",
curai->type);
#define CHECK(x) if(curai->type & x) printf("|"#x);
CHECK(XvInputMask);
CHECK(XvOutputMask);
CHECK(XvVideoMask);
CHECK(XvStillMask);
CHECK(XvImageMask);
printf("\n Name : %s",
curai->name);
printf("\n Num Adap : %lu", curai->num_adaptors);
printf("\n Num fmt : %lu", curai->num_formats);
#endif
formats = curai->formats;
//
uint16_t k;
for (k = 0; (k < curai->num_ports) && !port; k++)
{
if (GUI_XvList(WDN, k + curai->base_id, &xv_format))
port = k + curai->base_id;
}
curai++;
}
//
if (!port)
{
printf("\n no port found");
goto failed;
}
#ifdef COLORSPACE_YV12
printf("\n Xv YV12 found at port :%d, format : %ld", port, xv_format);
#else
printf("\n Xv YUY2 found at port :%d, format : %ld", port, xv_format);
#endif
if (Success != XvGrabPort(WDN, port, 0))
goto failed;
{
xv_port = port;
/*
Display *display,
XvPortID port,
int id,
char* data,
int width,
int height,
XShmSegmentInfo *shminfo
*/
XSetWindowAttributes xswa;
XWindowAttributes attribs;
static Atom xv_atom;
unsigned long xswamask;
int erCode;
/* check if colorkeying is needed */
xv_atom = getAtom( "XV_AUTOPAINT_COLORKEY" );
if(xv_atom!=None)
{
XvSetPortAttribute( xv_display, xv_port, xv_atom, 1 );
}
else printf("No autopaint \n");
/* if we have to deal with colorkeying ... */
xvimage = XvShmCreateImage(WDN, xv_port,
xv_format, 0, w, h, &Shminfo);
Shminfo.shmid = shmget(IPC_PRIVATE, xvimage->data_size,
IPC_CREAT | 0777);
if(Shminfo.shmid<=0)
{
printf("shmget failed\n");
}
Shminfo.shmaddr = (char *) shmat(Shminfo.shmid, 0, 0);
Shminfo.readOnly = False;
if(Shminfo.shmaddr==(char *)-1)
{
printf("Shmat failed\n");
}
xvimage->data = Shminfo.shmaddr;
XShmAttach(WDN, &Shminfo);
XSync(WDN, False);
erCode=shmctl(Shminfo.shmid, IPC_RMID, 0);
if(erCode)
{
printf("Shmctl failed :%d\n",erCode);
}
memset(xvimage->data, 0, xvimage->data_size);
xv_xgc.graphics_exposures = False;
xv_gc = XCreateGC(xv_display, xv_win, 0L, &xv_xgc);
//ADM_assert(BadWindow!=XSelectInput(xv_display, xv_win, ExposureMask | VisibilityChangeMask));
}
printf("\n Xv init succeedeed\n");
return 1;
failed:
printf("\n Xv init failed..\n");
return 0;
}
int
xf_video_init(xfInfo * xfi)
{
unsigned int version;
unsigned int release;
unsigned int request_base;
unsigned int event_base;
unsigned int error_base;
unsigned int num_adaptors;
unsigned int i;
int ret;
XvAdaptorInfo * ai;
XvAttribute * attr;
XvImageFormatValues * fo;
xfi->xv_colorkey_atom = None;
xfi->xv_image_size = 0;
if (!XShmQueryExtension(xfi->display))
{
printf("xf_video_init: no shmem available.\n");
return 1;
}
ret = XvQueryExtension(xfi->display, &version, &release, &request_base, &event_base, &error_base);
if (ret != Success)
{
printf("xf_video_init: XvQueryExtension failed %d.\n", ret);
return 1;
}
printf("xf_video_init:");
printf(" version %u", version);
printf(" release %u", release);
printf("\n");
ret = XvQueryAdaptors(xfi->display, DefaultRootWindow(xfi->display),
&num_adaptors, &ai);
if (ret != Success)
{
printf("xf_video_init: XvQueryAdaptors failed %d.\n", ret);
return 1;
}
for (i = 0; i < num_adaptors; i++)
{
printf("xf_video_init: adapter port %ld-%ld (%s)\n", ai[i].base_id,
ai[i].base_id + ai[i].num_ports - 1, ai[i].name);
if (xfi->xv_port == -1 && i == num_adaptors - 1)
xfi->xv_port = ai[i].base_id;
}
if (num_adaptors > 0)
XvFreeAdaptorInfo(ai);
if (xfi->xv_port == -1)
{
printf("xf_video_init: no adapter selected, video frames will not be processed.\n");
return 1;
}
printf("xf_video_init: selected %ld\n", xfi->xv_port);
attr = XvQueryPortAttributes(xfi->display, xfi->xv_port, &ret);
for (i = 0; i < (unsigned int)ret; i++)
{
if (strcmp(attr[i].name, "XV_COLORKEY") == 0)
{
xfi->xv_colorkey_atom = XInternAtom(xfi->display, "XV_COLORKEY", False);
XvSetPortAttribute(xfi->display, xfi->xv_port, xfi->xv_colorkey_atom, attr[i].min_value + 1);
break;
}
}
XFree(attr);
printf("xf_video_init: pixel format ");
fo = XvListImageFormats(xfi->display, xfi->xv_port, &ret);
if (ret > 0)
{
xfi->xv_pixfmts = (uint32 *) malloc((ret + 1) * sizeof(uint32));
for (i = 0; i < ret; i++)
{
xfi->xv_pixfmts[i] = fo[i].id;
printf("%c%c%c%c ", ((char*)(xfi->xv_pixfmts + i))[0], ((char*)(xfi->xv_pixfmts + i))[1],
((char*)(xfi->xv_pixfmts + i))[2], ((char*)(xfi->xv_pixfmts + i))[3]);
}
xfi->xv_pixfmts[i] = 0;
}
printf("\n");
return 0;
}
int
S9xXVDisplayDriver::init (void)
{
int padding;
int depth = 0, num_formats, num_attrs, highest_formats = 0;
XvImageFormatValues *formats = NULL;
XvAdaptorInfo *adaptors;
XvAttribute *port_attr;
VisualID visualid = None;
unsigned int num_adaptors;
GdkScreen *screen;
GdkWindow *root;
buffer[0] = malloc (image_padded_size);
buffer[1] = malloc (scaled_padded_size);
padding = (image_padded_size - image_size) / 2;
padded_buffer[0] = (void *) (((uint8 *) buffer[0]) + padding);
padding = (scaled_padded_size - scaled_size) / 2;
padded_buffer[1] = (void *) (((uint8 *) buffer[1]) + padding);
memset (buffer[0], 0, image_padded_size);
memset (buffer[1], 0, scaled_padded_size);
/* Setup XV */
gtk_widget_realize (drawing_area);
display = gdk_x11_drawable_get_xdisplay (GDK_DRAWABLE (gtk_widget_get_window (drawing_area)));
screen = gtk_widget_get_screen (drawing_area);
root = gdk_screen_get_root_window (screen);
xv_portid = -1;
XvQueryAdaptors (display,
GDK_WINDOW_XWINDOW (root),
&num_adaptors,
&adaptors);
for (int i = 0; i < (int) num_adaptors; i++)
{
if (adaptors[i].type & XvInputMask &&
adaptors[i].type & XvImageMask)
{
formats = XvListImageFormats (display,
adaptors[i].base_id,
&num_formats);
if (num_formats > highest_formats)
{
xv_portid = adaptors[i].base_id;
highest_formats = num_formats;
visualid = adaptors[i].formats->visual_id;
}
free (formats);
}
}
XvFreeAdaptorInfo (adaptors);
if (xv_portid < 0)
{
fprintf (stderr, "Could not open Xv output port.\n");
return -1;
}
/* Set XV_AUTOPAINT_COLORKEY _only_ if available */
port_attr = XvQueryPortAttributes (display, xv_portid, &num_attrs);
for (int i = 0; i < num_attrs; i++)
{
if (!strcmp (port_attr[i].name, "XV_AUTOPAINT_COLORKEY"))
{
Atom colorkey = None;
colorkey = XInternAtom (display, "XV_AUTOPAINT_COLORKEY", True);
if (colorkey != None)
XvSetPortAttribute (display, xv_portid, colorkey, 1);
}
}
/* Try to find an RGB format */
format = FOURCC_YUY2;
bpp = 100;
formats = XvListImageFormats (display,
xv_portid,
&num_formats);
for (int i = 0; i < num_formats; i++)
{
if (formats[i].id == 0x3 || formats[i].type == XvRGB)
{
if (formats[i].bits_per_pixel < bpp)
{
format = formats[i].id;
bpp = formats[i].bits_per_pixel;
bytes_per_pixel = (bpp == 15) ? 2 : bpp >> 3;
depth = formats[i].depth;
this->rshift = get_inv_shift (formats[i].red_mask, bpp);
this->gshift = get_inv_shift (formats[i].green_mask, bpp);
this->bshift = get_inv_shift (formats[i].blue_mask, bpp);
/* Check for red-blue inversion on SiliconMotion drivers */
if (formats[i].red_mask == 0x001f &&
formats[i].blue_mask == 0x7c00)
{
int copy = this->rshift;
this->rshift = this->bshift;
this->bshift = copy;
}
/* on big-endian Xv still seems to like LSB order */
if (config->force_inverted_byte_order)
S9xSetEndianess (ENDIAN_MSB);
else
S9xSetEndianess (ENDIAN_LSB);
}
}
}
void XvGrabber::setattr(Atom attr, int value)
{
Display* dpy = Tk_Display(Tcl::instance().tkmain());
XvSetPortAttribute(dpy, grabID_, attr, value);
}
int svlWindowManagerX11::DoModal(bool show, bool fullscreen)
{
Destroy();
DestroyFlag = false;
unsigned int i, atom_count;
int x, y, prevright, prevbottom;
unsigned int lastimage = 0;
unsigned long black, white;
XSizeHints wsh;
#if CISST_SVL_HAS_XV
Atom atoms[3];
unsigned int xvadaptorcount;
XvAdaptorInfo *xvai;
XVisualInfo xvvinfo;
bool xvupdateimage = true;
#else // CISST_SVL_HAS_XV
Atom atoms[2];
#endif // CISST_SVL_HAS_XV
// setting decoration hints for borderless mode
struct {
unsigned long flags;
unsigned long functions;
unsigned long decorations;
signed long input_mode;
unsigned long status;
} mwm;
mwm.flags = MWM_HINTS_DECORATIONS;
mwm.decorations = 0;
mwm.functions = 0;
mwm.input_mode = 0;
mwm.status = 0;
// resetting DestroyedSignal event
if (DestroyedSignal) delete(DestroyedSignal);
DestroyedSignal = new osaThreadSignal();
if (DestroyedSignal == 0) goto labError;
// initialize display and pick default screen
xDisplay = XOpenDisplay(reinterpret_cast<char*>(0));
xScreen = DefaultScreen(xDisplay);
#if CISST_SVL_HAS_XV
// check if 24bpp is suppoted by the display
if (XMatchVisualInfo(xDisplay, xScreen, 24, TrueColor, &xvvinfo) == 0) goto labError;
#endif // CISST_SVL_HAS_XV
// pick colors
black = BlackPixel(xDisplay, xScreen);
white = WhitePixel(xDisplay, xScreen);
// create windows
xWindows = new Window[NumOfWins];
memset(xWindows, 0, NumOfWins * sizeof(Window));
xGCs = new GC[NumOfWins];
memset(xGCs, 0, NumOfWins * sizeof(GC));
// create atoms for overriding default window behaviours
atoms[0] = XInternAtom(xDisplay, "WM_DELETE_WINDOW", False);
atoms[1] = XInternAtom(xDisplay, "_MOTIF_WM_HINTS", False);
#if CISST_SVL_HAS_XV
atoms[2] = XInternAtom(xDisplay, "XV_SYNC_TO_VBLANK", False);
#endif // CISST_SVL_HAS_XV
// create title strings
Titles = new std::string[NumOfWins];
CustomTitles = new std::string[NumOfWins];
CustomTitleEnabled = new int[NumOfWins];
#if CISST_SVL_HAS_XV
xvImg = new XvImage*[NumOfWins];
xvShmInfo = new XShmSegmentInfo[NumOfWins];
xvPort = new XvPortID[NumOfWins];
if (xvImg == 0 || xvShmInfo == 0 || xvPort == 0) goto labError;
memset(xvImg, 0, NumOfWins * sizeof(XvImage*));
memset(xvShmInfo, 0, NumOfWins * sizeof(XShmSegmentInfo));
memset(xvPort, 0, NumOfWins * sizeof(XvPortID));
#else // CISST_SVL_HAS_XV
// create images
xImageBuffers = new unsigned char*[NumOfWins];
for (i = 0; i < NumOfWins; i ++) {
xImageBuffers[i] = new unsigned char[Width[i] * Height[i] * 4];
}
xImg = new XImage*[NumOfWins];
memset(xImg, 0, NumOfWins * sizeof(XImage*));
if (xImg == 0) goto labError;
for (i = 0; i < NumOfWins; i ++) {
xImg[i] = XCreateImage(xDisplay,
DefaultVisual(xDisplay, xScreen),
24,
ZPixmap,
0,
reinterpret_cast<char*>(xImageBuffers[i]),
Width[i],
Height[i],
32,
0);
}
#endif // CISST_SVL_HAS_XV
prevright = prevbottom = 0;
for (i = 0; i < NumOfWins; i ++) {
if (PosX == 0 || PosY == 0) {
if (fullscreen) {
x = prevright;
y = 0;
prevright += Width[i];
}
else {
x = prevright;
y = prevbottom;
prevright += 50;
prevbottom += 50;
}
}
else {
x = PosX[i];
y = PosY[i];
}
xWindows[i] = XCreateSimpleWindow(xDisplay, DefaultRootWindow(xDisplay),
x,
y,
Width[i],
Height[i],
0,
black,
white);
if (xWindows[i] == 0) goto labError;
// overriding default behaviours:
// - borderless mode
// - closing window
if (fullscreen) {
XChangeProperty(xDisplay, xWindows[i],
atoms[1], atoms[1], 32,
PropModeReplace, reinterpret_cast<unsigned char*>(&mwm), 5);
atom_count = 2;
}
else {
atom_count = 1;
}
XSetWMProtocols(xDisplay, xWindows[i], atoms, atom_count);
wsh.flags = PPosition|PSize;
wsh.x = x;
wsh.y = y;
wsh.width = Width[i];
wsh.height = Height[i];
XSetNormalHints(xDisplay, xWindows[i], &wsh);
// set window title
CustomTitleEnabled[i] = 0;
std::ostringstream ostring;
if (Title.length() > 0) {
if (NumOfWins > 0) ostring << Title << " #" << i;
else ostring << Title;
}
else {
if (NumOfWins > 0) ostring << Title << "svlImageWindow #" << i;
else ostring << "svlImageWindow";
}
Titles[i] = ostring.str();
XSetStandardProperties(xDisplay, xWindows[i],
Titles[i].c_str(), Titles[i].c_str(),
None, NULL, 0, NULL);
// set even mask
XSelectInput(xDisplay, xWindows[i], ExposureMask|PointerMotionMask|ButtonPressMask|KeyPressMask);
// set window colormap
XSetWindowColormap(xDisplay, xWindows[i], DefaultColormapOfScreen(DefaultScreenOfDisplay(xDisplay)));
#if CISST_SVL_HAS_XV
// query shared memory extension
if (!XShmQueryExtension(xDisplay)) goto labError;
// query video adaptors
if (XvQueryAdaptors(xDisplay, DefaultRootWindow(xDisplay), &xvadaptorcount, &xvai) != Success) goto labError;
xvPort[i] = xvai->base_id + i;
XvFreeAdaptorInfo(xvai);
// overriding default Xvideo vertical sync behavior
XvSetPortAttribute (xDisplay, xvPort[i], atoms[2], 1);
#endif // CISST_SVL_HAS_XV
// create graphics context
xGCs[i] = XCreateGC(xDisplay, xWindows[i], 0, 0);
// set default colors
XSetBackground(xDisplay, xGCs[i], white);
XSetForeground(xDisplay, xGCs[i], black);
#if CISST_SVL_HAS_XV
// create image in shared memory
xvImg[i] = XvShmCreateImage(xDisplay, xvPort[i], 0x32595559/*YUV2*/, 0, Width[i], Height[i], &(xvShmInfo[i]));
if (xvImg[i]->width < static_cast<int>(Width[i]) || xvImg[i]->height < static_cast<int>(Height[i])) {
CMN_LOG_INIT_ERROR << "DoModal - image too large for XV to display (requested="
<< Width[i] << "x" << Height[i] << "; allowed="
<< xvImg[i]->width << "x" << xvImg[i]->height << ")" << std::endl;
goto labError;
}
xvShmInfo[i].shmid = shmget(IPC_PRIVATE, xvImg[i]->data_size, IPC_CREAT | 0777);
xvShmInfo[i].shmaddr = xvImg[i]->data = reinterpret_cast<char*>(shmat(xvShmInfo[i].shmid, 0, 0));
xvShmInfo[i].readOnly = False;
if (!XShmAttach(xDisplay, &(xvShmInfo[i]))) goto labError;
#endif // CISST_SVL_HAS_XV
// clear window
XClearWindow(xDisplay, xWindows[i]);
// show window if requested
if (show) XMapRaised(xDisplay, xWindows[i]);
}
// signal that initialization is done
if (InitReadySignal) InitReadySignal->Raise();
// main message loop
XEvent event;
KeySym code;
unsigned int winid;
while (1) {
osaSleep(0.001);
#if CISST_SVL_HAS_XV
if (!xvupdateimage) {
for (int events = XPending(xDisplay); events > 0; events --) {
#else // CISST_SVL_HAS_XV
if (XPending(xDisplay)) {
#endif // CISST_SVL_HAS_XV
XNextEvent(xDisplay, &event);
// find recipient
for (winid = 0; winid < NumOfWins; winid ++) {
if (event.xany.window == xWindows[winid]) break;
}
if (winid == NumOfWins) continue;
// override default window behaviour
if (event.type == ClientMessage) {
if (static_cast<unsigned long>(event.xclient.data.l[0]) == atoms[0]) {
// X11 server wants to close window
// Do nothing.... we will destroy it ourselves later
}
continue;
}
// window should be closed
if (event.type == UnmapNotify) {
printf("destroy\n");
if (xGCs[winid]) {
XFreeGC(xDisplay, xGCs[winid]);
xGCs[winid] = 0;
}
xWindows[winid] = 0;
continue;
}
// window should be updated
if (event.type == Expose && event.xexpose.count == 0) {
XClearWindow(xDisplay, xWindows[winid]);
continue;
}
if (event.type == KeyPress) {
code = XLookupKeysym(&event.xkey, 0);
if (code >= 48 && code <= 57) { // ascii numbers
OnUserEvent(winid, true, code);
continue;
}
if (code >= 97 && code <= 122) { // ascii letters
OnUserEvent(winid, true, code);
continue;
}
if (code == 13 ||
code == 32) { // special characters with correct ascii code
OnUserEvent(winid, true, code);
continue;
}
if (code >= 0xffbe && code <= 0xffc9) { // F1-F12
OnUserEvent(winid, false, winInput_KEY_F1 + (code - 0xffbe));
continue;
}
switch (code) {
case 0xFF55:
OnUserEvent(winid, false, winInput_KEY_PAGEUP);
break;
case 0xFF56:
OnUserEvent(winid, false, winInput_KEY_PAGEDOWN);
break;
case 0xFF50:
OnUserEvent(winid, false, winInput_KEY_HOME);
break;
case 0xFF57:
OnUserEvent(winid, false, winInput_KEY_END);
break;
case 0xFF63:
OnUserEvent(winid, false, winInput_KEY_INSERT);
break;
case 0xFFFF:
OnUserEvent(winid, false, winInput_KEY_DELETE);
break;
case 0xFF51:
OnUserEvent(winid, false, winInput_KEY_LEFT);
break;
case 0xFF53:
OnUserEvent(winid, false, winInput_KEY_RIGHT);
break;
case 0xFF52:
OnUserEvent(winid, false, winInput_KEY_UP);
break;
case 0xFF54:
OnUserEvent(winid, false, winInput_KEY_DOWN);
break;
}
continue;
}
if (event.type == ButtonPress) {
if (event.xbutton.button == Button1) {
if (!LButtonDown && !RButtonDown) {
LButtonDown = true;
XGrabPointer(xDisplay, xWindows[winid], false,
PointerMotionMask|ButtonReleaseMask,
GrabModeAsync, GrabModeAsync,
None,
None,
CurrentTime);
}
OnUserEvent(winid, false, winInput_LBUTTONDOWN);
}
else if (event.xbutton.button == Button3) {
if (!LButtonDown && !RButtonDown) {
RButtonDown = true;
XGrabPointer(xDisplay, xWindows[winid], false,
PointerMotionMask|ButtonReleaseMask,
GrabModeAsync, GrabModeAsync,
None,
None,
CurrentTime);
}
OnUserEvent(winid, false, winInput_RBUTTONDOWN);
}
}
if (event.type == ButtonRelease) {
if (event.xbutton.button == Button1) {
OnUserEvent(winid, false, winInput_LBUTTONUP);
if (LButtonDown && !RButtonDown) {
LButtonDown = false;
XUngrabPointer(xDisplay, CurrentTime);
}
}
else if (event.xbutton.button == Button3) {
OnUserEvent(winid, false, winInput_RBUTTONUP);
if (!LButtonDown && RButtonDown) {
RButtonDown = false;
XUngrabPointer(xDisplay, CurrentTime);
}
}
}
if (event.type == MotionNotify) {
SetMousePos(static_cast<short>(event.xmotion.x), static_cast<short>(event.xmotion.y));
OnUserEvent(winid, false, winInput_MOUSEMOVE);
}
#if CISST_SVL_HAS_XV
// image update complete
if (event.type == XShmGetEventBase(xDisplay) + ShmCompletion) {
xvupdateimage = true;
continue;
}
}
if (!xvupdateimage) signalImage.Wait(0.01);
#endif // CISST_SVL_HAS_XV
}
else {
if (DestroyFlag) break;
if (ImageCounter > lastimage) {
csImage.Enter();
lastimage = ImageCounter;
#if CISST_SVL_HAS_XV
for (i = 0; i < NumOfWins; i ++) {
XvShmPutImage(xDisplay,
xvPort[i],
xWindows[i],
xGCs[i],
xvImg[i],
0, 0, Width[i], Height[i],
0, 0, Width[i], Height[i], True);
}
xvupdateimage = false;
#else // CISST_SVL_HAS_XV
for (i = 0; i < NumOfWins; i ++) {
xImg[i]->data = reinterpret_cast<char*>(xImageBuffers[i]);
XPutImage(xDisplay,
xWindows[i],
xGCs[i],
xImg[i],
0, 0, 0, 0,
Width[i], Height[i]);
}
#endif // CISST_SVL_HAS_XV
/*
for (i = 0; i < NumOfWins; i ++) {
if (CustomTitleEnabled[i] < 0) {
// Restore original timestamp
XSetStandardProperties(xDisplay, xWindows[i],
Titles[i].c_str(), Titles[i].c_str(),
None, NULL, 0, NULL);
}
else if (CustomTitleEnabled[i] > 0) {
// Set custom timestamp
XSetStandardProperties(xDisplay, xWindows[i],
CustomTitles[i].c_str(), CustomTitles[i].c_str(),
None, NULL, 0, NULL);
}
}
*/
csImage.Leave();
}
}
}
labError:
#if CISST_SVL_HAS_XV
if (xvShmInfo) {
for (i = 0; i < NumOfWins; i ++) {
XShmDetach(xDisplay, &(xvShmInfo[i]));
shmdt(xvShmInfo[i].shmaddr);
}
delete [] xvShmInfo;
xvShmInfo = 0;
}
#endif // CISST_SVL_HAS_XV
XSync(xDisplay, 0);
for (i = 0; i < NumOfWins; i ++) {
if (xGCs[i]) XFreeGC(xDisplay, xGCs[i]);
if (xWindows[i]) XDestroyWindow(xDisplay, xWindows[i]);
}
XCloseDisplay(xDisplay);
#if CISST_SVL_HAS_XV
if (xvImg) {
for (i = 0; i < NumOfWins; i ++) {
if (xvImg[i]) XFree(xvImg[i]);
}
delete [] xvImg;
xvImg = 0;
}
if (xvPort) {
delete [] xvPort;
xvPort = 0;
}
#else // CISST_SVL_HAS_XV
if (xImg) {
for (i = 0; i < NumOfWins; i ++) {
if (xImg[i]) XDestroyImage(xImg[i]);
}
delete [] xImg;
xImg = 0;
}
if (xImageBuffers) {
delete [] xImageBuffers;
xImageBuffers = 0;
}
#endif // CISST_SVL_HAS_XV
if (xGCs) {
delete [] xGCs;
xGCs = 0;
}
if (xWindows) {
delete [] xWindows;
xWindows = 0;
}
if (Titles) {
delete [] Titles;
Titles = 0;
}
if (CustomTitles) {
delete [] CustomTitles;
CustomTitles = 0;
}
if (CustomTitleEnabled) {
delete [] CustomTitleEnabled;
CustomTitleEnabled = 0;
}
xScreen = 0;
xDisplay = 0;
if (DestroyedSignal) DestroyedSignal->Raise();
return 0;
}
int
XVWindow::Init (Display* dp,
Window rootWindow,
GC gc,
int x,
int y,
int windowWidth,
int windowHeight,
int imageWidth,
int imageHeight)
{
// local variables needed for creation of window
// and initialization of XV extension
unsigned int ver = 0;
unsigned int rel = 0;
unsigned int req = 0;
unsigned int ev = 0;
unsigned int err = 0;
int ret = 0;
unsigned int i = 0;
_display = dp;
_rootWindow = rootWindow;
_imageWidth = imageWidth;
_imageHeight = imageHeight;
PTRACE(4, "XVideo\tInitializing XV window with " << windowWidth << "x" << windowHeight << " at " << x << "," << y);
XLockDisplay (_display);
// check if SHM XV window is possible
ret = XvQueryExtension (_display, &ver, &rel, &req, &ev, &err);
PTRACE(4, "XVideo\tXvQueryExtension: Version: " << ver << " Release: " << rel
<< " Request Base: " << req << " Event Base: " << ev << " Error Base: " << err );
if (Success != ret) {
if (ret == XvBadExtension)
PTRACE(1, "XVideo\tXvQueryExtension failed - XvBadExtension");
else if (ret == XvBadAlloc)
PTRACE(1, "XVideo\tXvQueryExtension failed - XvBadAlloc");
else
PTRACE(1, "XVideo\tXQueryExtension failed");
XUnlockDisplay (_display);
return 0;
}
// Find XV port
_XVPort = FindXVPort ();
if (!_XVPort) {
PTRACE(1, "XVideo\tFindXVPort failed");
XUnlockDisplay(_display);
return 0;
}
PTRACE(4, "XVideo\tUsing XVideo port: " << _XVPort);
if (!CreateAtomsAndWindow(gc, x, y, windowWidth, windowHeight)) {
XUnlockDisplay(_display);
return 0;
}
XV_SYNC_TO_VBLANK = GetXVAtom("XV_SYNC_TO_VBLANK");
XV_COLORKEY = GetXVAtom( "XV_COLORKEY" );
XV_AUTOPAINT_COLORKEY = GetXVAtom( "XV_AUTOPAINT_COLORKEY" );
if ( !InitColorkey() )
{
PTRACE(1, "XVideo\tColorkey initialization failed");
XUnlockDisplay(_display);
return 0;
}
if (XV_SYNC_TO_VBLANK != None)
if (XvSetPortAttribute(_display, _XVPort, XV_SYNC_TO_VBLANK, 1) == Success)
PTRACE(4, "XVideo\tVertical sync successfully activated" );
else
PTRACE(4, "XVideo\tFailure when trying to activate vertical sync" );
else
PTRACE(4, "XVideo\tVertical sync not supported");
if (!checkMaxSize (imageWidth, imageHeight)) {
PTRACE(1, "XVideo\tCheck of image size failed");
XUnlockDisplay(_display);
return 0;
}
#ifdef HAVE_SHM
if (XShmQueryExtension (_display)) {
_useShm = true;
PTRACE(1, "XVideo\tXQueryShmExtension success");
}
else {
_useShm = false;
PTRACE(1, "XVideo\tXQueryShmExtension failed");
}
if (_useShm)
ShmAttach(imageWidth, imageHeight);
if (!_useShm) {
#endif
for (i = 0; i < NUM_BUFFERS; i++) {
_XVImage[i] = (XvImage *) XvCreateImage( _display, _XVPort, GUID_YV12_PLANAR, 0, imageWidth, imageHeight);
if (!_XVImage[i]) {
PTRACE(1, "XVideo\tUnable to create XVideo Image");
XUnlockDisplay (_display);
return 0;
}
_XVImage[i]->data = (char*) malloc(_XVImage[i]->data_size);
}
PTRACE(1, "XVideo\tNot using SHM extension");
#ifdef HAVE_SHM
}
else {
PTRACE(1, "XVideo\tUsing SHM extension");
}
#endif
XSync(_display, False);
_isInitialized = true;
XUnlockDisplay (_display);
// detect the window manager type
_wmType = GetWMType ();
CalculateSize (windowWidth, windowHeight, true);
return 1;
}
int xv_init( xv_handle_t handle, Display *dpy, __u32 fourcc, int width, int height, int bpp )
{
unsigned int version, release;
unsigned int request_base, event_base, error_base;
int i;
if( XvQueryExtension( dpy, &version, &release, &request_base, &event_base, &error_base ) != Success )
{
#ifdef DEBUG
fprintf( stderr, "XvQueryExtension failed\n" );
#endif
return -1;
}
if( XvQueryAdaptors( dpy, DefaultRootWindow( dpy ), &handle->num_adaptors, &handle->p_adaptor_info ) != Success )
{
#ifdef DEBUG
fprintf( stderr, "XvQueryAdaptors failed\n" );
#endif
return -1;
}
/* printf( "%d adaptors found\n", handle->num_adaptors ); */
if( handle->num_adaptors == 0 )
{
return -2;
}
for( i = 0; i < handle->num_adaptors; i++ )
{
/* int format; */
unsigned int num_encodings;
XvEncodingInfo *p_encoding_info;
int encoding;
XvAttribute *at;
unsigned int num_attributes;
int attribute;
XvImageFormatValues *xvimage_formats;
unsigned int num_xvimage_formats;
int format;
#ifdef DEBUG
printf( "Adaptor: %d\n", i );
printf( "Name: %s\n", handle->p_adaptor_info[i].name );
printf( "Ports: %lu\n", handle->p_adaptor_info[i].num_ports );
printf( "Formats: %lu\n", handle->p_adaptor_info[i].num_formats );
for( format = 0; format < handle->p_adaptor_info[i].num_formats; format++ )
{
printf( "+Format: %d\n", format );
printf( " +Depth: %d\n", handle->p_adaptor_info[i].formats[format].depth );
printf( " +VisualID: %lu\n", handle->p_adaptor_info[i].formats[format].visual_id );
}
if( XvQueryEncodings( dpy, handle->p_adaptor_info[i].base_id, &num_encodings, &p_encoding_info ) != Success )
{
fprintf( stderr, "XvQueryEncodings failed\n" );
}
printf( " +num_encodings: %d\n", num_encodings );
for( encoding = 0; encoding < num_encodings; encoding++ )
{
printf( " +Encoding: %d\n", encoding );
printf( " +Name: %s\n", p_encoding_info[encoding].name );
printf( " +Resolution: %lu x %lu\n",
p_encoding_info[encoding].width,
p_encoding_info[encoding].height );
}
#endif //DEBUG
at = XvQueryPortAttributes( dpy, handle->p_adaptor_info[i].base_id, &num_attributes );
#ifdef DEBUG
printf( "num_attributes: %d\n", num_attributes );
#endif
for( attribute = 0; attribute < num_attributes; attribute++ )
{
int val;
Atom atom;
if( !strcmp( at[attribute].name, "XV_COLORKEY" ) )
{
#ifdef DEBUG
printf( "attribute: %d\n", attribute );
printf( "name: %s\n", at[attribute].name );
#endif
atom = (Atom)XInternAtom( dpy, at[attribute].name, 0 );
#ifdef DEBUG
printf( "atom: %p\n", atom );
#endif
XvGetPortAttribute( dpy,
handle->p_adaptor_info[i].base_id,
atom,
&val );
#ifdef DEBUG
printf( "Attribute: %d\n", attribute );
printf( "Name: %s\n", at[attribute].name );
printf( "min: %x\n", at[attribute].min_value );
printf( "max: %x\n", at[attribute].max_value );
printf( "value: %x\n", val );
#endif
handle->atom_colorkey = XInternAtom( dpy, at[attribute].name, 0 );
}
if( !strcmp( at[attribute].name, "XV_BRIGHTNESS" ) )
{
handle->atom_brightness = XInternAtom( dpy, at[attribute].name, 0 );
handle->brightness_min = at[attribute].min_value;
handle->brightness_max = at[attribute].max_value;
}
if( !strcmp( at[attribute].name, "XV_HUE" ) )
{
handle->atom_hue = XInternAtom( dpy, at[attribute].name, 0 );
handle->hue_min = at[attribute].min_value;
handle->hue_max = at[attribute].max_value;
}
if( !strcmp( at[attribute].name, "XV_CONTRAST" ) )
{
handle->atom_contrast = XInternAtom( dpy, at[attribute].name, 0 );
handle->contrast_min = at[attribute].min_value;
handle->contrast_max = at[attribute].max_value;
}
if( !strcmp( at[attribute].name, "XV_DOUBLE_BUFFER" ) )
{
Atom _atom;
_atom = XInternAtom( dpy, at[attribute].name, 0 );
XvSetPortAttribute( dpy, handle->p_adaptor_info[i].base_id, _atom, 1 );
#ifdef DEBUG
printf( "Xv: DOUBLE_BUFFER available\n" );
#endif
}
}
xvimage_formats = XvListImageFormats( dpy, handle->p_adaptor_info[i].base_id, &num_xvimage_formats );
/* printf( "num_xvimage_formats: %d\n", num_xvimage_formats ); */
for( format = 0; format < num_xvimage_formats; format++ )
{
char imageName[5] = {0, 0, 0, 0, 0};
memcpy(imageName, &(xvimage_formats[format].id), 4);
#ifdef DEBUG
fprintf(stdout, " id: 0x%x", xvimage_formats[format].id);
#endif
if( isprint( imageName[0]) && isprint(imageName[1]) &&
isprint( imageName[2]) && isprint(imageName[3]))
{
#ifdef DEBUG
fprintf(stdout, " (%s)\n", imageName);
#endif
if( xvimage_formats[format].id == fourcc )
{
handle->xv_mode_id = fourcc;
break;
}
} else {
#ifdef DEBUG
fprintf(stdout, "\n");
#endif
}
}
if( handle->xv_mode_id != fourcc )
{
return -3;
}
if( XvGrabPort( dpy, handle->p_adaptor_info[i].base_id, CurrentTime ) != Success )
{
/* fprintf( stderr, "Failed to grab port!\n" ); */
return -1;
}
}
handle->use_shm = 1;
if( handle->use_shm )
{
memset( &handle->shminfo, 0, sizeof( XShmSegmentInfo ) );
handle->image = XvShmCreateImage( dpy,
handle->p_adaptor_info[0].base_id,
handle->xv_mode_id,
(char*)NULL,
width,
height,
&handle->shminfo );
if( handle->image )
{
handle->shminfo.shmid = shmget( IPC_PRIVATE, handle->image->data_size, IPC_CREAT | 0777 );
if( handle->shminfo.shmid == -1 )
{
/* fprintf( stderr, "shmget failed\n" ); */
return -1;
}
handle->shminfo.shmaddr = handle->image->data = shmat( handle->shminfo.shmid, 0, 0 );
shmctl(handle->shminfo.shmid, IPC_RMID, 0);
/* destroy when we terminate, now if shmat failed */
if( handle->shminfo.shmaddr == ( void * ) -1 )
{
/* fprintf( stderr, "shmat failed\n" ); */
return -1;
}
handle->shminfo.readOnly = False;
if( !XShmAttach( dpy, &handle->shminfo ) )
{
/* fprintf( stderr, "XShmAttach failed\n" ); */
shmdt( handle->shminfo.shmaddr );
XFree( handle->image );
return -1;
}
}
else
{
/* fprintf( stderr, "XvShmCreateImage failed\n" ); */
return -1;
}
}
else
{
char * data = (char*) malloc( width*height*(bpp/8));
handle->image = XvCreateImage( dpy, handle->p_adaptor_info[0].base_id, handle->xv_mode_id, data, width, height );
}
handle->display = dpy;
return 0;
}
void xf_tsmf_init(xfInfo* xfi, long xv_port)
{
int ret;
unsigned int i;
unsigned int version;
unsigned int release;
unsigned int event_base;
unsigned int error_base;
unsigned int request_base;
unsigned int num_adaptors;
xfXvContext* xv;
XvAdaptorInfo* ai;
XvAttribute* attr;
XvImageFormatValues* fo;
xv = (xfXvContext*) malloc(sizeof(xfXvContext));
ZeroMemory(xv, sizeof(xfXvContext));
xfi->xv_context = xv;
xv->xv_colorkey_atom = None;
xv->xv_image_size = 0;
xv->xv_port = xv_port;
if (!XShmQueryExtension(xfi->display))
{
DEBUG_XV("no shmem available.");
return;
}
ret = XvQueryExtension(xfi->display, &version, &release, &request_base, &event_base, &error_base);
if (ret != Success)
{
DEBUG_XV("XvQueryExtension failed %d.", ret);
return;
}
DEBUG_XV("version %u release %u", version, release);
ret = XvQueryAdaptors(xfi->display, DefaultRootWindow(xfi->display),
&num_adaptors, &ai);
if (ret != Success)
{
DEBUG_XV("XvQueryAdaptors failed %d.", ret);
return;
}
for (i = 0; i < num_adaptors; i++)
{
DEBUG_XV("adapter port %ld-%ld (%s)", ai[i].base_id,
ai[i].base_id + ai[i].num_ports - 1, ai[i].name);
if (xv->xv_port == 0 && i == num_adaptors - 1)
xv->xv_port = ai[i].base_id;
}
if (num_adaptors > 0)
XvFreeAdaptorInfo(ai);
if (xv->xv_port == 0)
{
DEBUG_XV("no adapter selected, video frames will not be processed.");
return;
}
DEBUG_XV("selected %ld", xv->xv_port);
attr = XvQueryPortAttributes(xfi->display, xv->xv_port, &ret);
for (i = 0; i < (unsigned int)ret; i++)
{
if (strcmp(attr[i].name, "XV_COLORKEY") == 0)
{
xv->xv_colorkey_atom = XInternAtom(xfi->display, "XV_COLORKEY", FALSE);
XvSetPortAttribute(xfi->display, xv->xv_port, xv->xv_colorkey_atom, attr[i].min_value + 1);
break;
}
}
XFree(attr);
#ifdef WITH_DEBUG_XV
fprintf(stderr, "xf_tsmf_init: pixel format ");
#endif
fo = XvListImageFormats(xfi->display, xv->xv_port, &ret);
if (ret > 0)
{
xv->xv_pixfmts = (UINT32*) malloc((ret + 1) * sizeof(UINT32));
ZeroMemory(xv->xv_pixfmts, (ret + 1) * sizeof(UINT32));
for (i = 0; i < ret; i++)
{
xv->xv_pixfmts[i] = fo[i].id;
#ifdef WITH_DEBUG_XV
fprintf(stderr, "%c%c%c%c ", ((char*)(xv->xv_pixfmts + i))[0], ((char*)(xv->xv_pixfmts + i))[1],
((char*)(xv->xv_pixfmts + i))[2], ((char*)(xv->xv_pixfmts + i))[3]);
#endif
}
xv->xv_pixfmts[i] = 0;
}
XFree(fo);
#ifdef WITH_DEBUG_XV
fprintf(stderr, "\n");
#endif
}
/* NOTE: If vo.colorkey has bits set after the first 3 low order bytes
* we don't draw anything as this means it was forced to off. */
static int xv_init_colorkey(struct vo *vo)
{
struct xvctx *ctx = vo->priv;
Display *display = vo->x11->display;
Atom xv_atom;
int rez;
/* check if colorkeying is needed */
xv_atom = xv_intern_atom_if_exists(vo, "XV_COLORKEY");
if (xv_atom != None && !(ctx->colorkey & 0xFF000000)) {
if (ctx->xv_ck_info.source == CK_SRC_CUR) {
int colorkey_ret;
rez = XvGetPortAttribute(display, ctx->xv_port, xv_atom,
&colorkey_ret);
if (rez == Success)
ctx->xv_colorkey = colorkey_ret;
else {
MP_FATAL(vo, "Couldn't get colorkey! "
"Maybe the selected Xv port has no overlay.\n");
return 0; // error getting colorkey
}
} else {
ctx->xv_colorkey = ctx->colorkey;
/* check if we have to set the colorkey too */
if (ctx->xv_ck_info.source == CK_SRC_SET) {
xv_atom = XInternAtom(display, "XV_COLORKEY", False);
rez = XvSetPortAttribute(display, ctx->xv_port, xv_atom,
ctx->colorkey);
if (rez != Success) {
MP_FATAL(vo, "Couldn't set colorkey!\n");
return 0; // error setting colorkey
}
}
}
xv_atom = xv_intern_atom_if_exists(vo, "XV_AUTOPAINT_COLORKEY");
/* should we draw the colorkey ourselves or activate autopainting? */
if (ctx->xv_ck_info.method == CK_METHOD_AUTOPAINT) {
rez = !Success;
if (xv_atom != None) // autopaint is supported
rez = XvSetPortAttribute(display, ctx->xv_port, xv_atom, 1);
if (rez != Success)
ctx->xv_ck_info.method = CK_METHOD_MANUALFILL;
} else {
// disable colorkey autopainting if supported
if (xv_atom != None)
XvSetPortAttribute(display, ctx->xv_port, xv_atom, 0);
}
} else // do no colorkey drawing at all
ctx->xv_ck_info.method = CK_METHOD_NONE;
xv_print_ck_info(vo);
return 1;
}
static int XVideoGetPort( Display *p_display,
int32_t i_chroma,
int i_requested_adaptor) // -1 for autoscan
{
XvAdaptorInfo *p_adaptor;
unsigned int i;
unsigned int i_adaptor, i_num_adaptors;
int i_selected_port;
switch( XvQueryExtension( p_display, &i, &i, &i, &i, &i ) )
{
case Success:
break;
case XvBadExtension:
ml_log_error("XvBadExtension\n" );
return -1;
case XvBadAlloc:
ml_log_error("XvBadAlloc\n" );
return -1;
default:
ml_log_error("XvQueryExtension failed\n" );
return -1;
}
switch( XvQueryAdaptors( p_display,
DefaultRootWindow( p_display ),
&i_num_adaptors, &p_adaptor ) )
{
case Success:
break;
case XvBadExtension:
ml_log_error("XvBadExtension for XvQueryAdaptors\n" );
return -1;
case XvBadAlloc:
ml_log_error("XvBadAlloc for XvQueryAdaptors\n" );
return -1;
default:
ml_log_error("XvQueryAdaptors failed\n" );
return -1;
}
i_selected_port = -1;
for( i_adaptor = 0; i_adaptor < i_num_adaptors; ++i_adaptor )
{
XvImageFormatValues *p_formats;
int i_format, i_num_formats;
int i_port;
/* If we requested an adaptor and it's not this one, we aren't
* interested */
if( i_requested_adaptor != -1 && i_adaptor != (unsigned int)i_requested_adaptor )
{
continue;
}
/* If the adaptor doesn't have the required properties, skip it */
if( !( p_adaptor[ i_adaptor ].type & XvInputMask ) ||
!( p_adaptor[ i_adaptor ].type & XvImageMask ) )
{
continue;
}
/* Check that adaptor supports our requested format... */
p_formats = XvListImageFormats( p_display,
p_adaptor[i_adaptor].base_id,
&i_num_formats );
for( i_format = 0;
i_format < i_num_formats && ( i_selected_port == -1 );
i_format++ )
{
XvAttribute *p_attr;
int i_attr, i_num_attributes;
/* Matching chroma? */
if( p_formats[ i_format ].id != i_chroma )
{
continue;
}
/* Look for the first available port supporting this format */
for( i_port = p_adaptor[i_adaptor].base_id;
( i_port < (int)(p_adaptor[i_adaptor].base_id
+ p_adaptor[i_adaptor].num_ports) )
&& ( i_selected_port == -1 );
i_port++ )
{
if( XvGrabPort( p_display, i_port, CurrentTime )
== Success )
{
i_selected_port = i_port;
}
}
/* If no free port was found, forget it */
if( i_selected_port == -1 )
{
continue;
}
/* If we found a port, print information about it */
ml_log_info("X11 display adaptor %i, port %i, format 0x%x (%4.4s) %s\n",
i_adaptor, i_selected_port, p_formats[ i_format ].id,
(char *)&p_formats[ i_format ].id,
( p_formats[ i_format ].format == XvPacked ) ?
"packed" : "planar" );
/* Make sure XV_AUTOPAINT_COLORKEY is set */
p_attr = XvQueryPortAttributes( p_display,
i_selected_port,
&i_num_attributes );
for( i_attr = 0; i_attr < i_num_attributes; i_attr++ )
{
if( !strcmp( p_attr[i_attr].name, "XV_AUTOPAINT_COLORKEY" ) )
{
const Atom autopaint =
XInternAtom( p_display,
"XV_AUTOPAINT_COLORKEY", False );
XvSetPortAttribute( p_display,
i_selected_port, autopaint, 1 );
break;
}
}
if( p_attr != NULL )
{
XFree( p_attr );
}
}
if( p_formats != NULL )
{
XFree( p_formats );
}
}
if( i_num_adaptors > 0 )
{
XvFreeAdaptorInfo( p_adaptor );
}
if( i_selected_port == -1 )
{
int i_chroma_tmp = X112VLC_FOURCC( i_chroma );
if( i_requested_adaptor == -1 )
{
ml_log_error("no free XVideo port found for format: "
"0x%.8x (%4.4s)\n", i_chroma_tmp, (char*)&i_chroma_tmp );
}
else
{
ml_log_error("XVideo adaptor %i does not have a free: "
"XVideo port for format 0x%.8x (%4.4s)\n",
i_requested_adaptor, i_chroma_tmp, (char*)&i_chroma_tmp );
}
}
return i_selected_port;
}
