static void SwitchCallback(Widget w, XtPointer call_data, XtPointer client_data) { int direction = (long)call_data; Arg args[1]; Bool result; char label[32]; XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, False); result = XF86VidModeSwitchMode(XtDisplay(toplevel), vidtune->screen, direction); XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, True); if (!result) return; UpdateCallback(w, call_data, client_data); if (modeline.htotal && modeline.vtotal) XmuSnprintf(label, sizeof(label), "%dx%d @ %d Hz", modeline.hdisplay, modeline.vdisplay, (int)((double)dot_clock / (double)modeline.htotal * 1000.0 / (double)modeline.vtotal)); else XmuSnprintf(label, sizeof(label), "%dx%d", modeline.hdisplay, modeline.vdisplay); XtSetArg(args[0], XtNlabel, label); XtSetValues(mode, args, 1); }
static void CleanUp(Display *display) { /* Make sure mode switching is not locked out at exit */ XF86VidModeLockModeSwitch(display, vidtune->screen, False); XFlush(display); }
void X11DRV_XF86VM_SetExclusiveMode(int lock) { if (!dd_modes) return; /* no XVidMode */ wine_tsx11_lock(); XF86VidModeLockModeSwitch(gdi_display, DefaultScreen(gdi_display), lock); wine_tsx11_unlock(); }
static void SelectCallback(Widget w, XtPointer call_data, XtPointer client_data) { XF86VidModeModeInfo *info = (XF86VidModeModeInfo*)call_data; Arg args[1]; Bool result; XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, False); result = XF86VidModeSwitchToMode(XtDisplay(toplevel), vidtune->screen, info); XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, True); if (!result) return; XtSetArg(args[0], XtNlabel, XtName(w)); XtSetValues(mode, args, 1); UpdateCallback(w, call_data, client_data); }
void VideoModeConfigureEnd(void) { XtUnmapWidget(vtune); if (vidtune != NULL) { XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, False); XSetErrorHandler(XtErrorFunc); } vidtune = NULL; }
/*ARGSUSED*/ static void ChangeScreenCallback(Widget w, XtPointer call_data, XtPointer client_data) { Arg args[1]; screenno = (long)call_data; if (screenno > computer.num_vidmodes || screenno < 0 || vidtune == computer.vidmodes[screenno]) return; XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, False); vidtune = computer.vidmodes[screenno]; XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, True); UpdateCallback(w, call_data, client_data); GetModes(); XtSetArg(args[0], XtNlabel, XtName(w)); XtSetValues(screenb, args, 1); SetLabelAndModeline(); }
void _glfwRestoreVideoMode(void) { if (_glfwLibrary.X11.FS.modeChanged) { if (_glfwLibrary.X11.RandR.available) { #if defined(_GLFW_HAS_XRANDR) XRRScreenConfiguration* sc; if (_glfwLibrary.X11.RandR.available) { sc = XRRGetScreenInfo(_glfwLibrary.X11.display, _glfwLibrary.X11.root); XRRSetScreenConfig(_glfwLibrary.X11.display, sc, _glfwLibrary.X11.root, _glfwLibrary.X11.FS.oldSizeID, _glfwLibrary.X11.FS.oldRotation, CurrentTime); XRRFreeScreenConfigInfo(sc); } #endif /*_GLFW_HAS_XRANDR*/ } else if (_glfwLibrary.X11.VidMode.available) { #if defined(_GLFW_HAS_XF86VIDMODE) // Unlock mode switch XF86VidModeLockModeSwitch(_glfwLibrary.X11.display, _glfwLibrary.X11.screen, 0); // Change the video mode back to the old mode XF86VidModeSwitchToMode(_glfwLibrary.X11.display, _glfwLibrary.X11.screen, &_glfwLibrary.X11.FS.oldMode); #endif /*_GLFW_HAS_XF86VIDMODE*/ } _glfwLibrary.X11.FS.modeChanged = GL_FALSE; } }
static void xfree_lock_mode_switch (saver_info *si, Bool lock_p) { static Bool any_mode_locked_p = False; saver_preferences *p = &si->prefs; int screen; int real_nscreens = ScreenCount (si->dpy); int event, error; Bool status; XErrorHandler old_handler; if (any_mode_locked_p == lock_p) return; if (!XF86VidModeQueryExtension (si->dpy, &event, &error)) return; for (screen = 0; screen < real_nscreens; screen++) { XSync (si->dpy, False); old_handler = XSetErrorHandler (ignore_all_errors_ehandler); error_handler_hit_p = False; status = XF86VidModeLockModeSwitch (si->dpy, screen, lock_p); XSync (si->dpy, False); XSetErrorHandler (old_handler); if (error_handler_hit_p) status = False; if (status) any_mode_locked_p = lock_p; if (!status && (p->verbose_p || !lock_p)) /* Only print this when verbose, or when we locked but can't unlock. I tried printing this message whenever it comes up, but mode-locking always fails if DontZoom is set in XF86Config. */ fprintf (stderr, "%s: %d: unable to %s mode switching!\n", blurb(), screen, (lock_p ? "lock" : "unlock")); else if (p->verbose_p) fprintf (stderr, "%s: %d: %s mode switching.\n", blurb(), screen, (lock_p ? "locked" : "unlocked")); } }
void _glfwSetVideoModeMODE(int mode, int rate) { if (_glfwLibrary.X11.RandR.available) { #if defined(_GLFW_HAS_XRANDR) XRRScreenConfiguration* sc; Window root; root = _glfwLibrary.X11.root; sc = XRRGetScreenInfo(_glfwLibrary.X11.display, root); // Remember old size and flag that we have changed the mode if (!_glfwLibrary.X11.FS.modeChanged) { _glfwLibrary.X11.FS.oldSizeID = XRRConfigCurrentConfiguration(sc, &_glfwLibrary.X11.FS.oldRotation); _glfwLibrary.X11.FS.oldWidth = DisplayWidth(_glfwLibrary.X11.display, _glfwLibrary.X11.screen); _glfwLibrary.X11.FS.oldHeight = DisplayHeight(_glfwLibrary.X11.display, _glfwLibrary.X11.screen); _glfwLibrary.X11.FS.modeChanged = GL_TRUE; } if (rate > 0) { // Set desired configuration XRRSetScreenConfigAndRate(_glfwLibrary.X11.display, sc, root, mode, RR_Rotate_0, (short) rate, CurrentTime); } else { // Set desired configuration XRRSetScreenConfig(_glfwLibrary.X11.display, sc, root, mode, RR_Rotate_0, CurrentTime); } XRRFreeScreenConfigInfo(sc); #endif /*_GLFW_HAS_XRANDR*/ } else if (_glfwLibrary.X11.VidMode.available) { #if defined(_GLFW_HAS_XF86VIDMODE) XF86VidModeModeInfo **modelist; int modecount; // Get a list of all available display modes XF86VidModeGetAllModeLines(_glfwLibrary.X11.display, _glfwLibrary.X11.screen, &modecount, &modelist); // Unlock mode switch if necessary if (_glfwLibrary.X11.FS.modeChanged) { XF86VidModeLockModeSwitch(_glfwLibrary.X11.display, _glfwLibrary.X11.screen, 0); } // Change the video mode to the desired mode XF86VidModeSwitchToMode(_glfwLibrary.X11.display, _glfwLibrary.X11.screen, modelist[mode]); // Set viewport to upper left corner (where our window will be) XF86VidModeSetViewPort(_glfwLibrary.X11.display, _glfwLibrary.X11.screen, 0, 0); // Lock mode switch XF86VidModeLockModeSwitch(_glfwLibrary.X11.display, _glfwLibrary.X11.screen, 1); // Remember old mode and flag that we have changed the mode if (!_glfwLibrary.X11.FS.modeChanged) { _glfwLibrary.X11.FS.oldMode = *modelist[0]; _glfwLibrary.X11.FS.modeChanged = GL_TRUE; } XFree(modelist); #endif /*_GLFW_HAS_XF86VIDMODE*/ } }
static int config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format) { int x_off, y_off; int wanted_width, wanted_height; static unsigned char *vo_dga_base; static int prev_width, prev_height; #ifdef HAVE_DGA2 // needed to change DGA video mode int mX = VO_DGA_INVALID_RES, mY = VO_DGA_INVALID_RES, mVBI = 100000, mMaxY = 0, i, j = 0; int dga_modenum; XDGAMode *modeline; XDGADevice *dgadevice; #else #ifdef HAVE_XF86VM unsigned int vm_event, vm_error; unsigned int vm_ver, vm_rev; int i, j = 0, have_vm = 0; int mX = VO_DGA_INVALID_RES, mY = VO_DGA_INVALID_RES, mVBI = 100000, mMaxY = 0, dga_modenum; #endif int bank, ram; #endif vo_dga_src_format = format; wanted_width = d_width; wanted_height = d_height; if (!wanted_height) wanted_height = height; if (!wanted_width) wanted_width = width; if (!vo_dbpp) { if ((format & IMGFMT_BGR_MASK) == IMGFMT_BGR) { vo_dga_src_mode = vd_ModeValid(format & 0xff); } } else { vo_dga_src_mode = vd_ModeValid(vo_dbpp); } vo_dga_hw_mode = SRC_MODE.vdm_hw_mode; if (!vo_dga_src_mode) { mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: unsupported video format!\n"); return 1; } vo_dga_vp_width = vo_screenwidth; vo_dga_vp_height = vo_screenheight; mp_msg(MSGT_VO, MSGL_V, "vo_dga: XServer res: %dx%d\n", vo_dga_vp_width, vo_dga_vp_height); // choose a suitable mode ... #ifdef HAVE_DGA2 // Code to change the video mode added by Michael Graffam // [email protected] mp_msg(MSGT_VO, MSGL_V, "vo_dga: vo_modelines=%p, vo_modecount=%d\n", vo_modelines, vo_modecount); if (vo_modelines == NULL) { mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: can't get modelines\n"); return 1; } mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: DGA 2.0 available :-) Can switch resolution AND depth!\n"); for (i = 0; i < vo_modecount; i++) { if (vd_ModeEqual(vo_modelines[i].depth, vo_modelines[i].bitsPerPixel, vo_modelines[i].redMask, vo_modelines[i].greenMask, vo_modelines[i].blueMask, vo_dga_hw_mode)) { mp_msg(MSGT_VO, MSGL_V, "maxy: %4d, depth: %2d, %4dx%4d, ", vo_modelines[i].maxViewportY, vo_modelines[i].depth, vo_modelines[i].imageWidth, vo_modelines[i].imageHeight); if (check_res (i, wanted_width, wanted_height, vo_modelines[i].depth, vo_modelines[i].viewportWidth, vo_modelines[i].viewportHeight, (unsigned) vo_modelines[i].verticalRefresh, vo_modelines[i].maxViewportY, &mX, &mY, &mVBI, &mMaxY)) j = i; } } mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Selected hardware mode %4d x %4d @ %3d Hz @ depth %2d, bitspp %2d.\n", mX, mY, mVBI, HW_MODE.vdm_depth, HW_MODE.vdm_bitspp); mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Video parameters by codec: %3d x %3d, depth %2d, bitspp %2d.\n", width, height, SRC_MODE.vdm_depth, SRC_MODE.vdm_bitspp); vo_dga_vp_width = mX; vo_dga_vp_height = mY; if ((flags & VOFLAG_SWSCALE) || (flags & VOFLAG_FULLSCREEN)) { /* -zoom or -fs */ scale_dstW = (d_width + 7) & ~7; scale_dstH = d_height; scale_srcW = width; scale_srcH = height; aspect_save_screenres(mX, mY); aspect_save_orig(scale_srcW, scale_srcH); aspect_save_prescale(scale_dstW, scale_dstH); if (flags & VOFLAG_FULLSCREEN) /* -fs */ aspect(&scale_dstW, &scale_dstH, A_ZOOM); else if (flags & VOFLAG_SWSCALE) /* -fs */ aspect(&scale_dstW, &scale_dstH, A_NOZOOM); mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Aspect corrected size for SwScaler: %4d x %4d.\n", scale_dstW, scale_dstH); /* XXX this is a hack, but I'm lazy ;-) :: atmos */ width = scale_dstW; height = scale_dstH; } vo_dga_width = vo_modelines[j].bytesPerScanline / HW_MODE.vdm_bytespp; dga_modenum = vo_modelines[j].num; modeline = vo_modelines + j; #else #ifdef HAVE_XF86VM mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: DGA 1.0 compatibility code: Using XF86VidMode for mode switching!\n"); if (XF86VidModeQueryExtension(mDisplay, &vm_event, &vm_error)) { XF86VidModeQueryVersion(mDisplay, &vm_ver, &vm_rev); mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: XF86VidMode Extension v%i.%i\n", vm_ver, vm_rev); have_vm = 1; } else { mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: XF86VidMode Extension not available.\n"); } #define GET_VREFRESH(dotclk, x, y)( (((dotclk)/(x))*1000)/(y) ) if (have_vm) { int modecount; XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount, &vo_dga_vidmodes); if (vo_dga_vidmodes != NULL) { for (i = 0; i < modecount; i++) { if (check_res(i, wanted_width, wanted_height, vo_dga_modes[vo_dga_hw_mode].vdm_depth, vo_dga_vidmodes[i]->hdisplay, vo_dga_vidmodes[i]->vdisplay, GET_VREFRESH(vo_dga_vidmodes[i]->dotclock, vo_dga_vidmodes[i]->htotal, vo_dga_vidmodes[i]->vtotal), 0, &mX, &mY, &mVBI, &mMaxY)) j = i; } mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Selected video mode %4d x %4d @ %3d Hz @ depth %2d, bitspp %2d, video %3d x %3d.\n", mX, mY, mVBI, vo_dga_modes[vo_dga_hw_mode].vdm_depth, vo_dga_modes[vo_dga_hw_mode].vdm_bitspp, width, height); } else { mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: XF86VidMode returned no screens - using current resolution.\n"); } dga_modenum = j; vo_dga_vp_width = mX; vo_dga_vp_height = mY; } #else mp_msg(MSGT_VO, MSGL_INFO, "vo_dga: Only have DGA 1.0 extension and no XF86VidMode :-(\n"); mp_msg(MSGT_VO, MSGL_INFO, " Thus, resolution switching is NOT possible.\n"); #endif #endif vo_dga_src_width = width; vo_dga_src_height = height; if (vo_dga_src_width > vo_dga_vp_width || vo_dga_src_height > vo_dga_vp_height) { mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: Sorry, video larger than viewport is not yet supported!\n"); // ugly, do something nicer in the future ... #ifndef HAVE_DGA2 #ifdef HAVE_XF86VM if (vo_dga_vidmodes) { XFree(vo_dga_vidmodes); vo_dga_vidmodes = NULL; } #endif #endif return 1; } if (vo_dga_vp_width == VO_DGA_INVALID_RES) { mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: Something is wrong with your DGA. There doesn't seem to be a\n" " single suitable mode!\n" " Please file a bug report (see DOCS/HTML/en/bugreports.html)\n"); #ifndef HAVE_DGA2 #ifdef HAVE_XF86VM if (vo_dga_vidmodes) { XFree(vo_dga_vidmodes); vo_dga_vidmodes = NULL; } #endif #endif return 1; } // now let's start the DGA thing if (!vo_config_count || width != prev_width || height != prev_height) { #ifdef HAVE_DGA2 if (!XDGAOpenFramebuffer(mDisplay, mScreen)) { mp_msg(MSGT_VO, MSGL_ERR, "vo_dga: Framebuffer mapping failed!!!\n"); return 1; } dgadevice = XDGASetMode(mDisplay, mScreen, dga_modenum); XDGASync(mDisplay, mScreen); vo_dga_base = dgadevice->data; XFree(dgadevice); XDGASetViewport(mDisplay, mScreen, 0, 0, XDGAFlipRetrace); #else #ifdef HAVE_XF86VM if (have_vm) { XF86VidModeLockModeSwitch(mDisplay, mScreen, 0); // Two calls are needed to switch modes on my ATI Rage 128. Why? // for riva128 one call is enough! XF86VidModeSwitchToMode(mDisplay, mScreen, vo_dga_vidmodes[dga_modenum]); XF86VidModeSwitchToMode(mDisplay, mScreen, vo_dga_vidmodes[dga_modenum]); } #endif XF86DGAGetViewPortSize(mDisplay, mScreen, &vo_dga_vp_width, &vo_dga_vp_height); XF86DGAGetVideo(mDisplay, mScreen, (char **) &vo_dga_base, &vo_dga_width, &bank, &ram); XF86DGADirectVideo(mDisplay, mScreen, XF86DGADirectGraphics | XF86DGADirectMouse | XF86DGADirectKeyb); XF86DGASetViewPort(mDisplay, mScreen, 0, 0); #endif } // do some more checkings here ... mp_msg(MSGT_VO, MSGL_V, "vo_dga: bytes/line: %d, screen res: %dx%d, depth: %d, base: %p, bpp: %d\n", vo_dga_width, vo_dga_vp_width, vo_dga_vp_height, HW_MODE.vdm_bytespp, vo_dga_base, HW_MODE.vdm_bitspp); x_off = (vo_dga_vp_width - vo_dga_src_width) >> 1; y_off = (vo_dga_vp_height - vo_dga_src_height) >> 1; vo_dga_bytes_per_line = vo_dga_src_width * HW_MODE.vdm_bytespp; vo_dga_lines = vo_dga_src_height; vo_dga_src_offset = 0; vo_dga_vp_offset = (y_off * vo_dga_width + x_off) * HW_MODE.vdm_bytespp; vo_dga_vp_skip = (vo_dga_width - vo_dga_src_width) * HW_MODE.vdm_bytespp; // todo mp_msg(MSGT_VO, MSGL_V, "vo_dga: vp_off=%d, vp_skip=%d, bpl=%d\n", vo_dga_vp_offset, vo_dga_vp_skip, vo_dga_bytes_per_line); XGrabKeyboard(mDisplay, DefaultRootWindow(mDisplay), True, GrabModeAsync, GrabModeAsync, CurrentTime); if (vo_grabpointer) XGrabPointer(mDisplay, DefaultRootWindow(mDisplay), True, ButtonPressMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); if (!vo_config_count || width != prev_width || height != prev_height) { init_video_buffers(vo_dga_base, vo_dga_vp_height, vo_dga_width * HW_MODE.vdm_bytespp, #ifdef HAVE_DGA2 modeline->maxViewportY, #else vo_dga_vp_height, #endif vo_doublebuffering); prev_width = width; prev_height = height; } mp_msg(MSGT_VO, MSGL_V, "vo_dga: Using %d frame buffer%s.\n", vo_dga_nr_video_buffers, vo_dga_nr_video_buffers == 1 ? "" : "s"); vo_dga_is_running = 1; return 0; }
void VideoModeConfigureStart(void) { vidtune = computer.vidmodes[screenno]; XtSetSensitive(vtune, vidtune != NULL); if (!XtIsManaged(vtune)) XtManageChild(vtune); else XtMapWidget(vtune); if (vidtune != NULL) { Arg args[1]; Boolean state; XF86ConfMonitorPtr mon; static char menuName[16]; static int menuN; XtErrorFunc = XSetErrorHandler(VidmodeError); XF86VidModeLockModeSwitch(XtDisplay(toplevel), vidtune->screen, True); GetModeLine(True); GetModes(); SetLabels(); XtSetArg(args[0], XtNstate, &state); XtGetValues(automatic, args, 1); XtSetSensitive(apply, !state); autoflag = state; if (monitor) XtDestroyWidget(monitor); XmuSnprintf(menuName, sizeof(menuName), "menuP%d", menuN); menuN = !menuN; monitor = XtCreatePopupShell(menuName, simpleMenuWidgetClass, vtune, NULL, 0); XtVaSetValues(monitorb, XtNmenuName, menuName, NULL, 0); mon = XF86Config->conf_monitor_lst; while (mon != NULL) { Widget sme = XtCreateManagedWidget(mon->mon_identifier, smeBSBObjectClass, monitor, NULL, 0); XtAddCallback(sme, XtNcallback, SelectMonitorCallback, (XtPointer)mon); /* guess the monitor at a given screen and/or * updates configuration if a monitor was removed from the * configuration. */ if (XF86Config->conf_layout_lst) { XF86ConfAdjacencyPtr adj = XF86Config->conf_layout_lst-> lay_adjacency_lst; while (adj != NULL) { if (adj->adj_screen != NULL) { if (adj->adj_screen->scrn_monitor == mon && adj->adj_scrnum >= 0 && adj->adj_scrnum < ScreenCount(XtDisplay(toplevel))) { if (computer.vidmodes[adj->adj_scrnum]->monitor == NULL || computer.vidmodes[adj->adj_scrnum]-> monitor == adj->adj_screen->scrn_monitor) { computer.vidmodes[adj->adj_scrnum]->monitor = adj->adj_screen->scrn_monitor; break; } else computer.vidmodes[adj->adj_scrnum]->monitor = NULL; } } adj = (XF86ConfAdjacencyPtr)(adj->list.next); } } mon = (XF86ConfMonitorPtr)(mon->list.next); } SetLabelAndModeline(); } }
static int SwitchRes(char inout, int x, int y, int w, int h, int *dw, int *dh) { static int vp_x, vp_y; XF86VidModeModeInfo *mode; int scr; scr = Dpy.screen; if (inout) { XF86VidModeModeLine curmode; int dotclock; int rx, ry; if (!XF86VidModeGetModeLine(disp, scr, &dotclock, &curmode)) return 0; XF86VidModeGetViewPort(disp, scr, &vp_x, &vp_y); mode = FindMode(w, h); if (mode) { #if USE_XRANDR int vw, vh; vw = WinGetW(VROOT); vh = WinGetH(VROOT); /* x and y relative to unrotated display */ if (Mode.screen.rotation == RR_Rotate_90) { rx = y; ry = vw - mode->vdisplay - x; } else if (Mode.screen.rotation == RR_Rotate_270) { rx = vh - mode->hdisplay - y; ry = x; } else if (Mode.screen.rotation == RR_Rotate_180) { rx = vw - mode->hdisplay - x; ry = vh - mode->vdisplay - y; } else #endif { rx = x; ry = y; } #if USE_XRANDR if ((Mode.screen.rotation == RR_Rotate_90) || (Mode.screen.rotation == RR_Rotate_270)) { *dw = mode->vdisplay; *dh = mode->hdisplay; } else #endif { *dw = mode->hdisplay; *dh = mode->vdisplay; } XF86VidModeLockModeSwitch(disp, scr, 0); std_vid_mode_cur = GetModeIndex(dotclock, &curmode); XF86VidModeSwitchToMode(disp, scr, mode); XF86VidModeSetViewPort(disp, scr, rx, ry); XF86VidModeLockModeSwitch(disp, scr, 1); return 1; } } else { mode = std_vid_modes[std_vid_mode_cur]; XF86VidModeLockModeSwitch(disp, scr, 0); XF86VidModeSwitchToMode(disp, scr, mode); XF86VidModeSetViewPort(disp, scr, vp_x, vp_y); #if 0 /* No, don't lock or we can't switch resolution */ XF86VidModeLockModeSwitch(disp, scr, 1); #endif } return 0; }