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; }