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 <string.h>
23 #include <stdio.h>
24 #include <math.h>
25
26 #include "x11drv.h"
27
28 #ifdef HAVE_LIBXXF86VM
29 #include <X11/extensions/xf86vmode.h>
30 #endif /* HAVE_LIBXXF86VM */
31
32 #include "xvidmode.h"
33
34 #include "windef.h"
35 #include "wingdi.h"
36 #include "ddrawi.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(xvidmode);
40
41 #ifdef HAVE_LIBXXF86VM
42
43 extern int usexvidmode;
44
45 static int xf86vm_event, xf86vm_error, xf86vm_major, xf86vm_minor;
46
47 #ifdef X_XF86VidModeSetGammaRamp
48 static int xf86vm_gammaramp_size;
49 static BOOL xf86vm_use_gammaramp;
50 #endif /* X_XF86VidModeSetGammaRamp */
51
52 static LPDDHALMODEINFO dd_modes;
53 static unsigned int dd_mode_count;
54 static XF86VidModeModeInfo** real_xf86vm_modes;
55 static unsigned int real_xf86vm_mode_count;
56
57 static void convert_modeinfo( const XF86VidModeModeInfo *mode)
58 {
59 int rate;
60 if (mode->htotal!=0 && mode->vtotal!=0)
61 rate = mode->dotclock * 1000 / (mode->htotal * mode->vtotal);
62 else
63 rate = 0;
64 X11DRV_Settings_AddOneMode(mode->hdisplay, mode->vdisplay, 0, rate);
65 }
66
67 static void convert_modeline(int dotclock, const XF86VidModeModeLine *mode, LPDDHALMODEINFO info, unsigned int bpp)
68 {
69 info->dwWidth = mode->hdisplay;
70 info->dwHeight = mode->vdisplay;
71 if (mode->htotal!=0 && mode->vtotal!=0)
72 info->wRefreshRate = dotclock * 1000 / (mode->htotal * mode->vtotal);
73 else
74 info->wRefreshRate = 0;
75 TRACE(" width=%d, height=%d, refresh=%d\n",
76 info->dwWidth, info->dwHeight, info->wRefreshRate);
77 info->lPitch = 0;
78 info->dwBPP = bpp;
79 info->wFlags = 0;
80 info->dwRBitMask = 0;
81 info->dwGBitMask = 0;
82 info->dwBBitMask = 0;
83 info->dwAlphaBitMask = 0;
84 }
85
86 static int XVidModeErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
87 {
88 return 1;
89 }
90
91 static int X11DRV_XF86VM_GetCurrentMode(void)
92 {
93 XF86VidModeModeLine line;
94 int dotclock;
95 unsigned int i;
96 DDHALMODEINFO cmode;
97 DWORD dwBpp = screen_bpp;
98
99 TRACE("Querying XVidMode current mode\n");
100 wine_tsx11_lock();
101 XF86VidModeGetModeLine(gdi_display, DefaultScreen(gdi_display), &dotclock, &line);
102 wine_tsx11_unlock();
103 convert_modeline(dotclock, &line, &cmode, dwBpp);
104 for (i=0; i<dd_mode_count; i++)
105 if (memcmp(&dd_modes[i], &cmode, sizeof(cmode)) == 0) {
106 TRACE("mode=%d\n", i);
107 return i;
108 }
109 ERR("In unknown mode, returning default\n");
110 return 0;
111 }
112
113 static LONG X11DRV_XF86VM_SetCurrentMode(int mode)
114 {
115 DWORD dwBpp = screen_bpp;
116 /* only set modes from the original color depth */
117 if (dwBpp != dd_modes[mode].dwBPP)
118 {
119 FIXME("Cannot change screen BPP from %d to %d\n", dwBpp, dd_modes[mode].dwBPP);
120 }
121 mode = mode % real_xf86vm_mode_count;
122
123 wine_tsx11_lock();
124 TRACE("Resizing X display to %dx%d\n",
125 real_xf86vm_modes[mode]->hdisplay, real_xf86vm_modes[mode]->vdisplay);
126 XF86VidModeSwitchToMode(gdi_display, DefaultScreen(gdi_display), real_xf86vm_modes[mode]);
127 #if 0 /* it is said that SetViewPort causes problems with some X servers */
128 XF86VidModeSetViewPort(gdi_display, DefaultScreen(gdi_display), 0, 0);
129 #else
130 XWarpPointer(gdi_display, None, DefaultRootWindow(gdi_display), 0, 0, 0, 0, 0, 0);
131 #endif
132 XSync(gdi_display, False);
133 wine_tsx11_unlock();
134 X11DRV_resize_desktop( real_xf86vm_modes[mode]->hdisplay, real_xf86vm_modes[mode]->vdisplay );
135 return DISP_CHANGE_SUCCESSFUL;
136 }
137
138 void X11DRV_XF86VM_Init(void)
139 {
140 Bool ok;
141 int nmodes;
142 unsigned int i;
143
144 if (xf86vm_major) return; /* already initialized? */
145
146 /* see if XVidMode is available */
147 wine_tsx11_lock();
148 ok = XF86VidModeQueryExtension(gdi_display, &xf86vm_event, &xf86vm_error);
149 if (ok)
150 {
151 X11DRV_expect_error(gdi_display, XVidModeErrorHandler, NULL);
152 ok = XF86VidModeQueryVersion(gdi_display, &xf86vm_major, &xf86vm_minor);
153 if (X11DRV_check_error()) ok = FALSE;
154 }
155 if (ok)
156 {
157 #ifdef X_XF86VidModeSetGammaRamp
158 if (xf86vm_major > 2 || (xf86vm_major == 2 && xf86vm_minor >= 1))
159 {
160 XF86VidModeGetGammaRampSize(gdi_display, DefaultScreen(gdi_display),
161 &xf86vm_gammaramp_size);
162 if (xf86vm_gammaramp_size == 256)
163 xf86vm_use_gammaramp = TRUE;
164 }
165 #endif /* X_XF86VidModeSetGammaRamp */
166
167 /* retrieve modes */
168 if (usexvidmode && root_window == DefaultRootWindow( gdi_display ))
169 ok = XF86VidModeGetAllModeLines(gdi_display, DefaultScreen(gdi_display), &nmodes, &real_xf86vm_modes);
170 else
171 ok = FALSE; /* In desktop mode, do not switch resolution... But still use the Gamma ramp stuff */
172 }
173 wine_tsx11_unlock();
174 if (!ok) return;
175
176 TRACE("XVidMode modes: count=%d\n", nmodes);
177
178 real_xf86vm_mode_count = nmodes;
179
180 dd_modes = X11DRV_Settings_SetHandlers("XF86VidMode",
181 X11DRV_XF86VM_GetCurrentMode,
182 X11DRV_XF86VM_SetCurrentMode,
183 nmodes, 1);
184
185 /* convert modes to DDHALMODEINFO format */
186 for (i=0; i<real_xf86vm_mode_count; i++)
187 {
188 convert_modeinfo(real_xf86vm_modes[i]);
189 }
190 /* add modes for different color depths */
191 X11DRV_Settings_AddDepthModes();
192 dd_mode_count = X11DRV_Settings_GetModeCount();
193
194 TRACE("Available DD modes: count=%d\n", dd_mode_count);
195 TRACE("Enabling XVidMode\n");
196 }
197
198 void X11DRV_XF86VM_Cleanup(void)
199 {
200 wine_tsx11_lock();
201 if (real_xf86vm_modes) XFree(real_xf86vm_modes);
202 wine_tsx11_unlock();
203 }
204
205 void X11DRV_XF86VM_SetExclusiveMode(int lock)
206 {
207 if (!dd_modes) return; /* no XVidMode */
208
209 wine_tsx11_lock();
210 XF86VidModeLockModeSwitch(gdi_display, DefaultScreen(gdi_display), lock);
211 wine_tsx11_unlock();
212 }
213
214 /***** GAMMA CONTROL *****/
215 /* (only available in XF86VidMode 2.x) */
216
217 #ifdef X_XF86VidModeSetGamma
218
219 static void GenerateRampFromGamma(WORD ramp[256], float gamma)
220 {
221 float r_gamma = 1/gamma;
222 unsigned i;
223 TRACE("gamma is %f\n", r_gamma);
224 for (i=0; i<256; i++)
225 ramp[i] = pow(i/255.0, r_gamma) * 65535.0;
226 }
227
228 static BOOL ComputeGammaFromRamp(WORD ramp[256], float *gamma)
229 {
230 float r_x, r_y, r_lx, r_ly, r_d, r_v, r_e, g_avg, g_min, g_max;
231 unsigned i, f, l, g_n, c;
232 f = ramp[0];
233 l = ramp[255];
234 if (f >= l) {
235 ERR("inverted or flat gamma ramp (%d->%d), rejected\n", f, l);
236 return FALSE;
237 }
238 r_d = l - f;
239 g_min = g_max = g_avg = 0.0;
240 /* check gamma ramp entries to estimate the gamma */
241 TRACE("analyzing gamma ramp (%d->%d)\n", f, l);
242 for (i=1, g_n=0; i<255; i++) {
243 if (ramp[i] < f || ramp[i] > l) {
244 ERR("strange gamma ramp ([%d]=%d for %d->%d), rejected\n", i, ramp[i], f, l);
245 return FALSE;
246 }
247 c = ramp[i] - f;
248 if (!c) continue; /* avoid log(0) */
249
250 /* normalize entry values into 0..1 range */
251 r_x = i/255.0; r_y = c / r_d;
252 /* compute logarithms of values */
253 r_lx = log(r_x); r_ly = log(r_y);
254 /* compute gamma for this entry */
255 r_v = r_ly / r_lx;
256 /* compute differential (error estimate) for this entry */
257 /* some games use table-based logarithms that magnifies the error by 128 */
258 r_e = -r_lx * 128 / (c * r_lx * r_lx);
259
260 /* compute min & max while compensating for estimated error */
261 if (!g_n || g_min > (r_v + r_e)) g_min = r_v + r_e;
262 if (!g_n || g_max < (r_v - r_e)) g_max = r_v - r_e;
263
264 /* add to average */
265 g_avg += r_v;
266 g_n++;
267 /* TRACE("[%d]=%d, gamma=%f, error=%f\n", i, ramp[i], r_v, r_e); */
268 }
269 if (!g_n) {
270 ERR("no gamma data, shouldn't happen\n");
271 return FALSE;
272 }
273 g_avg /= g_n;
274 TRACE("low bias is %d, high is %d, gamma is %5.3f\n", f, 65535-l, g_avg);
275 /* the bias could be because the app wanted something like a "red shift"
276 * like when you're hit in Quake, but XVidMode doesn't support it,
277 * so we have to reject a significant bias */
278 if (f && f > (pow(1/255.0, g_avg) * 65536.0)) {
279 ERR("low-biased gamma ramp (%d), rejected\n", f);
280 return FALSE;
281 }
282 /* check that the gamma is reasonably uniform across the ramp */
283 if (g_max - g_min > 0.1) {
284 ERR("ramp not uniform (max=%f, min=%f, avg=%f), rejected\n", g_max, g_min, g_avg);
285 return FALSE;
286 }
287 /* ok, now we're pretty sure we can set the desired gamma ramp,
288 * so go for it */
289 *gamma = 1/g_avg;
290 return TRUE;
291 }
292
293 #endif /* X_XF86VidModeSetGamma */
294
295 /* Hmm... should gamma control be available in desktop mode or not?
296 * I'll assume that it should */
297
298 BOOL X11DRV_XF86VM_GetGammaRamp(LPDDGAMMARAMP ramp)
299 {
300 #ifdef X_XF86VidModeSetGamma
301 XF86VidModeGamma gamma;
302 Bool ret;
303
304 if (xf86vm_major < 2) return FALSE; /* no gamma control */
305 #ifdef X_XF86VidModeSetGammaRamp
306 else if (xf86vm_use_gammaramp)
307 {
308 Bool ret;
309 wine_tsx11_lock();
310 ret = XF86VidModeGetGammaRamp(gdi_display, DefaultScreen(gdi_display), 256,
311 ramp->red, ramp->green, ramp->blue);
312 wine_tsx11_unlock();
313 return ret;
314 }
315 #endif
316 else
317 {
318 wine_tsx11_lock();
319 ret = XF86VidModeGetGamma(gdi_display, DefaultScreen(gdi_display), &gamma);
320 wine_tsx11_unlock();
321 if (ret) {
322 GenerateRampFromGamma(ramp->red, gamma.red);
323 GenerateRampFromGamma(ramp->green, gamma.green);
324 GenerateRampFromGamma(ramp->blue, gamma.blue);
325 return TRUE;
326 }
327 }
328 #endif /* X_XF86VidModeSetGamma */
329 return FALSE;
330 }
331
332 BOOL X11DRV_XF86VM_SetGammaRamp(LPDDGAMMARAMP ramp)
333 {
334 #ifdef X_XF86VidModeSetGamma
335 XF86VidModeGamma gamma;
336
337 if (xf86vm_major < 2) return FALSE; /* no gamma control */
338 #ifdef X_XF86VidModeSetGammaRamp
339 else if (xf86vm_use_gammaramp)
340 {
341 Bool ret;
342 wine_tsx11_lock();
343 ret = XF86VidModeSetGammaRamp(gdi_display, DefaultScreen(gdi_display), 256,
344 ramp->red, ramp->green, ramp->blue);
345 wine_tsx11_unlock();
346 return ret;
347 }
348 #endif
349 else
350 {
351 if (ComputeGammaFromRamp(ramp->red, &gamma.red) &&
352 ComputeGammaFromRamp(ramp->green, &gamma.green) &&
353 ComputeGammaFromRamp(ramp->blue, &gamma.blue)) {
354 Bool ret;
355 wine_tsx11_lock();
356 ret = XF86VidModeSetGamma(gdi_display, DefaultScreen(gdi_display), &gamma);
357 wine_tsx11_unlock();
358 return ret;
359 }
360 }
361 #endif /* X_XF86VidModeSetGamma */
362 return FALSE;
363 }
364
365 #endif /* HAVE_LIBXXF86VM */
366
367 /***********************************************************************
368 * GetDeviceGammaRamp (X11DRV.@)
369 *
370 * FIXME: should move to somewhere appropriate, but probably not before
371 * the stuff in graphics/x11drv/ has been moved to dlls/x11drv, so that
372 * they can include xvidmode.h directly
373 */
374 BOOL X11DRV_GetDeviceGammaRamp(X11DRV_PDEVICE *physDev, LPVOID ramp)
375 {
376 #ifdef HAVE_LIBXXF86VM
377 return X11DRV_XF86VM_GetGammaRamp(ramp);
378 #else
379 return FALSE;
380 #endif
381 }
382
383 /***********************************************************************
384 * SetDeviceGammaRamp (X11DRV.@)
385 *
386 * FIXME: should move to somewhere appropriate, but probably not before
387 * the stuff in graphics/x11drv/ has been moved to dlls/x11drv, so that
388 * they can include xvidmode.h directly
389 */
390 BOOL X11DRV_SetDeviceGammaRamp(X11DRV_PDEVICE *physDev, LPVOID ramp)
391 {
392 #ifdef HAVE_LIBXXF86VM
393 return X11DRV_XF86VM_SetGammaRamp(ramp);
394 #else
395 return FALSE;
396 #endif
397 }
398
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.