git.oblomov.eu Git - wine/blob - dlls/x11drv/xvidmode.c

   1 /*
   2  * DirectDraw XVidMode interface
   3  *
   4  * Copyright 2001 TransGaming Technologies, Inc.
   5  */
   6
   7 /* FIXME: ChangeDisplaySettings ought to be able to use this */
   8
   9 #include "config.h"
  10 #include <string.h>
  11
  12 #include "ts_xlib.h"
  13 #include "ts_xf86vmode.h"
  14 #include "x11drv.h"
  15 #include "x11ddraw.h"
  16 #include "xvidmode.h"
  17
  18 #include "windef.h"
  19 #include "wingdi.h"
  20 #include "ddrawi.h"
  21 #include "debugtools.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(x11drv);
  24
  25 #ifdef HAVE_LIBXXF86VM
  26
  27 extern int usexvidmode;
  28
  29 static int xf86vm_event, xf86vm_error, xf86vm_major, xf86vm_minor;
  30
  31 LPDDHALMODEINFO xf86vm_modes;
  32 unsigned xf86vm_mode_count;
  33 XF86VidModeModeInfo** modes;
  34
  35 static void convert_modeinfo( const XF86VidModeModeInfo *mode, LPDDHALMODEINFO info )
  36 {
  37   info->dwWidth      = mode->hdisplay;
  38   info->dwHeight     = mode->vdisplay;
  39   if (mode->htotal!=0 && mode->vtotal!=0)
  40       info->wRefreshRate = mode->dotclock * 1000 / (mode->htotal * mode->vtotal);
  41   else
  42       info->wRefreshRate = 0;
  43   TRACE(" width=%ld, height=%ld, refresh=%d\n",
  44         info->dwWidth, info->dwHeight, info->wRefreshRate);
  45   /* XVidMode cannot change display depths... */
  46   /* let's not bother with filling out these then... */
  47   info->lPitch         = 0;
  48   info->dwBPP          = 0;
  49   info->wFlags         = 0;
  50   info->dwRBitMask     = 0;
  51   info->dwGBitMask     = 0;
  52   info->dwBBitMask     = 0;
  53   info->dwAlphaBitMask = 0;
  54 }
  55
  56 static void convert_modeline(int dotclock, const XF86VidModeModeLine *mode, LPDDHALMODEINFO info)
  57 {
  58   info->dwWidth      = mode->hdisplay;
  59   info->dwHeight     = mode->vdisplay;
  60   if (mode->htotal!=0 && mode->vtotal!=0)
  61       info->wRefreshRate = dotclock * 1000 / (mode->htotal * mode->vtotal);
  62   else
  63       info->wRefreshRate = 0;
  64   TRACE(" width=%ld, height=%ld, refresh=%d\n",
  65         info->dwWidth, info->dwHeight, info->wRefreshRate);
  66   /* XVidMode cannot change display depths... */
  67   /* let's not bother with filling out these then... */
  68   info->lPitch         = 0;
  69   info->dwBPP          = 0;
  70   info->wFlags         = 0;
  71   info->dwRBitMask     = 0;
  72   info->dwGBitMask     = 0;
  73   info->dwBBitMask     = 0;
  74   info->dwAlphaBitMask = 0;
  75 }
  76
  77 void X11DRV_XF86VM_Init(void)
  78 {
  79   int nmodes, i;
  80
  81   if (xf86vm_major) return; /* already initialized? */
  82
  83   /* if in desktop mode, don't use XVidMode */
  84   if (root_window != DefaultRootWindow(gdi_display)) return;
  85
  86   if (!usexvidmode) return;
  87
  88   /* see if XVidMode is available */
  89   if (!TSXF86VidModeQueryExtension(gdi_display, &xf86vm_event, &xf86vm_error)) return;
  90   if (!TSXF86VidModeQueryVersion(gdi_display, &xf86vm_major, &xf86vm_minor)) return;
  91
  92   /* retrieve modes */
  93   if (!TSXF86VidModeGetAllModeLines(gdi_display, DefaultScreen(gdi_display), &nmodes,
  94                                     &modes))
  95     return;
  96
  97   TRACE("XVidMode modes: count=%d\n", nmodes);
  98
  99   xf86vm_mode_count = nmodes;
 100   xf86vm_modes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DDHALMODEINFO) * nmodes);
 101
 102   /* convert modes to DDHALMODEINFO format */
 103   for (i=0; i<nmodes; i++)
 104     convert_modeinfo(modes[i], &xf86vm_modes[i]);
 105
 106   TRACE("Enabling XVidMode\n");
 107 }
 108
 109 void X11DRV_XF86VM_Cleanup(void)
 110 {
 111   if (modes) TSXFree(modes);
 112 }
 113
 114 int X11DRV_XF86VM_GetCurrentMode(void)
 115 {
 116   XF86VidModeModeLine line;
 117   int dotclock, i;
 118   DDHALMODEINFO cmode;
 119
 120   if (!xf86vm_modes) return 0; /* no XVidMode */
 121
 122   TRACE("Querying XVidMode current mode\n");
 123   TSXF86VidModeGetModeLine(gdi_display, DefaultScreen(gdi_display), &dotclock, &line);
 124   convert_modeline(dotclock, &line, &cmode);
 125   for (i=0; i<xf86vm_mode_count; i++)
 126     if (memcmp(&xf86vm_modes[i], &cmode, sizeof(cmode)) == 0) {
 127       TRACE("mode=%d\n", i);
 128       return i;
 129     }
 130   ERR("unknown mode, shouldn't happen\n");
 131   return 0; /* return first mode */
 132 }
 133
 134 void X11DRV_XF86VM_SetCurrentMode(int mode)
 135 {
 136   if (!xf86vm_modes) return; /* no XVidMode */
 137
 138   TSXF86VidModeSwitchToMode(gdi_display, DefaultScreen(gdi_display), modes[mode]);
 139 #if 0 /* it is said that SetViewPort causes problems with some X servers */
 140   TSXF86VidModeSetViewPort(gdi_display, DefaultScreen(gdi_display), 0, 0);
 141 #else
 142   TSXWarpPointer(gdi_display, None, DefaultRootWindow(gdi_display), 0, 0, 0, 0, 0, 0);
 143 #endif
 144   TSXSync(gdi_display, False);
 145 }
 146
 147 void X11DRV_XF86VM_SetExclusiveMode(int lock)
 148 {
 149   if (!xf86vm_modes) return; /* no XVidMode */
 150
 151   TSXF86VidModeLockModeSwitch(gdi_display, DefaultScreen(gdi_display), lock);
 152 }
 153
 154 /* actual DirectDraw HAL stuff */
 155
 156 static DWORD PASCAL X11DRV_XF86VM_SetMode(LPDDHAL_SETMODEDATA data)
 157 {
 158   X11DRV_XF86VM_SetCurrentMode(data->dwModeIndex);
 159   X11DRV_DDHAL_SwitchMode(data->dwModeIndex, NULL, NULL);
 160   data->ddRVal = DD_OK;
 161   return DDHAL_DRIVER_HANDLED;
 162 }
 163
 164 int X11DRV_XF86VM_CreateDriver(LPDDHALINFO info)
 165 {
 166   if (!xf86vm_mode_count) return 0; /* no XVidMode */
 167
 168   info->dwNumModes = xf86vm_mode_count;
 169   info->lpModeInfo = xf86vm_modes;
 170   X11DRV_DDHAL_SwitchMode(X11DRV_XF86VM_GetCurrentMode(), NULL, NULL);
 171   info->lpDDCallbacks->SetMode = X11DRV_XF86VM_SetMode;
 172   return TRUE;
 173 }
 174
 175
 176 /***** GAMMA CONTROL *****/
 177 /* (only available in XF86VidMode 2.x) */
 178
 179 #ifdef X_XF86VidModeSetGamma
 180
 181 static void GenerateRampFromGamma(WORD ramp[256], float gamma)
 182 {
 183   float r_gamma = 1/gamma;
 184   unsigned i;
 185   TRACE("gamma is %f\n", r_gamma);
 186   for (i=0; i<256; i++)
 187     ramp[i] = pow(i/255.0, r_gamma) * 65535.0;
 188 }
 189
 190 static BOOL ComputeGammaFromRamp(WORD ramp[256], float *gamma)
 191 {
 192   float r_x, r_y, r_lx, r_ly, r_d, r_v, r_e, g_avg, g_min, g_max;
 193   unsigned i, f, l, g_n, c;
 194   f = ramp[0];
 195   l = ramp[255];
 196   if (f >= l) {
 197     ERR("inverted or flat gamma ramp (%d->%d), rejected\n", f, l);
 198     return FALSE;
 199   }
 200   r_d = l - f;
 201   g_min = g_max = g_avg = 0.0;
 202   /* check gamma ramp entries to estimate the gamma */
 203   TRACE("analyzing gamma ramp (%d->%d)\n", f, l);
 204   for (i=1, g_n=0; i<255; i++) {
 205     if (ramp[i] < f || ramp[i] > l) {
 206       ERR("strange gamma ramp ([%d]=%d for %d->%d), rejected\n", i, ramp[i], f, l);
 207       return FALSE;
 208     }
 209     c = ramp[i] - f;
 210     if (!c) continue; /* avoid log(0) */
 211
 212     /* normalize entry values into 0..1 range */
 213     r_x = i/255.0; r_y = c / r_d;
 214     /* compute logarithms of values */
 215     r_lx = log(r_x); r_ly = log(r_y);
 216     /* compute gamma for this entry */
 217     r_v = r_ly / r_lx;
 218     /* compute differential (error estimate) for this entry */
 219     /* some games use table-based logarithms that magnifies the error by 128 */
 220     r_e = -r_lx * 128 / (c * r_lx * r_lx);
 221
 222     /* compute min & max while compensating for estimated error */
 223     if (!g_n || g_min > (r_v + r_e)) g_min = r_v + r_e;
 224     if (!g_n || g_max < (r_v - r_e)) g_max = r_v - r_e;
 225
 226     /* add to average */
 227     g_avg += r_v;
 228     g_n++;
 229     /* TRACE("[%d]=%d, gamma=%f, error=%f\n", i, ramp[i], r_v, r_e); */
 230   }
 231   if (!g_n) {
 232     ERR("no gamma data, shouldn't happen\n");
 233     return FALSE;
 234   }
 235   g_avg /= g_n;
 236   TRACE("low bias is %d, high is %d, gamma is %5.3f\n", f, 65535-l, g_avg);
 237   /* the bias could be because the app wanted something like a "red shift"
 238    * like when you're hit in Quake, but XVidMode doesn't support it,
 239    * so we have to reject a significant bias */
 240   if (f && f > (pow(1/255.0, g_avg) * 65536.0)) {
 241     ERR("low-biased gamma ramp (%d), rejected\n", f);
 242     return FALSE;
 243   }
 244   /* check that the gamma is reasonably uniform across the ramp */
 245   if (g_max - g_min > 0.1) {
 246     ERR("ramp not uniform (max=%f, min=%f, avg=%f), rejected\n", g_max, g_min, g_avg);
 247     return FALSE;
 248   }
 249   /* ok, now we're pretty sure we can set the desired gamma ramp,
 250    * so go for it */
 251   *gamma = 1/g_avg;
 252   return TRUE;
 253 }
 254
 255 #endif /* X_XF86VidModeSetGamma */
 256
 257 /* Hmm... should gamma control be available in desktop mode or not?
 258  * I'll assume that it should */
 259
 260 BOOL X11DRV_XF86VM_GetGammaRamp(LPDDGAMMARAMP ramp)
 261 {
 262 #ifdef X_XF86VidModeSetGamma
 263   XF86VidModeGamma gamma;
 264   Bool ret;
 265
 266   if (xf86vm_major < 2) return FALSE; /* no gamma control */
 267   wine_tsx11_lock();
 268   ret = XF86VidModeGetGamma(gdi_display, DefaultScreen(gdi_display), &gamma);
 269   wine_tsx11_unlock();
 270   if (ret) {
 271     GenerateRampFromGamma(ramp->red,   gamma.red);
 272     GenerateRampFromGamma(ramp->green, gamma.green);
 273     GenerateRampFromGamma(ramp->blue,  gamma.blue);
 274     return TRUE;
 275   }
 276 #endif /* X_XF86VidModeSetGamma */
 277   return FALSE;
 278 }
 279
 280 BOOL X11DRV_XF86VM_SetGammaRamp(LPDDGAMMARAMP ramp)
 281 {
 282 #ifdef X_XF86VidModeSetGamma
 283   XF86VidModeGamma gamma;
 284
 285   if (xf86vm_major < 2) return FALSE; /* no gamma control */
 286   if (ComputeGammaFromRamp(ramp->red,   &gamma.red) &&
 287       ComputeGammaFromRamp(ramp->green, &gamma.green) &&
 288       ComputeGammaFromRamp(ramp->blue,  &gamma.blue)) {
 289     Bool ret;
 290     wine_tsx11_lock();
 291     ret = XF86VidModeSetGamma(gdi_display, DefaultScreen(gdi_display), &gamma);
 292     wine_tsx11_unlock();
 293     return ret;
 294   }
 295 #endif /* X_XF86VidModeSetGamma */
 296   return FALSE;
 297 }
 298
 299 #endif /* HAVE_LIBXXF86VM */
 300
 301 /***********************************************************************
 302  *              GetDeviceGammaRamp (X11DRV.@)
 303  *
 304  * FIXME: should move to somewhere appropriate, but probably not before
 305  * the stuff in graphics/x11drv/ has been moved to dlls/x11drv, so that
 306  * they can include xvidmode.h directly
 307  */
 308 BOOL X11DRV_GetDeviceGammaRamp(DC *dc, LPVOID ramp)
 309 {
 310 #ifdef HAVE_LIBXXF86VM
 311   return X11DRV_XF86VM_GetGammaRamp(ramp);
 312 #else
 313   return FALSE;
 314 #endif
 315 }
 316
 317 /***********************************************************************
 318  *              SetDeviceGammaRamp (X11DRV.@)
 319  *
 320  * FIXME: should move to somewhere appropriate, but probably not before
 321  * the stuff in graphics/x11drv/ has been moved to dlls/x11drv, so that
 322  * they can include xvidmode.h directly
 323  */
 324 BOOL X11DRV_SetDeviceGammaRamp(DC *dc, LPVOID ramp)
 325 {
 326 #ifdef HAVE_LIBXXF86VM
 327   return X11DRV_XF86VM_SetGammaRamp(ramp);
 328 #else
 329   return FALSE;
 330 #endif
 331 }