winex11.drv: Assign struct.
[wine] / dlls / winex11.drv / xvidmode.c
1 /*
2  * DirectDraw XVidMode interface
3  *
4  * Copyright 2001 TransGaming Technologies, Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <string.h>
25 #include <stdio.h>
26 #include <math.h>
27
28 #include "x11drv.h"
29
30 #ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
31 #include <X11/extensions/xf86vmode.h>
32 #endif
33 #ifdef HAVE_X11_EXTENSIONS_XF86VMPROTO_H
34 #include <X11/extensions/xf86vmproto.h>
35 #endif
36
37 #include "xvidmode.h"
38
39 #include "windef.h"
40 #include "wingdi.h"
41 #include "ddrawi.h"
42 #include "wine/debug.h"
43 #include "wine/library.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(xvidmode);
46
47 #ifdef SONAME_LIBXXF86VM
48
49 extern int usexvidmode;
50
51 static int xf86vm_event, xf86vm_error, xf86vm_major, xf86vm_minor;
52
53 #ifdef X_XF86VidModeSetGammaRamp
54 static int xf86vm_gammaramp_size;
55 static BOOL xf86vm_use_gammaramp;
56 #endif /* X_XF86VidModeSetGammaRamp */
57
58 static LPDDHALMODEINFO dd_modes;
59 static unsigned int dd_mode_count;
60 static XF86VidModeModeInfo** real_xf86vm_modes;
61 static unsigned int real_xf86vm_mode_count;
62
63 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
64 MAKE_FUNCPTR(XF86VidModeGetAllModeLines)
65 MAKE_FUNCPTR(XF86VidModeGetModeLine)
66 MAKE_FUNCPTR(XF86VidModeLockModeSwitch)
67 MAKE_FUNCPTR(XF86VidModeQueryExtension)
68 MAKE_FUNCPTR(XF86VidModeQueryVersion)
69 MAKE_FUNCPTR(XF86VidModeSetViewPort)
70 MAKE_FUNCPTR(XF86VidModeSwitchToMode)
71 #ifdef X_XF86VidModeSetGamma
72 MAKE_FUNCPTR(XF86VidModeGetGamma)
73 MAKE_FUNCPTR(XF86VidModeSetGamma)
74 #endif
75 #ifdef X_XF86VidModeSetGammaRamp
76 MAKE_FUNCPTR(XF86VidModeGetGammaRamp)
77 MAKE_FUNCPTR(XF86VidModeGetGammaRampSize)
78 MAKE_FUNCPTR(XF86VidModeSetGammaRamp)
79 #endif
80 #undef MAKE_FUNCPTR
81
82
83 static void convert_modeinfo( const XF86VidModeModeInfo *mode)
84 {
85   int rate;
86   if (mode->htotal!=0 && mode->vtotal!=0)
87       rate = mode->dotclock * 1000 / (mode->htotal * mode->vtotal);
88   else
89       rate = 0;
90   X11DRV_Settings_AddOneMode(mode->hdisplay, mode->vdisplay, 0, rate);
91 }
92
93 static void convert_modeline(int dotclock, const XF86VidModeModeLine *mode, LPDDHALMODEINFO info, unsigned int bpp)
94 {
95   info->dwWidth      = mode->hdisplay;
96   info->dwHeight     = mode->vdisplay;
97   if (mode->htotal!=0 && mode->vtotal!=0)
98       info->wRefreshRate = dotclock * 1000 / (mode->htotal * mode->vtotal);
99   else
100       info->wRefreshRate = 0;
101   TRACE(" width=%d, height=%d, refresh=%d\n",
102         info->dwWidth, info->dwHeight, info->wRefreshRate);
103   info->lPitch         = 0;
104   info->dwBPP          = bpp;
105   info->wFlags         = 0;
106   info->dwRBitMask     = 0;
107   info->dwGBitMask     = 0;
108   info->dwBBitMask     = 0;
109   info->dwAlphaBitMask = 0;
110 }
111
112 static int XVidModeErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
113 {
114     return 1;
115 }
116
117 static int X11DRV_XF86VM_GetCurrentMode(void)
118 {
119   XF86VidModeModeLine line;
120   int dotclock;
121   unsigned int i;
122   DDHALMODEINFO cmode;
123   DWORD dwBpp = screen_bpp;
124
125   TRACE("Querying XVidMode current mode\n");
126   wine_tsx11_lock();
127   pXF86VidModeGetModeLine(gdi_display, DefaultScreen(gdi_display), &dotclock, &line);
128   wine_tsx11_unlock();
129   convert_modeline(dotclock, &line, &cmode, dwBpp);
130   for (i=0; i<dd_mode_count; i++)
131     if (memcmp(&dd_modes[i], &cmode, sizeof(cmode)) == 0) {
132       TRACE("mode=%d\n", i);
133       return i;
134     }
135   ERR("In unknown mode, returning default\n");
136   return 0;
137 }
138
139 static LONG X11DRV_XF86VM_SetCurrentMode(int mode)
140 {
141   DWORD dwBpp = screen_bpp;
142   /* only set modes from the original color depth */
143   if (dwBpp != dd_modes[mode].dwBPP)
144   {
145       FIXME("Cannot change screen BPP from %d to %d\n", dwBpp, dd_modes[mode].dwBPP);
146   }
147   mode = mode % real_xf86vm_mode_count;
148
149   wine_tsx11_lock();
150   TRACE("Resizing X display to %dx%d\n", 
151         real_xf86vm_modes[mode]->hdisplay, real_xf86vm_modes[mode]->vdisplay);
152   pXF86VidModeSwitchToMode(gdi_display, DefaultScreen(gdi_display), real_xf86vm_modes[mode]);
153 #if 0 /* it is said that SetViewPort causes problems with some X servers */
154   pXF86VidModeSetViewPort(gdi_display, DefaultScreen(gdi_display), 0, 0);
155 #else
156   XWarpPointer(gdi_display, None, DefaultRootWindow(gdi_display), 0, 0, 0, 0, 0, 0);
157 #endif
158   XSync(gdi_display, False);
159   wine_tsx11_unlock();
160   X11DRV_resize_desktop( real_xf86vm_modes[mode]->hdisplay, real_xf86vm_modes[mode]->vdisplay );
161   return DISP_CHANGE_SUCCESSFUL;
162 }
163
164
165 void X11DRV_XF86VM_Init(void)
166 {
167   void *xvidmode_handle;
168   Bool ok;
169   int nmodes;
170   unsigned int i;
171
172   if (xf86vm_major) return; /* already initialized? */
173
174   xvidmode_handle = wine_dlopen(SONAME_LIBXXF86VM, RTLD_NOW, NULL, 0);
175   if (!xvidmode_handle)
176   {
177     TRACE("Unable to open %s, XVidMode disabled\n", SONAME_LIBXXF86VM);
178     usexvidmode = 0;
179     return;
180   }
181
182 #define LOAD_FUNCPTR(f) \
183     if((p##f = wine_dlsym(xvidmode_handle, #f, NULL, 0)) == NULL) \
184         goto sym_not_found;
185     LOAD_FUNCPTR(XF86VidModeGetAllModeLines)
186     LOAD_FUNCPTR(XF86VidModeGetModeLine)
187     LOAD_FUNCPTR(XF86VidModeLockModeSwitch)
188     LOAD_FUNCPTR(XF86VidModeQueryExtension)
189     LOAD_FUNCPTR(XF86VidModeQueryVersion)
190     LOAD_FUNCPTR(XF86VidModeSetViewPort)
191     LOAD_FUNCPTR(XF86VidModeSwitchToMode)
192 #ifdef X_XF86VidModeSetGamma
193     LOAD_FUNCPTR(XF86VidModeGetGamma)
194     LOAD_FUNCPTR(XF86VidModeSetGamma)
195 #endif
196 #ifdef X_XF86VidModeSetGammaRamp
197     LOAD_FUNCPTR(XF86VidModeGetGammaRamp)
198     LOAD_FUNCPTR(XF86VidModeGetGammaRampSize)
199     LOAD_FUNCPTR(XF86VidModeSetGammaRamp)
200 #endif
201 #undef LOAD_FUNCPTR
202
203   /* see if XVidMode is available */
204   wine_tsx11_lock();
205   ok = pXF86VidModeQueryExtension(gdi_display, &xf86vm_event, &xf86vm_error);
206   wine_tsx11_unlock();
207   if (!ok) return;
208
209   X11DRV_expect_error(gdi_display, XVidModeErrorHandler, NULL);
210   ok = pXF86VidModeQueryVersion(gdi_display, &xf86vm_major, &xf86vm_minor);
211   if (X11DRV_check_error() || !ok) return;
212
213 #ifdef X_XF86VidModeSetGammaRamp
214   if (xf86vm_major > 2 || (xf86vm_major == 2 && xf86vm_minor >= 1))
215   {
216       X11DRV_expect_error(gdi_display, XVidModeErrorHandler, NULL);
217       pXF86VidModeGetGammaRampSize(gdi_display, DefaultScreen(gdi_display),
218                                    &xf86vm_gammaramp_size);
219       if (X11DRV_check_error()) xf86vm_gammaramp_size = 0;
220       if (xf86vm_gammaramp_size == 256)
221           xf86vm_use_gammaramp = TRUE;
222   }
223 #endif /* X_XF86VidModeSetGammaRamp */
224
225   /* retrieve modes */
226   if (usexvidmode && root_window == DefaultRootWindow( gdi_display ))
227   {
228       X11DRV_expect_error(gdi_display, XVidModeErrorHandler, NULL);
229       ok = pXF86VidModeGetAllModeLines(gdi_display, DefaultScreen(gdi_display), &nmodes, &real_xf86vm_modes);
230       if (X11DRV_check_error() || !ok) return;
231   }
232   else return; /* In desktop mode, do not switch resolution... But still use the Gamma ramp stuff */
233
234   TRACE("XVidMode modes: count=%d\n", nmodes);
235
236   real_xf86vm_mode_count = nmodes;
237
238   dd_modes = X11DRV_Settings_SetHandlers("XF86VidMode", 
239                                          X11DRV_XF86VM_GetCurrentMode, 
240                                          X11DRV_XF86VM_SetCurrentMode, 
241                                          nmodes, 1);
242
243   /* convert modes to DDHALMODEINFO format */
244   for (i=0; i<real_xf86vm_mode_count; i++)
245   {
246       convert_modeinfo(real_xf86vm_modes[i]);
247   }
248   /* add modes for different color depths */
249   X11DRV_Settings_AddDepthModes();
250   dd_mode_count = X11DRV_Settings_GetModeCount();
251
252   TRACE("Available DD modes: count=%d\n", dd_mode_count);
253   TRACE("Enabling XVidMode\n");
254   return;
255
256 sym_not_found:
257     TRACE("Unable to load function pointers from %s, XVidMode disabled\n", SONAME_LIBXXF86VM);
258     wine_dlclose(xvidmode_handle, NULL, 0);
259     xvidmode_handle = NULL;
260     usexvidmode = 0;
261 }
262
263 void X11DRV_XF86VM_Cleanup(void)
264 {
265   wine_tsx11_lock();
266   if (real_xf86vm_modes) XFree(real_xf86vm_modes);
267   wine_tsx11_unlock();
268 }
269
270 /***** GAMMA CONTROL *****/
271 /* (only available in XF86VidMode 2.x) */
272
273 #ifdef X_XF86VidModeSetGamma
274
275 static void GenerateRampFromGamma(WORD ramp[256], float gamma)
276 {
277   float r_gamma = 1/gamma;
278   unsigned i;
279   TRACE("gamma is %f\n", r_gamma);
280   for (i=0; i<256; i++)
281     ramp[i] = pow(i/255.0, r_gamma) * 65535.0;
282 }
283
284 static BOOL ComputeGammaFromRamp(WORD ramp[256], float *gamma)
285 {
286   float r_x, r_y, r_lx, r_ly, r_d, r_v, r_e, g_avg, g_min, g_max;
287   unsigned i, f, l, g_n, c;
288   f = ramp[0];
289   l = ramp[255];
290   if (f >= l) {
291     ERR("inverted or flat gamma ramp (%d->%d), rejected\n", f, l);
292     return FALSE;
293   }
294   r_d = l - f;
295   g_min = g_max = g_avg = 0.0;
296   /* check gamma ramp entries to estimate the gamma */
297   TRACE("analyzing gamma ramp (%d->%d)\n", f, l);
298   for (i=1, g_n=0; i<255; i++) {
299     if (ramp[i] < f || ramp[i] > l) {
300       ERR("strange gamma ramp ([%d]=%d for %d->%d), rejected\n", i, ramp[i], f, l);
301       return FALSE;
302     }
303     c = ramp[i] - f;
304     if (!c) continue; /* avoid log(0) */
305
306     /* normalize entry values into 0..1 range */
307     r_x = i/255.0; r_y = c / r_d;
308     /* compute logarithms of values */
309     r_lx = log(r_x); r_ly = log(r_y);
310     /* compute gamma for this entry */
311     r_v = r_ly / r_lx;
312     /* compute differential (error estimate) for this entry */
313     /* some games use table-based logarithms that magnifies the error by 128 */
314     r_e = -r_lx * 128 / (c * r_lx * r_lx);
315
316     /* compute min & max while compensating for estimated error */
317     if (!g_n || g_min > (r_v + r_e)) g_min = r_v + r_e;
318     if (!g_n || g_max < (r_v - r_e)) g_max = r_v - r_e;
319
320     /* add to average */
321     g_avg += r_v;
322     g_n++;
323     /* TRACE("[%d]=%d, gamma=%f, error=%f\n", i, ramp[i], r_v, r_e); */
324   }
325   if (!g_n) {
326     ERR("no gamma data, shouldn't happen\n");
327     return FALSE;
328   }
329   g_avg /= g_n;
330   TRACE("low bias is %d, high is %d, gamma is %5.3f\n", f, 65535-l, g_avg);
331   /* the bias could be because the app wanted something like a "red shift"
332    * like when you're hit in Quake, but XVidMode doesn't support it,
333    * so we have to reject a significant bias */
334   if (f && f > (pow(1/255.0, g_avg) * 65536.0)) {
335     ERR("low-biased gamma ramp (%d), rejected\n", f);
336     return FALSE;
337   }
338   /* check that the gamma is reasonably uniform across the ramp */
339   if (g_max - g_min > 12.8) {
340     ERR("ramp not uniform (max=%f, min=%f, avg=%f), rejected\n", g_max, g_min, g_avg);
341     return FALSE;
342   }
343   /* check that the gamma is not too bright */
344   if (g_avg < 0.2) {
345     ERR("too bright gamma ( %5.3f), rejected\n", g_avg);
346     return FALSE;
347   }
348   /* ok, now we're pretty sure we can set the desired gamma ramp,
349    * so go for it */
350   *gamma = 1/g_avg;
351   return TRUE;
352 }
353
354 #endif /* X_XF86VidModeSetGamma */
355
356 /* Hmm... should gamma control be available in desktop mode or not?
357  * I'll assume that it should */
358
359 static BOOL X11DRV_XF86VM_GetGammaRamp(LPDDGAMMARAMP ramp)
360 {
361 #ifdef X_XF86VidModeSetGamma
362   XF86VidModeGamma gamma;
363   Bool ret;
364
365   if (xf86vm_major < 2) return FALSE; /* no gamma control */
366 #ifdef X_XF86VidModeSetGammaRamp
367   else if (xf86vm_use_gammaramp)
368   {
369       Bool ret;
370       wine_tsx11_lock();
371       ret = pXF86VidModeGetGammaRamp(gdi_display, DefaultScreen(gdi_display), 256,
372                                     ramp->red, ramp->green, ramp->blue);
373       wine_tsx11_unlock();
374       return ret;
375   }
376 #endif
377   else
378   {
379       wine_tsx11_lock();
380       ret = pXF86VidModeGetGamma(gdi_display, DefaultScreen(gdi_display), &gamma);
381       wine_tsx11_unlock();
382       if (ret) {
383           GenerateRampFromGamma(ramp->red,   gamma.red);
384           GenerateRampFromGamma(ramp->green, gamma.green);
385           GenerateRampFromGamma(ramp->blue,  gamma.blue);
386           return TRUE;
387       }
388   }
389 #endif /* X_XF86VidModeSetGamma */
390   return FALSE;
391 }
392
393 static BOOL X11DRV_XF86VM_SetGammaRamp(LPDDGAMMARAMP ramp)
394 {
395   Bool ret = FALSE;
396 #ifdef X_XF86VidModeSetGamma
397   XF86VidModeGamma gamma;
398
399   if (xf86vm_major < 2 || !usexvidmode) return FALSE; /* no gamma control */
400   if (!ComputeGammaFromRamp(ramp->red,   &gamma.red) || /* ramp validation */
401       !ComputeGammaFromRamp(ramp->green, &gamma.green) ||
402       !ComputeGammaFromRamp(ramp->blue,  &gamma.blue)) return FALSE;
403   wine_tsx11_lock();
404 #ifdef X_XF86VidModeSetGammaRamp
405   if (xf86vm_use_gammaramp)
406       ret = pXF86VidModeSetGammaRamp(gdi_display, DefaultScreen(gdi_display), 256,
407                                     ramp->red, ramp->green, ramp->blue);
408   else
409 #endif
410       ret = pXF86VidModeSetGamma(gdi_display, DefaultScreen(gdi_display), &gamma);
411   wine_tsx11_unlock();
412 #endif /* X_XF86VidModeSetGamma */
413   return ret;
414 }
415
416 #endif /* SONAME_LIBXXF86VM */
417
418 /***********************************************************************
419  *              GetDeviceGammaRamp (X11DRV.@)
420  *
421  * FIXME: should move to somewhere appropriate, but probably not before
422  * the stuff in graphics/x11drv/ has been moved to dlls/x11drv, so that
423  * they can include xvidmode.h directly
424  */
425 BOOL X11DRV_GetDeviceGammaRamp(PHYSDEV dev, LPVOID ramp)
426 {
427     if (GetObjectType( dev->hdc ) == OBJ_MEMDC)
428     {
429         SetLastError( ERROR_INVALID_PARAMETER );
430         return FALSE;
431     }
432 #ifdef SONAME_LIBXXF86VM
433   return X11DRV_XF86VM_GetGammaRamp(ramp);
434 #else
435   return FALSE;
436 #endif
437 }
438
439 /***********************************************************************
440  *              SetDeviceGammaRamp (X11DRV.@)
441  *
442  * FIXME: should move to somewhere appropriate, but probably not before
443  * the stuff in graphics/x11drv/ has been moved to dlls/x11drv, so that
444  * they can include xvidmode.h directly
445  */
446 BOOL X11DRV_SetDeviceGammaRamp(PHYSDEV dev, LPVOID ramp)
447 {
448     if (GetObjectType( dev->hdc ) == OBJ_MEMDC)
449     {
450         SetLastError( ERROR_INVALID_PARAMETER );
451         return FALSE;
452     }
453 #ifdef SONAME_LIBXXF86VM
454   return X11DRV_XF86VM_SetGammaRamp(ramp);
455 #else
456   return FALSE;
457 #endif
458 }