?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use 1 macro for rgbbitdepth -> byte determination.
[wine/wine64.git] / graphics / ddraw.c
blob297c8e2f3b4b11f3db8ee76fd7ceb9e93ec18f39
1 /* DirectDraw using DGA or Xlib(XSHM)
2 *
3 * Copyright 1997-1999 Marcus Meissner
4 * Copyright 1998 Lionel Ulmer (most of Direct3D stuff)
5 */
6 /* XF86DGA:
7 * When DirectVideo mode is enabled you can no longer use 'normal' X
8 * applications nor can you switch to a virtual console. Also, enabling
9 * only works, if you have switched to the screen where the application
10 * is running.
11 * Some ways to debug this stuff are:
12 * - A terminal connected to the serial port. Can be bought used for cheap.
13 * (This is the method I am using.)
14 * - Another machine connected over some kind of network.
15 */
16
17 #include "config.h"
18
19 #ifndef X_DISPLAY_MISSING
20
21 #include "ts_xlib.h"
22 #include "ts_xutil.h"
23
24 #ifdef HAVE_LIBXXSHM
25 #include <sys/types.h>
26 #include <sys/ipc.h>
27 #include <sys/shm.h>
28 #include "ts_xshm.h"
29 #endif /* defined(HAVE_LIBXXSHM) */
30
31 #ifdef HAVE_LIBXXF86DGA
32 #include "ts_xf86dga.h"
33 #endif /* defined(HAVE_LIBXXF86DGA) */
34
35 #ifdef HAVE_LIBXXF86VM
36 #include "ts_xf86vmode.h"
37 #endif /* defined(HAVE_LIBXXF86VM) */
38
39 #include "x11drv.h"
40
41 #include <unistd.h>
42 #include <assert.h>
43 #include <sys/signal.h>
44 #include <fcntl.h>
45 #include <string.h>
46 #include <stdlib.h>
47
48 #include "winerror.h"
49 #include "gdi.h"
50 #include "heap.h"
51 #include "dc.h"
52 #include "win.h"
53 #include "wine/exception.h"
54 #include "ddraw.h"
55 #include "d3d.h"
56 #include "debugtools.h"
57 #include "spy.h"
58 #include "message.h"
59 #include "options.h"
60 #include "monitor.h"
61
62 /* This for all the enumeration and creation of D3D-related objects */
63 #include "ddraw_private.h"
64 #include "d3d_private.h"
65
66 DEFAULT_DEBUG_CHANNEL(ddraw)
67
68 /* Restore signal handlers overwritten by XF86DGA
69 */
70 #define RESTORE_SIGNALS
71
72 /* Get DDSCAPS of surface (shortcutmacro) */
73 #define SDDSCAPS(iface) ((iface)->s.surface_desc.ddsCaps.dwCaps)
74
75 /* Get the number of bytes per pixel for a given surface */
76 #define PFGET_BPP(pf) (pf.dwFlags&DDPF_PALETTEINDEXED8?1:(pf.x.dwRGBBitCount/8))
77
78 #define GET_BPP(desc) PFGET_BPP(desc.ddpfPixelFormat)
79
80 /* Where do these GUIDs come from? mkuuid.
81 * They exist solely to distinguish between the targets Wine support,
82 * and should be different than any other GUIDs in existence.
83 */
84 static GUID DGA_DirectDraw_GUID = { /* e2dcb020-dc60-11d1-8407-9714f5d50802 */
85 0xe2dcb020,
86 0xdc60,
87 0x11d1,
88 {0x84, 0x07, 0x97, 0x14, 0xf5, 0xd5, 0x08, 0x02}
89 };
90
91 static GUID XLIB_DirectDraw_GUID = { /* 1574a740-dc61-11d1-8407-f7875a7d1879 */
92 0x1574a740,
93 0xdc61,
94 0x11d1,
95 {0x84, 0x07, 0xf7, 0x87, 0x5a, 0x7d, 0x18, 0x79}
96 };
97
98 #ifdef HAVE_LIBXXF86DGA
99 static struct ICOM_VTABLE(IDirectDrawSurface4) dga_dds4vt;
100 static struct ICOM_VTABLE(IDirectDraw) dga_ddvt;
101 static struct ICOM_VTABLE(IDirectDraw2) dga_dd2vt;
102 static struct ICOM_VTABLE(IDirectDraw4) dga_dd4vt;
103 static struct ICOM_VTABLE(IDirectDrawPalette) dga_ddpalvt;
104 #endif /* defined(HAVE_LIBXXF86DGA) */
105
106 static struct ICOM_VTABLE(IDirectDrawSurface4) xlib_dds4vt;
107 static struct ICOM_VTABLE(IDirectDraw) xlib_ddvt;
108 static struct ICOM_VTABLE(IDirectDraw2) xlib_dd2vt;
109 static struct ICOM_VTABLE(IDirectDraw4) xlib_dd4vt;
110 static struct ICOM_VTABLE(IDirectDrawPalette) xlib_ddpalvt;
111
112 static struct ICOM_VTABLE(IDirectDrawClipper) ddclipvt;
113 static struct ICOM_VTABLE(IDirect3D) d3dvt;
114 static struct ICOM_VTABLE(IDirect3D2) d3d2vt;
115
116 /* This is for mode-emulation */
117
118 static void pixel_convert_16_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) ;
119 static void palette_convert_16_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) ;
120 static void palette_convert_15_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) ;
121 static void pixel_convert_24_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) ;
122 static void pixel_convert_32_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) ;
123 static void palette_convert_24_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) ;
124 static void pixel_convert_32_to_16(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) ;
125
126 typedef struct {
127 unsigned short bpp;
128 unsigned short depth;
129 unsigned int rmask;
130 unsigned int gmask;
131 unsigned int bmask;
132 } ConvertMode;
133
134 typedef struct {
135 void (*pixel_convert)(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette);
136 void (*palette_convert)(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count);
137 } ConvertFuncs;
138
139 typedef struct {
140 ConvertMode screen, dest;
141 ConvertFuncs funcs;
142 } Convert;
143
144 static Convert ModeEmulations[] = {
145 { { 32, 24, 0x00FF0000, 0x0000FF00, 0x000000FF }, { 8, 8, 0x00, 0x00, 0x00 }, { pixel_convert_32_to_8, palette_convert_24_to_8 } },
146 { { 32, 24, 0x00FF0000, 0x0000FF00, 0x000000FF }, { 16, 16, 0xF800, 0x07E0, 0x001F }, { pixel_convert_32_to_16, NULL } },
147 { { 24, 24, 0xFF0000, 0x00FF00, 0x0000FF }, { 8, 8, 0x00, 0x00, 0x00 }, { pixel_convert_24_to_8, palette_convert_24_to_8 } },
148 { { 16, 16, 0xF800, 0x07E0, 0x001F }, { 8, 8, 0x00, 0x00, 0x00 }, { pixel_convert_16_to_8, palette_convert_16_to_8 } },
149 { { 16, 15, 0x7C00, 0x03E0, 0x001F }, { 8, 8, 0x00, 0x00, 0x00 }, { pixel_convert_16_to_8, palette_convert_15_to_8 } },
150 };
151
152 #ifdef HAVE_LIBXXF86VM
153 static XF86VidModeModeInfo *orig_mode = NULL;
154 #endif
155
156 #ifdef HAVE_LIBXXSHM
157 static int XShmErrorFlag = 0;
158 #endif
159
160 static BOOL
161 DDRAW_DGA_Available(void)
162 {
163 #ifdef HAVE_LIBXXF86DGA
164 int evbase, evret, fd;
165
166 if (Options.noDGA)
167 return 0;
168
169 /* You don't have to be root to use DGA extensions. Simply having access to /dev/mem will do the trick */
170 /* This can be achieved by adding the user to the "kmem" group on Debian 2.x systems, don't know about */
171 /* others. --stephenc */
172 if ((fd = open("/dev/mem", O_RDWR)) != -1)
173 close(fd);
174
175 return (fd != -1) && TSXF86DGAQueryExtension(display,&evbase,&evret);
176 #else /* defined(HAVE_LIBXXF86DGA) */
177 return 0;
178 #endif /* defined(HAVE_LIBXXF86DGA) */
179 }
180
181 /**********************************************************************/
182
183 typedef struct {
184 LPVOID lpCallback;
185 LPVOID lpContext;
186 } DirectDrawEnumerateProcData;
187
188 /***********************************************************************
189 * DirectDrawEnumerateExA (DDRAW.*)
190 */
191 HRESULT WINAPI DirectDrawEnumerateExA(
192 LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
193 {
194 TRACE("(%p,%p, %08lx)\n", lpCallback, lpContext, dwFlags);
195
196 if (TRACE_ON(ddraw)) {
197 DPRINTF(" Flags : ");
198 if (dwFlags & DDENUM_ATTACHEDSECONDARYDEVICES)
199 DPRINTF("DDENUM_ATTACHEDSECONDARYDEVICES ");
200 if (dwFlags & DDENUM_DETACHEDSECONDARYDEVICES)
201 DPRINTF("DDENUM_DETACHEDSECONDARYDEVICES ");
202 if (dwFlags & DDENUM_NONDISPLAYDEVICES)
203 DPRINTF("DDENUM_NONDISPLAYDEVICES ");
204 DPRINTF("\n");
205 }
206
207 if (dwFlags == DDENUM_NONDISPLAYDEVICES) {
208 /* For the moment, Wine does not support any 3D only accelerators */
209 return DD_OK;
210 }
211
212 if (DDRAW_DGA_Available()) {
213 TRACE("Enumerating DGA interface\n");
214 if (!lpCallback(&DGA_DirectDraw_GUID, "WINE with XFree86 DGA", "display", lpContext, 0))
215 return DD_OK;
216 }
217
218 TRACE("Enumerating Xlib interface\n");
219 if (!lpCallback(&XLIB_DirectDraw_GUID, "WINE with Xlib", "display", lpContext, 0))
220 return DD_OK;
221
222 TRACE("Enumerating Default interface\n");
223 if (!lpCallback(NULL,"WINE (default)", "display", lpContext, 0))
224 return DD_OK;
225
226 return DD_OK;
227 }
228
229 /***********************************************************************
230 * DirectDrawEnumerateExW (DDRAW.*)
231 */
232
233 static BOOL CALLBACK DirectDrawEnumerateExProcW(
234 GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
235 LPVOID lpContext, HMONITOR hm)
236 {
237 DirectDrawEnumerateProcData *pEPD =
238 (DirectDrawEnumerateProcData *) lpContext;
239 LPWSTR lpDriverDescriptionW =
240 HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverDescription);
241 LPWSTR lpDriverNameW =
242 HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverName);
243
244 BOOL bResult = (*(LPDDENUMCALLBACKEXW *) pEPD->lpCallback)(
245 lpGUID, lpDriverDescriptionW, lpDriverNameW, pEPD->lpContext, hm);
246
247 HeapFree(GetProcessHeap(), 0, lpDriverDescriptionW);
248 HeapFree(GetProcessHeap(), 0, lpDriverNameW);
249
250 return bResult;
251 }
252
253 /**********************************************************************/
254
255 HRESULT WINAPI DirectDrawEnumerateExW(
256 LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
257 {
258 DirectDrawEnumerateProcData epd;
259 epd.lpCallback = (LPVOID) lpCallback;
260 epd.lpContext = lpContext;
261
262 return DirectDrawEnumerateExA(DirectDrawEnumerateExProcW,
263 (LPVOID) &epd, 0);
264 }
265
266 /***********************************************************************
267 * DirectDrawEnumerateA (DDRAW.*)
268 */
269
270 static BOOL CALLBACK DirectDrawEnumerateProcA(
271 GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
272 LPVOID lpContext, HMONITOR hm)
273 {
274 DirectDrawEnumerateProcData *pEPD =
275 (DirectDrawEnumerateProcData *) lpContext;
276
277 return ((LPDDENUMCALLBACKA) pEPD->lpCallback)(
278 lpGUID, lpDriverDescription, lpDriverName, pEPD->lpContext);
279 }
280
281 /**********************************************************************/
282
283 HRESULT WINAPI DirectDrawEnumerateA(
284 LPDDENUMCALLBACKA lpCallback, LPVOID lpContext)
285 {
286 DirectDrawEnumerateProcData epd;
287 epd.lpCallback = (LPVOID) lpCallback;
288 epd.lpContext = lpContext;
289
290 return DirectDrawEnumerateExA(DirectDrawEnumerateProcA,
291 (LPVOID) &epd, 0);
292 }
293
294 /***********************************************************************
295 * DirectDrawEnumerateW (DDRAW.*)
296 */
297
298 static BOOL WINAPI DirectDrawEnumerateProcW(
299 GUID *lpGUID, LPWSTR lpDriverDescription, LPWSTR lpDriverName,
300 LPVOID lpContext, HMONITOR hm)
301 {
302 DirectDrawEnumerateProcData *pEPD =
303 (DirectDrawEnumerateProcData *) lpContext;
304
305 return ((LPDDENUMCALLBACKW) pEPD->lpCallback)(
306 lpGUID, lpDriverDescription, lpDriverName,
307 pEPD->lpContext);
308 }
309
310 /**********************************************************************/
311
312 HRESULT WINAPI DirectDrawEnumerateW(
313 LPDDENUMCALLBACKW lpCallback, LPVOID lpContext)
314 {
315 DirectDrawEnumerateProcData epd;
316 epd.lpCallback = (LPVOID) lpCallback;
317 epd.lpContext = lpContext;
318
319 return DirectDrawEnumerateExW(DirectDrawEnumerateProcW,
320 (LPVOID) &epd, 0);
321 }
322
323 /***********************************************************************
324 * DSoundHelp (DDRAW.?)
325 */
326
327 /* What is this doing here? */
328 HRESULT WINAPI
329 DSoundHelp(DWORD x,DWORD y,DWORD z) {
330 FIXME("(0x%08lx,0x%08lx,0x%08lx),stub!\n",x,y,z);
331 return 0;
332 }
333
334 /******************************************************************************
335 * internal helper functions
336 */
337 static void _dump_DDBLTFX(DWORD flagmask) {
338 int i;
339 const struct {
340 DWORD mask;
341 char *name;
342 } flags[] = {
343 #define FE(x) { x, #x},
344 FE(DDBLTFX_ARITHSTRETCHY)
345 FE(DDBLTFX_MIRRORLEFTRIGHT)
346 FE(DDBLTFX_MIRRORUPDOWN)
347 FE(DDBLTFX_NOTEARING)
348 FE(DDBLTFX_ROTATE180)
349 FE(DDBLTFX_ROTATE270)
350 FE(DDBLTFX_ROTATE90)
351 FE(DDBLTFX_ZBUFFERRANGE)
352 FE(DDBLTFX_ZBUFFERBASEDEST)
353 #undef FE
354 };
355 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
356 if (flags[i].mask & flagmask) {
357 DPRINTF("%s ",flags[i].name);
358
359 };
360 DPRINTF("\n");
361
362 }
363
364 static void _dump_DDBLTFAST(DWORD flagmask) {
365 int i;
366 const struct {
367 DWORD mask;
368 char *name;
369 } flags[] = {
370 #define FE(x) { x, #x},
371 FE(DDBLTFAST_NOCOLORKEY)
372 FE(DDBLTFAST_SRCCOLORKEY)
373 FE(DDBLTFAST_DESTCOLORKEY)
374 FE(DDBLTFAST_WAIT)
375 #undef FE
376 };
377 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
378 if (flags[i].mask & flagmask)
379 DPRINTF("%s ",flags[i].name);
380 DPRINTF("\n");
381 }
382
383 static void _dump_DDBLT(DWORD flagmask) {
384 int i;
385 const struct {
386 DWORD mask;
387 char *name;
388 } flags[] = {
389 #define FE(x) { x, #x},
390 FE(DDBLT_ALPHADEST)
391 FE(DDBLT_ALPHADESTCONSTOVERRIDE)
392 FE(DDBLT_ALPHADESTNEG)
393 FE(DDBLT_ALPHADESTSURFACEOVERRIDE)
394 FE(DDBLT_ALPHAEDGEBLEND)
395 FE(DDBLT_ALPHASRC)
396 FE(DDBLT_ALPHASRCCONSTOVERRIDE)
397 FE(DDBLT_ALPHASRCNEG)
398 FE(DDBLT_ALPHASRCSURFACEOVERRIDE)
399 FE(DDBLT_ASYNC)
400 FE(DDBLT_COLORFILL)
401 FE(DDBLT_DDFX)
402 FE(DDBLT_DDROPS)
403 FE(DDBLT_KEYDEST)
404 FE(DDBLT_KEYDESTOVERRIDE)
405 FE(DDBLT_KEYSRC)
406 FE(DDBLT_KEYSRCOVERRIDE)
407 FE(DDBLT_ROP)
408 FE(DDBLT_ROTATIONANGLE)
409 FE(DDBLT_ZBUFFER)
410 FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE)
411 FE(DDBLT_ZBUFFERDESTOVERRIDE)
412 FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE)
413 FE(DDBLT_ZBUFFERSRCOVERRIDE)
414 FE(DDBLT_WAIT)
415 FE(DDBLT_DEPTHFILL)
416 #undef FE
417 };
418 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
419 if (flags[i].mask & flagmask)
420 DPRINTF("%s ",flags[i].name);
421 DPRINTF("\n");
422 }
423
424 static void _dump_DDSCAPS(void *in) {
425 int i;
426 const struct {
427 DWORD mask;
428 char *name;
429 } flags[] = {
430 #define FE(x) { x, #x},
431 FE(DDSCAPS_RESERVED1)
432 FE(DDSCAPS_ALPHA)
433 FE(DDSCAPS_BACKBUFFER)
434 FE(DDSCAPS_COMPLEX)
435 FE(DDSCAPS_FLIP)
436 FE(DDSCAPS_FRONTBUFFER)
437 FE(DDSCAPS_OFFSCREENPLAIN)
438 FE(DDSCAPS_OVERLAY)
439 FE(DDSCAPS_PALETTE)
440 FE(DDSCAPS_PRIMARYSURFACE)
441 FE(DDSCAPS_PRIMARYSURFACELEFT)
442 FE(DDSCAPS_SYSTEMMEMORY)
443 FE(DDSCAPS_TEXTURE)
444 FE(DDSCAPS_3DDEVICE)
445 FE(DDSCAPS_VIDEOMEMORY)
446 FE(DDSCAPS_VISIBLE)
447 FE(DDSCAPS_WRITEONLY)
448 FE(DDSCAPS_ZBUFFER)
449 FE(DDSCAPS_OWNDC)
450 FE(DDSCAPS_LIVEVIDEO)
451 FE(DDSCAPS_HWCODEC)
452 FE(DDSCAPS_MODEX)
453 FE(DDSCAPS_MIPMAP)
454 FE(DDSCAPS_RESERVED2)
455 FE(DDSCAPS_ALLOCONLOAD)
456 FE(DDSCAPS_VIDEOPORT)
457 FE(DDSCAPS_LOCALVIDMEM)
458 FE(DDSCAPS_NONLOCALVIDMEM)
459 FE(DDSCAPS_STANDARDVGAMODE)
460 FE(DDSCAPS_OPTIMIZED)
461 #undef FE
462 };
463 DWORD flagmask = *((DWORD *) in);
464 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
465 if (flags[i].mask & flagmask)
466 DPRINTF("%s ",flags[i].name);
467 }
468
469 static void _dump_pixelformat_flag(DWORD flagmask) {
470 int i;
471 const struct {
472 DWORD mask;
473 char *name;
474 } flags[] = {
475 #define FE(x) { x, #x},
476 FE(DDPF_ALPHAPIXELS)
477 FE(DDPF_ALPHA)
478 FE(DDPF_FOURCC)
479 FE(DDPF_PALETTEINDEXED4)
480 FE(DDPF_PALETTEINDEXEDTO8)
481 FE(DDPF_PALETTEINDEXED8)
482 FE(DDPF_RGB)
483 FE(DDPF_COMPRESSED)
484 FE(DDPF_RGBTOYUV)
485 FE(DDPF_YUV)
486 FE(DDPF_ZBUFFER)
487 FE(DDPF_PALETTEINDEXED1)
488 FE(DDPF_PALETTEINDEXED2)
489 FE(DDPF_ZPIXELS)
490 #undef FE
491 };
492 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
493 if (flags[i].mask & flagmask)
494 DPRINTF("%s ",flags[i].name);
495 }
496
497 static void _dump_paletteformat(DWORD dwFlags) {
498 int i;
499 const struct {
500 DWORD mask;
501 char *name;
502 } flags[] = {
503 #define FE(x) { x, #x},
504 FE(DDPCAPS_4BIT)
505 FE(DDPCAPS_8BITENTRIES)
506 FE(DDPCAPS_8BIT)
507 FE(DDPCAPS_INITIALIZE)
508 FE(DDPCAPS_PRIMARYSURFACE)
509 FE(DDPCAPS_PRIMARYSURFACELEFT)
510 FE(DDPCAPS_ALLOW256)
511 FE(DDPCAPS_VSYNC)
512 FE(DDPCAPS_1BIT)
513 FE(DDPCAPS_2BIT)
514 FE(DDPCAPS_ALPHA)
515 #undef FE
516 };
517 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
518 if (flags[i].mask & dwFlags)
519 DPRINTF("%s ",flags[i].name);
520 DPRINTF("\n");
521 }
522
523 static void _dump_pixelformat(void *in) {
524 LPDDPIXELFORMAT pf = (LPDDPIXELFORMAT) in;
525 char *cmd;
526
527 DPRINTF("( ");
528 _dump_pixelformat_flag(pf->dwFlags);
529 if (pf->dwFlags & DDPF_FOURCC) {
530 DPRINTF(", dwFourCC : %ld", pf->dwFourCC);
531 }
532 if (pf->dwFlags & DDPF_RGB) {
533 DPRINTF(", RGB bits: %ld, ", pf->x.dwRGBBitCount);
534 switch (pf->x.dwRGBBitCount) {
535 case 4:
536 cmd = "%1lx";
537 break;
538 case 8:
539 cmd = "%02lx";
540 break;
541 case 16:
542 cmd = "%04lx";
543 break;
544 case 24:
545 cmd = "%06lx";
546 break;
547 case 32:
548 cmd = "%08lx";
549 break;
550 default:
551 ERR("Unexpected bit depth !\n");
552 cmd = "%d";
553 }
554 DPRINTF(" R "); DPRINTF(cmd, pf->y.dwRBitMask);
555 DPRINTF(" G "); DPRINTF(cmd, pf->z.dwGBitMask);
556 DPRINTF(" B "); DPRINTF(cmd, pf->xx.dwBBitMask);
557 if (pf->dwFlags & DDPF_ALPHAPIXELS) {
558 DPRINTF(" A "); DPRINTF(cmd, pf->xy.dwRGBAlphaBitMask);
559 }
560 if (pf->dwFlags & DDPF_ZPIXELS) {
561 DPRINTF(" Z "); DPRINTF(cmd, pf->xy.dwRGBZBitMask);
562 }
563 }
564 if (pf->dwFlags & DDPF_ZBUFFER) {
565 DPRINTF(", Z bits : %ld", pf->x.dwZBufferBitDepth);
566 }
567 if (pf->dwFlags & DDPF_ALPHA) {
568 DPRINTF(", Alpha bits : %ld", pf->x.dwAlphaBitDepth);
569 }
570 DPRINTF(")");
571 }
572
573 static void _dump_colorkeyflag(DWORD ck) {
574 int i;
575 const struct {
576 DWORD mask;
577 char *name;
578 } flags[] = {
579 #define FE(x) { x, #x},
580 FE(DDCKEY_COLORSPACE)
581 FE(DDCKEY_DESTBLT)
582 FE(DDCKEY_DESTOVERLAY)
583 FE(DDCKEY_SRCBLT)
584 FE(DDCKEY_SRCOVERLAY)
585 #undef FE
586 };
587 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
588 if (flags[i].mask & ck)
589 DPRINTF("%s ",flags[i].name);
590 }
591
592 static void _dump_DWORD(void *in) {
593 DPRINTF("%ld", *((DWORD *) in));
594 }
595 static void _dump_PTR(void *in) {
596 DPRINTF("%p", *((void **) in));
597 }
598 static void _dump_DDCOLORKEY(void *in) {
599 DDCOLORKEY *ddck = (DDCOLORKEY *) in;
600
601 DPRINTF(" Low : %ld - High : %ld", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
602 }
603
604 static void _dump_surface_desc(DDSURFACEDESC *lpddsd) {
605 int i;
606 struct {
607 DWORD mask;
608 char *name;
609 void (*func)(void *);
610 void *elt;
611 } flags[16], *fe = flags;
612 #define FE(x,f,e) do { fe->mask = x; fe->name = #x; fe->func = f; fe->elt = (void *) &(lpddsd->e); fe++; } while(0)
613 FE(DDSD_CAPS, _dump_DDSCAPS, ddsCaps);
614 FE(DDSD_HEIGHT, _dump_DWORD, dwHeight);
615 FE(DDSD_WIDTH, _dump_DWORD, dwWidth);
616 FE(DDSD_PITCH, _dump_DWORD, lPitch);
617 FE(DDSD_BACKBUFFERCOUNT, _dump_DWORD, dwBackBufferCount);
618 FE(DDSD_ZBUFFERBITDEPTH, _dump_DWORD, x.dwZBufferBitDepth);
619 FE(DDSD_ALPHABITDEPTH, _dump_DWORD, dwAlphaBitDepth);
620 FE(DDSD_PIXELFORMAT, _dump_pixelformat, ddpfPixelFormat);
621 FE(DDSD_CKDESTOVERLAY, _dump_DDCOLORKEY, ddckCKDestOverlay);
622 FE(DDSD_CKDESTBLT, _dump_DDCOLORKEY, ddckCKDestBlt);
623 FE(DDSD_CKSRCOVERLAY, _dump_DDCOLORKEY, ddckCKSrcOverlay);
624 FE(DDSD_CKSRCBLT, _dump_DDCOLORKEY, ddckCKSrcBlt);
625 FE(DDSD_MIPMAPCOUNT, _dump_DWORD, x.dwMipMapCount);
626 FE(DDSD_REFRESHRATE, _dump_DWORD, x.dwRefreshRate);
627 FE(DDSD_LINEARSIZE, _dump_DWORD, y.dwLinearSize);
628 FE(DDSD_LPSURFACE, _dump_PTR, y.lpSurface);
629 #undef FE
630
631 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
632 if (flags[i].mask & lpddsd->dwFlags) {
633 DPRINTF(" - %s : ",flags[i].name);
634 flags[i].func(flags[i].elt);
635 DPRINTF("\n");
636 }
637 }
638
639
640 /******************************************************************************
641 * IDirectDrawSurface methods
642 *
643 * Since DDS3 and DDS2 are supersets of DDS, we implement DDS3 and let
644 * DDS and DDS2 use those functions. (Function calls did not change (except
645 * using different DirectDrawSurfaceX version), just added flags and functions)
646 */
647
648 static HRESULT WINAPI IDirectDrawSurface4Impl_Lock(
649 LPDIRECTDRAWSURFACE4 iface,LPRECT lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE hnd
650 ) {
651 ICOM_THIS(IDirectDrawSurface4Impl,iface);
652 TRACE("(%p)->Lock(%p,%p,%08lx,%08lx)\n",
653 This,lprect,lpddsd,flags,(DWORD)hnd);
654 if (flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY))
655 WARN("(%p)->Lock(%p,%p,%08lx,%08lx)\n",
656 This,lprect,lpddsd,flags,(DWORD)hnd);
657
658 /* First, copy the Surface description */
659 *lpddsd = This->s.surface_desc;
660 TRACE("locked surface: height=%ld, width=%ld, pitch=%ld\n",
661 lpddsd->dwHeight,lpddsd->dwWidth,lpddsd->lPitch);
662
663 /* If asked only for a part, change the surface pointer */
664 if (lprect) {
665 TRACE(" lprect: %dx%d-%dx%d\n",
666 lprect->top,lprect->left,lprect->bottom,lprect->right
667 );
668 if ((lprect->top < 0) ||
669 (lprect->left < 0) ||
670 (lprect->bottom < 0) ||
671 (lprect->right < 0)) {
672 ERR(" Negative values in LPRECT !!!\n");
673 return DDERR_INVALIDPARAMS;
674 }
675
676 lpddsd->y.lpSurface = (LPVOID) ((char *) This->s.surface_desc.y.lpSurface +
677 (lprect->top*This->s.surface_desc.lPitch) +
678 lprect->left*GET_BPP(This->s.surface_desc));
679 } else {
680 assert(This->s.surface_desc.y.lpSurface);
681 }
682 return DD_OK;
683 }
684
685 #ifdef HAVE_LIBXXF86DGA
686 static HRESULT WINAPI DGA_IDirectDrawSurface4Impl_Unlock(
687 LPDIRECTDRAWSURFACE4 iface,LPVOID surface
688 ) {
689 ICOM_THIS(IDirectDrawSurface4Impl,iface);
690 TRACE("(%p)->Unlock(%p)\n",This,surface);
691 return DD_OK;
692 }
693 #endif /* defined(HAVE_LIBXXF86DGA) */
694
695 static void Xlib_copy_surface_on_screen(IDirectDrawSurface4Impl* This) {
696 if (This->s.ddraw->d.pixel_convert != NULL)
697 This->s.ddraw->d.pixel_convert(This->s.surface_desc.y.lpSurface,
698 This->t.xlib.image->data,
699 This->s.surface_desc.dwWidth,
700 This->s.surface_desc.dwHeight,
701 This->s.surface_desc.lPitch,
702 This->s.palette);
703
704 #ifdef HAVE_LIBXXSHM
705 if (This->s.ddraw->e.xlib.xshm_active)
706 TSXShmPutImage(display,
707 This->s.ddraw->d.drawable,
708 DefaultGCOfScreen(X11DRV_GetXScreen()),
709 This->t.xlib.image,
710 0, 0, 0, 0,
711 This->t.xlib.image->width,
712 This->t.xlib.image->height,
713 False);
714 else
715 #endif
716 TSXPutImage( display,
717 This->s.ddraw->d.drawable,
718 DefaultGCOfScreen(X11DRV_GetXScreen()),
719 This->t.xlib.image,
720 0, 0, 0, 0,
721 This->t.xlib.image->width,
722 This->t.xlib.image->height);
723 }
724
725 static HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_Unlock(
726 LPDIRECTDRAWSURFACE4 iface,LPVOID surface)
727 {
728 ICOM_THIS(IDirectDrawSurface4Impl,iface);
729 TRACE("(%p)->Unlock(%p)\n",This,surface);
730
731 if (!This->s.ddraw->d.paintable)
732 return DD_OK;
733
734 /* Only redraw the screen when unlocking the buffer that is on screen */
735 if (This->t.xlib.image && (SDDSCAPS(This) & DDSCAPS_VISIBLE)) {
736 Xlib_copy_surface_on_screen(This);
737
738 if (This->s.palette && This->s.palette->cm)
739 TSXSetWindowColormap(display,This->s.ddraw->d.drawable,This->s.palette->cm);
740 }
741 return DD_OK;
742 }
743
744 static IDirectDrawSurface4Impl* _common_find_flipto(
745 IDirectDrawSurface4Impl* This,IDirectDrawSurface4Impl* flipto
746 ) {
747 int i,j,flipable=0;
748 struct _surface_chain *chain = This->s.chain;
749
750 /* if there was no override flipto, look for current backbuffer */
751 if (!flipto) {
752 /* walk the flip chain looking for backbuffer */
753 for (i=0;i<chain->nrofsurfaces;i++) {
754 if (SDDSCAPS(chain->surfaces[i]) & DDSCAPS_FLIP)
755 flipable++;
756 if (SDDSCAPS(chain->surfaces[i]) & DDSCAPS_BACKBUFFER)
757 flipto = chain->surfaces[i];
758 }
759 /* sanity checks ... */
760 if (!flipto) {
761 if (flipable>1) {
762 for (i=0;i<chain->nrofsurfaces;i++)
763 if (SDDSCAPS(chain->surfaces[i]) & DDSCAPS_FRONTBUFFER)
764 break;
765 if (i==chain->nrofsurfaces) {
766 /* we do not have a frontbuffer either */
767 for (i=0;i<chain->nrofsurfaces;i++)
768 if (SDDSCAPS(chain->surfaces[i]) & DDSCAPS_FLIP) {
769 SDDSCAPS(chain->surfaces[i])|=DDSCAPS_FRONTBUFFER;
770 break;
771 }
772 for (j=i+1;j<i+chain->nrofsurfaces+1;j++) {
773 int k = j % chain->nrofsurfaces;
774 if (SDDSCAPS(chain->surfaces[k]) & DDSCAPS_FLIP) {
775 SDDSCAPS(chain->surfaces[k])|=DDSCAPS_BACKBUFFER;
776 flipto = chain->surfaces[k];
777 break;
778 }
779 }
780 }
781 }
782 if (!flipto)
783 flipto = This;
784 }
785 TRACE("flipping to %p\n",flipto);
786 }
787 return flipto;
788 }
789
790 #ifdef HAVE_LIBXXF86DGA
791 static HRESULT WINAPI DGA_IDirectDrawSurface4Impl_Flip(
792 LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWSURFACE4 flipto,DWORD dwFlags
793 ) {
794 ICOM_THIS(IDirectDrawSurface4Impl,iface);
795 IDirectDrawSurface4Impl* iflipto=(IDirectDrawSurface4Impl*)flipto;
796 DWORD xheight;
797 LPBYTE surf;
798
799 TRACE("(%p)->Flip(%p,%08lx)\n",This,iflipto,dwFlags);
800 iflipto = _common_find_flipto(This,iflipto);
801
802 /* and flip! */
803 TSXF86DGASetViewPort(display,DefaultScreen(display),0,iflipto->t.dga.fb_height);
804 if (iflipto->s.palette && iflipto->s.palette->cm)
805 TSXF86DGAInstallColormap(display,DefaultScreen(display),iflipto->s.palette->cm);
806 while (!TSXF86DGAViewPortChanged(display,DefaultScreen(display),2)) {
807
808 }
809 /* We need to switch the lowlevel surfaces, for DGA this is: */
810
811 /* The height within the framebuffer */
812 xheight = This->t.dga.fb_height;
813 This->t.dga.fb_height = iflipto->t.dga.fb_height;
814 iflipto->t.dga.fb_height = xheight;
815
816 /* And the assciated surface pointer */
817 surf = This->s.surface_desc.y.lpSurface;
818 This->s.surface_desc.y.lpSurface = iflipto->s.surface_desc.y.lpSurface;
819 iflipto->s.surface_desc.y.lpSurface = surf;
820
821 return DD_OK;
822 }
823 #endif /* defined(HAVE_LIBXXF86DGA) */
824
825 static HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_Flip(
826 LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWSURFACE4 flipto,DWORD dwFlags
827 ) {
828 ICOM_THIS(IDirectDrawSurface4Impl,iface);
829 XImage *image;
830 LPBYTE surf;
831 IDirectDrawSurface4Impl* iflipto=(IDirectDrawSurface4Impl*)flipto;
832
833 TRACE("(%p)->Flip(%p,%08lx)\n",This,iflipto,dwFlags);
834 iflipto = _common_find_flipto(This,iflipto);
835
836 #if defined(HAVE_MESAGL) && 0 /* does not work */
837 if (This->s.d3d_device || (iflipto && iflipto->s.d3d_device)) {
838 TRACE(" - OpenGL flip\n");
839 ENTER_GL();
840 glXSwapBuffers(display, This->s.ddraw->d.drawable);
841 LEAVE_GL();
842
843 return DD_OK;
844 }
845 #endif /* defined(HAVE_MESAGL) */
846
847 if (!This->s.ddraw->d.paintable)
848 return DD_OK;
849
850 /* We need to switch the lowlevel surfaces, for xlib this is: */
851 /* The surface pointer */
852 surf = This->s.surface_desc.y.lpSurface;
853 This->s.surface_desc.y.lpSurface = iflipto->s.surface_desc.y.lpSurface;
854 iflipto->s.surface_desc.y.lpSurface = surf;
855 /* the associated ximage */
856 image = This->t.xlib.image;
857 This->t.xlib.image = iflipto->t.xlib.image;
858 iflipto->t.xlib.image = image;
859
860 Xlib_copy_surface_on_screen(This);
861
862 if (iflipto->s.palette && iflipto->s.palette->cm)
863 TSXSetWindowColormap(display,This->s.ddraw->d.drawable,iflipto->s.palette->cm);
864 return DD_OK;
865 }
866
867 /* The IDirectDrawSurface4::SetPalette method attaches the specified
868 * DirectDrawPalette object to a surface. The surface uses this palette for all
869 * subsequent operations. The palette change takes place immediately.
870 */
871 static HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_SetPalette(
872 LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWPALETTE pal
873 ) {
874 ICOM_THIS(IDirectDrawSurface4Impl,iface);
875 IDirectDrawPaletteImpl* ipal=(IDirectDrawPaletteImpl*)pal;
876 int i;
877 TRACE("(%p)->(%p)\n",This,ipal);
878
879 if (ipal == NULL) {
880 if( This->s.palette != NULL )
881 IDirectDrawPalette_Release((IDirectDrawPalette*)This->s.palette);
882 This->s.palette = ipal;
883
884 return DD_OK;
885 }
886
887 if( !(ipal->cm) && (This->s.ddraw->d.screen_pixelformat.x.dwRGBBitCount<=8))
888 {
889 ipal->cm = TSXCreateColormap(display,This->s.ddraw->d.drawable,
890 DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll);
891
892 if (!Options.managed)
893 TSXInstallColormap(display,ipal->cm);
894
895 for (i=0;i<256;i++) {
896 XColor xc;
897
898 xc.red = ipal->palents[i].peRed<<8;
899 xc.blue = ipal->palents[i].peBlue<<8;
900 xc.green = ipal->palents[i].peGreen<<8;
901 xc.flags = DoRed|DoBlue|DoGreen;
902 xc.pixel = i;
903 TSXStoreColor(display,ipal->cm,&xc);
904 }
905 TSXInstallColormap(display,ipal->cm);
906 }
907
908 /* According to spec, we are only supposed to
909 * AddRef if this is not the same palette.
910 */
911 if( This->s.palette != ipal )
912 {
913 if( ipal != NULL )
914 IDirectDrawPalette_AddRef( (IDirectDrawPalette*)ipal );
915 if( This->s.palette != NULL )
916 IDirectDrawPalette_Release( (IDirectDrawPalette*)This->s.palette );
917 This->s.palette = ipal;
918 /* Perform the refresh */
919 TSXSetWindowColormap(display,This->s.ddraw->d.drawable,This->s.palette->cm);
920 }
921 return DD_OK;
922 }
923
924 #ifdef HAVE_LIBXXF86DGA
925 static HRESULT WINAPI DGA_IDirectDrawSurface4Impl_SetPalette(
926 LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWPALETTE pal
927 ) {
928 ICOM_THIS(IDirectDrawSurface4Impl,iface);
929 IDirectDrawPaletteImpl* ipal=(IDirectDrawPaletteImpl*)pal;
930 TRACE("(%p)->(%p)\n",This,ipal);
931
932 /* According to spec, we are only supposed to
933 * AddRef if this is not the same palette.
934 */
935 if( This->s.palette != ipal )
936 {
937 if( ipal != NULL )
938 IDirectDrawPalette_AddRef( (IDirectDrawPalette*)ipal );
939 if( This->s.palette != NULL )
940 IDirectDrawPalette_Release( (IDirectDrawPalette*)This->s.palette );
941 This->s.palette = ipal;
942 TSXF86DGAInstallColormap(display,DefaultScreen(display),This->s.palette->cm);
943 }
944 return DD_OK;
945 }
946 #endif /* defined(HAVE_LIBXXF86DGA) */
947
948 static HRESULT _Blt_ColorFill(LPBYTE buf, int width, int height, int bpp, LONG lPitch, DWORD color)
949 {
950 int x, y;
951 LPBYTE first;
952
953 /* Do first row */
954
955 #define COLORFILL_ROW(type) { \
956 type *d = (type *) buf; \
957 for (x = 0; x < width; x++) \
958 d[x] = (type) color; \
959 break; \
960 }
961
962 switch(bpp) {
963 case 1: COLORFILL_ROW(BYTE)
964 case 2: COLORFILL_ROW(WORD)
965 case 4: COLORFILL_ROW(DWORD)
966 default:
967 FIXME("Color fill not implemented for bpp %d!\n", bpp*8);
968 return DDERR_UNSUPPORTED;
969 }
970
971 #undef COLORFILL_ROW
972
973 /* Now copy first row */
974 first = buf;
975 for (y = 1; y < height; y++) {
976 buf += lPitch;
977 memcpy(buf, first, width * bpp);
978 }
979
980 return DD_OK;
981 }
982
983 static HRESULT WINAPI IDirectDrawSurface4Impl_Blt(
984 LPDIRECTDRAWSURFACE4 iface,LPRECT rdst,LPDIRECTDRAWSURFACE4 src,LPRECT rsrc,DWORD dwFlags,LPDDBLTFX lpbltfx
985 ) {
986 ICOM_THIS(IDirectDrawSurface4Impl,iface);
987 RECT xdst,xsrc;
988 DDSURFACEDESC ddesc,sdesc;
989 HRESULT ret = DD_OK;
990 int bpp, srcheight, srcwidth, dstheight, dstwidth, width;
991 int x, y;
992 LPBYTE dbuf, sbuf;
993
994 TRACE("(%p)->(%p,%p,%p,%08lx,%p)\n", This,rdst,src,rsrc,dwFlags,lpbltfx);
995
996 if (src) IDirectDrawSurface4_Lock(src, NULL, &sdesc, 0, 0);
997 IDirectDrawSurface4_Lock(iface,NULL,&ddesc,0,0);
998
999 if (TRACE_ON(ddraw)) {
1000 if (rdst) TRACE("\tdestrect :%dx%d-%dx%d\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
1001 if (rsrc) TRACE("\tsrcrect :%dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
1002 TRACE("\tflags: ");
1003 _dump_DDBLT(dwFlags);
1004 if (dwFlags & DDBLT_DDFX) {
1005 TRACE("\tblitfx: ");
1006 _dump_DDBLTFX(lpbltfx->dwDDFX);
1007 }
1008 }
1009
1010 if (rdst) {
1011 memcpy(&xdst,rdst,sizeof(xdst));
1012 } else {
1013 xdst.top = 0;
1014 xdst.bottom = ddesc.dwHeight;
1015 xdst.left = 0;
1016 xdst.right = ddesc.dwWidth;
1017 }
1018
1019 if (rsrc) {
1020 memcpy(&xsrc,rsrc,sizeof(xsrc));
1021 } else {
1022 if (src) {
1023 xsrc.top = 0;
1024 xsrc.bottom = sdesc.dwHeight;
1025 xsrc.left = 0;
1026 xsrc.right = sdesc.dwWidth;
1027 } else {
1028 memset(&xsrc,0,sizeof(xsrc));
1029 }
1030 }
1031
1032 bpp = GET_BPP(ddesc);
1033 srcheight = xsrc.bottom - xsrc.top;
1034 srcwidth = xsrc.right - xsrc.left;
1035 dstheight = xdst.bottom - xdst.top;
1036 dstwidth = xdst.right - xdst.left;
1037 width = (xdst.right - xdst.left) * bpp;
1038 dbuf = (BYTE *) ddesc.y.lpSurface + (xdst.top * ddesc.lPitch) + (xdst.left * bpp);
1039
1040 dwFlags &= ~(DDBLT_WAIT|DDBLT_ASYNC);/* FIXME: can't handle right now */
1041
1042 /* First, all the 'source-less' blits */
1043 if (dwFlags & DDBLT_COLORFILL) {
1044 ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp,
1045 ddesc.lPitch, lpbltfx->b.dwFillColor);
1046 dwFlags &= ~DDBLT_COLORFILL;
1047 }
1048
1049 if (dwFlags & DDBLT_DEPTHFILL) {
1050 #ifdef HAVE_MESAGL
1051 GLboolean ztest;
1052
1053 /* Clears the screen */
1054 TRACE(" Filling depth buffer with %ld\n", lpbltfx->b.dwFillDepth);
1055 glClearDepth(lpbltfx->b.dwFillDepth / 65535.0); /* We suppose a 16 bit Z Buffer */
1056 glGetBooleanv(GL_DEPTH_TEST, &ztest);
1057 glDepthMask(GL_TRUE); /* Enables Z writing to be sure to delete also the Z buffer */
1058 glClear(GL_DEPTH_BUFFER_BIT);
1059 glDepthMask(ztest);
1060
1061 dwFlags &= ~(DDBLT_DEPTHFILL);
1062 #endif /* defined(HAVE_MESAGL) */
1063 }
1064
1065 if (dwFlags & DDBLT_ROP) {
1066 /* Catch some degenerate cases here */
1067 switch(lpbltfx->dwROP) {
1068 case BLACKNESS:
1069 ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp, ddesc.lPitch, 0);
1070 break;
1071 case 0xAA0029: /* No-op */
1072 break;
1073 case WHITENESS:
1074 ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp, ddesc.lPitch, ~0);
1075 break;
1076 default:
1077 FIXME("Unsupported raster op: %08lx Pattern: %p\n", lpbltfx->dwROP, lpbltfx->b.lpDDSPattern);
1078 goto error;
1079 }
1080 dwFlags &= ~DDBLT_ROP;
1081 }
1082
1083 if (dwFlags & DDBLT_DDROPS) {
1084 FIXME("\tDdraw Raster Ops: %08lx Pattern: %p\n", lpbltfx->dwDDROP, lpbltfx->b.lpDDSPattern);
1085 }
1086
1087 /* Now the 'with source' blits */
1088 if (src) {
1089 LPBYTE sbase;
1090 int sx, xinc, sy, yinc;
1091
1092 sbase = (BYTE *) sdesc.y.lpSurface + (xsrc.top * sdesc.lPitch) + xsrc.left * bpp;
1093 xinc = (srcwidth << 16) / dstwidth;
1094 yinc = (srcheight << 16) / dstheight;
1095
1096 if (!dwFlags) {
1097
1098 /* No effects, we can cheat here */
1099 if (dstwidth == srcwidth) {
1100 if (dstheight == srcheight) {
1101 /* No stretching in either direction. This needs to be as fast as possible */
1102 sbuf = sbase;
1103 for (y = 0; y < dstheight; y++) {
1104 memcpy(dbuf, sbuf, width);
1105 sbuf += sdesc.lPitch;
1106 dbuf += ddesc.lPitch;
1107 }
1108 } else {
1109 /* Stretching in Y direction only */
1110 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
1111 sbuf = sbase + (sy >> 16) * sdesc.lPitch;
1112 memcpy(dbuf, sbuf, width);
1113 dbuf += ddesc.lPitch;
1114 }
1115 }
1116 } else {
1117 /* Stretching in X direction */
1118 int last_sy = -1;
1119 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
1120 sbuf = sbase + (sy >> 16) * sdesc.lPitch;
1121
1122 if ((sy >> 16) == (last_sy >> 16)) {
1123 /* Same as last row - copy already stretched row */
1124 memcpy(dbuf, dbuf - ddesc.lPitch, width);
1125 } else {
1126
1127 #define STRETCH_ROW(type) { \
1128 type *s = (type *) sbuf, *d = (type *) dbuf; \
1129 for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
1130 d[x] = s[sx >> 16]; \
1131 break; }
1132
1133 switch(bpp) {
1134 case 1: STRETCH_ROW(BYTE)
1135 case 2: STRETCH_ROW(WORD)
1136 case 4: STRETCH_ROW(DWORD)
1137 default:
1138 FIXME("Stretched blit not implemented for bpp %d!\n", bpp*8);
1139 ret = DDERR_UNSUPPORTED;
1140 goto error;
1141 }
1142
1143 #undef STRETCH_ROW
1144
1145 }
1146 last_sy = sy;
1147 dbuf += ddesc.lPitch;
1148 }
1149 }
1150 } else if (dwFlags & (DDBLT_KEYSRC | DDBLT_KEYDEST)) {
1151 DWORD keylow, keyhigh;
1152
1153 if (dwFlags & DDBLT_KEYSRC) {
1154 keylow = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
1155 keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
1156 } else {
1157 /* I'm not sure if this is correct */
1158 FIXME("DDBLT_KEYDEST not fully supported yet.\n");
1159 keylow = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
1160 keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
1161 }
1162
1163
1164 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
1165 sbuf = sbase + (sy >> 16) * sdesc.lPitch;
1166
1167 #define COPYROW_COLORKEY(type) { \
1168 type *s = (type *) sbuf, *d = (type *) dbuf, tmp; \
1169 for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
1170 tmp = s[sx >> 16]; \
1171 if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1172 } \
1173 break; }
1174
1175 switch (bpp) {
1176 case 1: COPYROW_COLORKEY(BYTE)
1177 case 2: COPYROW_COLORKEY(WORD)
1178 case 4: COPYROW_COLORKEY(DWORD)
1179 default:
1180 FIXME("%s color-keyed blit not implemented for bpp %d!\n",
1181 (dwFlags & DDBLT_KEYSRC) ? "Source" : "Destination", bpp*8);
1182 ret = DDERR_UNSUPPORTED;
1183 goto error;
1184 }
1185 dbuf += ddesc.lPitch;
1186 }
1187
1188 #undef COPYROW_COLORKEY
1189
1190 dwFlags &= ~(DDBLT_KEYSRC | DDBLT_KEYDEST);
1191
1192 }
1193 }
1194
1195 error:
1196
1197 if (dwFlags && FIXME_ON(ddraw)) {
1198 FIXME("\tUnsupported flags: ");
1199 _dump_DDBLT(dwFlags);
1200 }
1201
1202 IDirectDrawSurface4_Unlock(iface,ddesc.y.lpSurface);
1203 if (src) IDirectDrawSurface4_Unlock(src,sdesc.y.lpSurface);
1204
1205 return DD_OK;
1206 }
1207
1208 static HRESULT WINAPI IDirectDrawSurface4Impl_BltFast(
1209 LPDIRECTDRAWSURFACE4 iface,DWORD dstx,DWORD dsty,LPDIRECTDRAWSURFACE4 src,LPRECT rsrc,DWORD trans
1210 ) {
1211 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1212 int bpp, w, h, x, y;
1213 DDSURFACEDESC ddesc,sdesc;
1214 HRESULT ret = DD_OK;
1215 LPBYTE sbuf, dbuf;
1216
1217
1218 if (TRACE_ON(ddraw)) {
1219 FIXME("(%p)->(%ld,%ld,%p,%p,%08lx)\n",
1220 This,dstx,dsty,src,rsrc,trans
1221 );
1222 FIXME(" trans:");
1223 if (FIXME_ON(ddraw))
1224 _dump_DDBLTFAST(trans);
1225 FIXME(" srcrect: %dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
1226 }
1227 /* We need to lock the surfaces, or we won't get refreshes when done. */
1228 IDirectDrawSurface4_Lock(src, NULL,&sdesc,DDLOCK_READONLY, 0);
1229 IDirectDrawSurface4_Lock(iface,NULL,&ddesc,DDLOCK_WRITEONLY,0);
1230
1231 bpp = GET_BPP(This->s.surface_desc);
1232 sbuf = (BYTE *) sdesc.y.lpSurface + (rsrc->top * sdesc.lPitch) + rsrc->left * bpp;
1233 dbuf = (BYTE *) ddesc.y.lpSurface + (dsty * ddesc.lPitch) + dstx * bpp;
1234
1235
1236 h=rsrc->bottom-rsrc->top;
1237 if (h>ddesc.dwHeight-dsty) h=ddesc.dwHeight-dsty;
1238 if (h>sdesc.dwHeight-rsrc->top) h=sdesc.dwHeight-rsrc->top;
1239 if (h<0) h=0;
1240
1241 w=rsrc->right-rsrc->left;
1242 if (w>ddesc.dwWidth-dstx) w=ddesc.dwWidth-dstx;
1243 if (w>sdesc.dwWidth-rsrc->left) w=sdesc.dwWidth-rsrc->left;
1244 if (w<0) w=0;
1245
1246 if (trans & (DDBLTFAST_SRCCOLORKEY | DDBLTFAST_DESTCOLORKEY)) {
1247 DWORD keylow, keyhigh;
1248 if (trans & DDBLTFAST_SRCCOLORKEY) {
1249 keylow = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
1250 keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
1251 } else {
1252 /* I'm not sure if this is correct */
1253 FIXME("DDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
1254 keylow = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
1255 keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
1256 }
1257
1258 #define COPYBOX_COLORKEY(type) { \
1259 type *d = (type *)dbuf, *s = (type *)sbuf, tmp; \
1260 s = (type *) ((BYTE *) sdesc.y.lpSurface + (rsrc->top * sdesc.lPitch) + rsrc->left * bpp); \
1261 d = (type *) ((BYTE *) ddesc.y.lpSurface + (dsty * ddesc.lPitch) + dstx * bpp); \
1262 for (y = 0; y < h; y++) { \
1263 for (x = 0; x < w; x++) { \
1264 tmp = s[x]; \
1265 if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1266 } \
1267 (LPBYTE)s += sdesc.lPitch; \
1268 (LPBYTE)d += ddesc.lPitch; \
1269 } \
1270 break; \
1271 }
1272
1273 switch (bpp) {
1274 case 1: COPYBOX_COLORKEY(BYTE)
1275 case 2: COPYBOX_COLORKEY(WORD)
1276 case 4: COPYBOX_COLORKEY(DWORD)
1277 default:
1278 FIXME("Source color key blitting not supported for bpp %d\n", bpp*8);
1279 ret = DDERR_UNSUPPORTED;
1280 goto error;
1281 }
1282
1283 #undef COPYBOX_COLORKEY
1284
1285 } else {
1286 int width = w * bpp;
1287
1288 for (y = 0; y < h; y++) {
1289 memcpy(dbuf, sbuf, width);
1290 sbuf += sdesc.lPitch;
1291 dbuf += ddesc.lPitch;
1292 }
1293 }
1294
1295 error:
1296
1297 IDirectDrawSurface4_Unlock(iface,ddesc.y.lpSurface);
1298 IDirectDrawSurface4_Unlock(src,sdesc.y.lpSurface);
1299 return ret;
1300 }
1301
1302 static HRESULT WINAPI IDirectDrawSurface4Impl_BltBatch(
1303 LPDIRECTDRAWSURFACE4 iface,LPDDBLTBATCH ddbltbatch,DWORD x,DWORD y
1304 ) {
1305 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1306 FIXME("(%p)->BltBatch(%p,%08lx,%08lx),stub!\n",
1307 This,ddbltbatch,x,y
1308 );
1309 return DD_OK;
1310 }
1311
1312 static HRESULT WINAPI IDirectDrawSurface4Impl_GetCaps(
1313 LPDIRECTDRAWSURFACE4 iface,LPDDSCAPS caps
1314 ) {
1315 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1316 TRACE("(%p)->GetCaps(%p)\n",This,caps);
1317 caps->dwCaps = DDSCAPS_PALETTE; /* probably more */
1318 return DD_OK;
1319 }
1320
1321 static HRESULT WINAPI IDirectDrawSurface4Impl_GetSurfaceDesc(
1322 LPDIRECTDRAWSURFACE4 iface,LPDDSURFACEDESC ddsd
1323 ) {
1324 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1325 TRACE("(%p)->GetSurfaceDesc(%p)\n", This,ddsd);
1326
1327 /* Simply copy the surface description stored in the object */
1328 *ddsd = This->s.surface_desc;
1329
1330 if (TRACE_ON(ddraw)) { _dump_surface_desc(ddsd); }
1331
1332 return DD_OK;
1333 }
1334
1335 static ULONG WINAPI IDirectDrawSurface4Impl_AddRef(LPDIRECTDRAWSURFACE4 iface) {
1336 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1337 TRACE("(%p)->() incrementing from %lu.\n", This, This->ref );
1338 return ++(This->ref);
1339 }
1340
1341 #ifdef HAVE_LIBXXF86DGA
1342 static ULONG WINAPI DGA_IDirectDrawSurface4Impl_Release(LPDIRECTDRAWSURFACE4 iface) {
1343 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1344
1345 TRACE("(%p)->() decrementing from %lu.\n", This, This->ref );
1346
1347 if (--(This->ref))
1348 return This->ref;
1349
1350 IDirectDraw2_Release((IDirectDraw2*)This->s.ddraw);
1351 /* clear out of surface list */
1352 if (This->t.dga.fb_height == -1)
1353 HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1354 else
1355 This->s.ddraw->e.dga.vpmask &= ~(1<<(This->t.dga.fb_height/This->s.ddraw->e.dga.fb_height));
1356
1357 /* Free the DIBSection (if any) */
1358 if (This->s.hdc != 0) {
1359 SelectObject(This->s.hdc, This->s.holdbitmap);
1360 DeleteDC(This->s.hdc);
1361 DeleteObject(This->s.DIBsection);
1362 }
1363
1364 HeapFree(GetProcessHeap(),0,This);
1365 return S_OK;
1366 }
1367 #endif /* defined(HAVE_LIBXXF86DGA) */
1368
1369 static ULONG WINAPI Xlib_IDirectDrawSurface4Impl_Release(LPDIRECTDRAWSURFACE4 iface) {
1370 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1371
1372 TRACE( "(%p)->() decrementing from %lu.\n", This, This->ref );
1373
1374 if (--(This->ref))
1375 return This->ref;
1376
1377 IDirectDraw2_Release((IDirectDraw2*)This->s.ddraw);
1378
1379 if (This->t.xlib.image != NULL) {
1380 if (This->s.ddraw->d.pixel_convert != NULL) {
1381 /* In pixel conversion mode, there are 2 buffers to release. */
1382 HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1383
1384 #ifdef HAVE_LIBXXSHM
1385 if (This->s.ddraw->e.xlib.xshm_active) {
1386 TSXShmDetach(display, &(This->t.xlib.shminfo));
1387 TSXDestroyImage(This->t.xlib.image);
1388 shmdt(This->t.xlib.shminfo.shmaddr);
1389 } else {
1390 #endif
1391 HeapFree(GetProcessHeap(),0,This->t.xlib.image->data);
1392 This->t.xlib.image->data = NULL;
1393 TSXDestroyImage(This->t.xlib.image);
1394 #ifdef HAVE_LIBXXSHM
1395 }
1396 #endif
1397 } else {
1398 This->t.xlib.image->data = NULL;
1399
1400 #ifdef HAVE_LIBXXSHM
1401 if (This->s.ddraw->e.xlib.xshm_active) {
1402 TSXShmDetach(display, &(This->t.xlib.shminfo));
1403 TSXDestroyImage(This->t.xlib.image);
1404 shmdt(This->t.xlib.shminfo.shmaddr);
1405 } else {
1406 #endif
1407 HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1408 TSXDestroyImage(This->t.xlib.image);
1409 #ifdef HAVE_LIBXXSHM
1410 }
1411 #endif
1412 }
1413 This->t.xlib.image = 0;
1414 } else {
1415 HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1416 }
1417
1418 if (This->s.palette)
1419 IDirectDrawPalette_Release((IDirectDrawPalette*)This->s.palette);
1420
1421 /* Free the DIBSection (if any) */
1422 if (This->s.hdc != 0) {
1423 SelectObject(This->s.hdc, This->s.holdbitmap);
1424 DeleteDC(This->s.hdc);
1425 DeleteObject(This->s.DIBsection);
1426 }
1427
1428 HeapFree(GetProcessHeap(),0,This);
1429 return S_OK;
1430 }
1431
1432 static HRESULT WINAPI IDirectDrawSurface4Impl_GetAttachedSurface(
1433 LPDIRECTDRAWSURFACE4 iface,LPDDSCAPS lpddsd,LPDIRECTDRAWSURFACE4 *lpdsf
1434 ) {
1435 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1436 int i,found = 0,xstart;
1437 struct _surface_chain *chain;
1438
1439 TRACE("(%p)->GetAttachedSurface(%p,%p)\n", This, lpddsd, lpdsf);
1440 if (TRACE_ON(ddraw)) {
1441 TRACE(" caps ");_dump_DDSCAPS((void *) &(lpddsd->dwCaps));
1442 }
1443 chain = This->s.chain;
1444 if (!chain)
1445 return DDERR_NOTFOUND;
1446
1447 for (i=0;i<chain->nrofsurfaces;i++)
1448 if (chain->surfaces[i] == This)
1449 break;
1450
1451 xstart = i;
1452 for (i=0;i<chain->nrofsurfaces;i++) {
1453 if ((SDDSCAPS(chain->surfaces[(xstart+i)%chain->nrofsurfaces])&lpddsd->dwCaps) == lpddsd->dwCaps) {
1454 #if 0
1455 if (found) /* may not find the same caps twice, (doc) */
1456 return DDERR_INVALIDPARAMS;/*FIXME: correct? */
1457 #endif
1458 found = (i+1)+xstart;
1459 }
1460 }
1461 if (!found)
1462 return DDERR_NOTFOUND;
1463 *lpdsf = (LPDIRECTDRAWSURFACE4)chain->surfaces[found-1-xstart];
1464 /* FIXME: AddRef? */
1465 TRACE("found %p\n",*lpdsf);
1466 return DD_OK;
1467 }
1468
1469 static HRESULT WINAPI IDirectDrawSurface4Impl_Initialize(
1470 LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAW ddraw,LPDDSURFACEDESC lpdsfd
1471 ) {
1472 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1473 TRACE("(%p)->(%p, %p)\n",This,ddraw,lpdsfd);
1474
1475 return DDERR_ALREADYINITIALIZED;
1476 }
1477
1478 static HRESULT WINAPI IDirectDrawSurface4Impl_GetPixelFormat(
1479 LPDIRECTDRAWSURFACE4 iface,LPDDPIXELFORMAT pf
1480 ) {
1481 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1482 TRACE("(%p)->(%p)\n",This,pf);
1483
1484 *pf = This->s.surface_desc.ddpfPixelFormat;
1485 if (TRACE_ON(ddraw)) { _dump_pixelformat(pf); DPRINTF("\n"); }
1486 return DD_OK;
1487 }
1488
1489 static HRESULT WINAPI IDirectDrawSurface4Impl_GetBltStatus(LPDIRECTDRAWSURFACE4 iface,DWORD dwFlags) {
1490 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1491 FIXME("(%p)->(0x%08lx),stub!\n",This,dwFlags);
1492 return DD_OK;
1493 }
1494
1495 static HRESULT WINAPI IDirectDrawSurface4Impl_GetOverlayPosition(
1496 LPDIRECTDRAWSURFACE4 iface,LPLONG x1,LPLONG x2
1497 ) {
1498 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1499 FIXME("(%p)->(%p,%p),stub!\n",This,x1,x2);
1500 return DD_OK;
1501 }
1502
1503 static HRESULT WINAPI IDirectDrawSurface4Impl_SetClipper(
1504 LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWCLIPPER clipper
1505 ) {
1506 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1507 FIXME("(%p)->(%p),stub!\n",This,clipper);
1508 return DD_OK;
1509 }
1510
1511 static HRESULT WINAPI IDirectDrawSurface4Impl_AddAttachedSurface(
1512 LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWSURFACE4 surf
1513 ) {
1514 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1515 IDirectDrawSurface4Impl*isurf = (IDirectDrawSurface4Impl*)surf;
1516 int i;
1517 struct _surface_chain *chain;
1518
1519 IDirectDrawSurface4_AddRef(iface);
1520
1521 FIXME("(%p)->(%p)\n",This,surf);
1522 chain = This->s.chain;
1523
1524 if (chain) {
1525 for (i=0;i<chain->nrofsurfaces;i++)
1526 if (chain->surfaces[i] == isurf)
1527 FIXME("attaching already attached surface %p to %p!\n",iface,isurf);
1528 } else {
1529 chain = HeapAlloc(GetProcessHeap(),0,sizeof(*chain));
1530 chain->nrofsurfaces = 1;
1531 chain->surfaces = HeapAlloc(GetProcessHeap(),0,sizeof(chain->surfaces[0]));
1532 chain->surfaces[0] = This;
1533 This->s.chain = chain;
1534 }
1535
1536 if (chain->surfaces)
1537 chain->surfaces = HeapReAlloc(
1538 GetProcessHeap(),
1539 0,
1540 chain->surfaces,
1541 sizeof(chain->surfaces[0])*(chain->nrofsurfaces+1)
1542 );
1543 else
1544 chain->surfaces = HeapAlloc(GetProcessHeap(),0,sizeof(chain->surfaces[0]));
1545 isurf->s.chain = chain;
1546 chain->surfaces[chain->nrofsurfaces++] = isurf;
1547 return DD_OK;
1548 }
1549
1550 static HRESULT WINAPI IDirectDrawSurface4Impl_GetDC(LPDIRECTDRAWSURFACE4 iface,HDC* lphdc) {
1551 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1552 DDSURFACEDESC desc;
1553 BITMAPINFO *b_info;
1554 UINT usage;
1555
1556 FIXME("(%p)->GetDC(%p)\n",This,lphdc);
1557
1558 /* Creates a DIB Section of the same size / format as the surface */
1559 IDirectDrawSurface4_Lock(iface,NULL,&desc,0,0);
1560
1561 if (This->s.hdc == 0) {
1562 switch (desc.ddpfPixelFormat.x.dwRGBBitCount) {
1563 case 16:
1564 case 32:
1565 #if 0 /* This should be filled if Wine's DIBSection did understand BI_BITFIELDS */
1566 b_info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD));
1567 break;
1568 #endif
1569
1570 case 24:
1571 b_info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER));
1572 break;
1573
1574 default:
1575 b_info = (BITMAPINFO *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1576 sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (2 << desc.ddpfPixelFormat.x.dwRGBBitCount));
1577 break;
1578 }
1579
1580 b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1581 b_info->bmiHeader.biWidth = desc.dwWidth;
1582 b_info->bmiHeader.biHeight = desc.dwHeight;
1583 b_info->bmiHeader.biPlanes = 1;
1584 b_info->bmiHeader.biBitCount = desc.ddpfPixelFormat.x.dwRGBBitCount;
1585 #if 0
1586 if ((desc.ddpfPixelFormat.x.dwRGBBitCount != 16) &&
1587 (desc.ddpfPixelFormat.x.dwRGBBitCount != 32))
1588 #endif
1589 b_info->bmiHeader.biCompression = BI_RGB;
1590 #if 0
1591 else
1592 b_info->bmiHeader.biCompression = BI_BITFIELDS;
1593 #endif
1594 b_info->bmiHeader.biSizeImage = (desc.ddpfPixelFormat.x.dwRGBBitCount / 8) * desc.dwWidth * desc.dwHeight;
1595 b_info->bmiHeader.biXPelsPerMeter = 0;
1596 b_info->bmiHeader.biYPelsPerMeter = 0;
1597 b_info->bmiHeader.biClrUsed = 0;
1598 b_info->bmiHeader.biClrImportant = 0;
1599
1600 switch (desc.ddpfPixelFormat.x.dwRGBBitCount) {
1601 case 16:
1602 case 32:
1603 #if 0
1604 {
1605 DWORD *masks = (DWORD *) &(b_info->bmiColors);
1606
1607 usage = 0;
1608 masks[0] = desc.ddpfPixelFormat.y.dwRBitMask;
1609 masks[1] = desc.ddpfPixelFormat.z.dwGBitMask;
1610 masks[2] = desc.ddpfPixelFormat.xx.dwBBitMask;
1611 }
1612 break;
1613 #endif
1614 case 24:
1615 /* Nothing to do */
1616 usage = DIB_RGB_COLORS;
1617 break;
1618
1619 default: {
1620 int i;
1621
1622 /* Fill the palette */
1623 usage = DIB_RGB_COLORS;
1624
1625 if (This->s.palette == NULL) {
1626 ERR("Bad palette !!!\n");
1627 } else {
1628 RGBQUAD *rgb = (RGBQUAD *) &(b_info->bmiColors);
1629 PALETTEENTRY *pent = (PALETTEENTRY *)&(This->s.palette->palents);
1630
1631 for (i=0;i<(1<<desc.ddpfPixelFormat.x.dwRGBBitCount);i++) {
1632 rgb[i].rgbBlue = pent[i].peBlue;
1633 rgb[i].rgbRed = pent[i].peRed;
1634 rgb[i].rgbGreen = pent[i].peGreen;
1635 }
1636 }
1637 }
1638 break;
1639 }
1640 This->s.DIBsection = CreateDIBSection(BeginPaint(This->s.ddraw->d.mainWindow,&This->s.ddraw->d.ps),
1641 b_info,
1642 usage,
1643 &(This->s.bitmap_data),
1644 0,
1645 0
1646 );
1647 EndPaint(This->s.ddraw->d.mainWindow,&This->s.ddraw->d.ps);
1648 TRACE("DIBSection at : %p\n", This->s.bitmap_data);
1649
1650 /* b_info is not useful anymore */
1651 HeapFree(GetProcessHeap(), 0, b_info);
1652
1653 /* Create the DC */
1654 This->s.hdc = CreateCompatibleDC(0);
1655 This->s.holdbitmap = SelectObject(This->s.hdc, This->s.DIBsection);
1656 }
1657
1658 /* Copy our surface in the DIB section */
1659 if ((GET_BPP(desc) * desc.dwWidth) == desc.lPitch)
1660 memcpy(This->s.bitmap_data,desc.y.lpSurface,desc.lPitch*desc.dwHeight);
1661 else
1662 /* TODO */
1663 FIXME("This case has to be done :/\n");
1664
1665 TRACE("HDC : %08lx\n", (DWORD) This->s.hdc);
1666 *lphdc = This->s.hdc;
1667
1668 return DD_OK;
1669 }
1670
1671 static HRESULT WINAPI IDirectDrawSurface4Impl_ReleaseDC(LPDIRECTDRAWSURFACE4 iface,HDC hdc) {
1672 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1673
1674 FIXME("(%p)->(0x%08lx),stub!\n",This,(long)hdc);
1675 TRACE( "Copying DIBSection at : %p\n", This->s.bitmap_data);
1676 /* Copy the DIB section to our surface */
1677 if ((GET_BPP(This->s.surface_desc) * This->s.surface_desc.dwWidth) == This->s.surface_desc.lPitch) {
1678 memcpy(This->s.surface_desc.y.lpSurface, This->s.bitmap_data, This->s.surface_desc.lPitch * This->s.surface_desc.dwHeight);
1679 } else {
1680 /* TODO */
1681 FIXME("This case has to be done :/\n");
1682 }
1683 /* Unlock the surface */
1684 IDirectDrawSurface4_Unlock(iface,This->s.surface_desc.y.lpSurface);
1685 return DD_OK;
1686 }
1687
1688 static HRESULT WINAPI IDirectDrawSurface4Impl_QueryInterface(LPDIRECTDRAWSURFACE4 iface,REFIID refiid,LPVOID *obj) {
1689 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1690 char xrefiid[50];
1691
1692 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1693 TRACE("(%p)->(%s,%p)\n",This,xrefiid,obj);
1694
1695 /* All DirectDrawSurface versions (1, 2, 3 and 4) use
1696 * the same interface. And IUnknown does that too of course.
1697 */
1698 if ( IsEqualGUID( &IID_IDirectDrawSurface4, refiid ) ||
1699 IsEqualGUID( &IID_IDirectDrawSurface3, refiid ) ||
1700 IsEqualGUID( &IID_IDirectDrawSurface2, refiid ) ||
1701 IsEqualGUID( &IID_IDirectDrawSurface, refiid ) ||
1702 IsEqualGUID( &IID_IUnknown, refiid )
1703 ) {
1704 *obj = This;
1705 IDirectDrawSurface4_AddRef(iface);
1706
1707 TRACE(" Creating IDirectDrawSurface interface (%p)\n", *obj);
1708 return S_OK;
1709 }
1710 else if ( IsEqualGUID( &IID_IDirect3DTexture2, refiid ) )
1711 {
1712 /* Texture interface */
1713 *obj = d3dtexture2_create(This);
1714 IDirectDrawSurface4_AddRef(iface);
1715 TRACE(" Creating IDirect3DTexture2 interface (%p)\n", *obj);
1716 return S_OK;
1717 }
1718 else if ( IsEqualGUID( &IID_IDirect3DTexture, refiid ) )
1719 {
1720 /* Texture interface */
1721 *obj = d3dtexture_create(This);
1722 IDirectDrawSurface4_AddRef(iface);
1723
1724 TRACE(" Creating IDirect3DTexture interface (%p)\n", *obj);
1725
1726 return S_OK;
1727 }
1728 else if (is_OpenGL_dx3(refiid, (IDirectDrawSurfaceImpl*)This, (IDirect3DDeviceImpl**) obj)) {
1729 /* It is the OpenGL Direct3D Device */
1730 IDirectDrawSurface4_AddRef(iface);
1731 TRACE(" Creating IDirect3DDevice interface (%p)\n", *obj);
1732 return S_OK;
1733 }
1734
1735 FIXME("(%p):interface for IID %s NOT found!\n",This,xrefiid);
1736 return OLE_E_ENUM_NOMORE;
1737 }
1738
1739 static HRESULT WINAPI IDirectDrawSurface4Impl_IsLost(LPDIRECTDRAWSURFACE4 iface) {
1740 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1741 TRACE("(%p)->(), stub!\n",This);
1742 return DD_OK; /* hmm */
1743 }
1744
1745 static HRESULT WINAPI IDirectDrawSurface4Impl_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE4 iface,LPVOID context,LPDDENUMSURFACESCALLBACK esfcb) {
1746 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1747 int i;
1748 struct _surface_chain *chain = This->s.chain;
1749
1750 TRACE("(%p)->(%p,%p)\n",This,context,esfcb);
1751 for (i=0;i<chain->nrofsurfaces;i++) {
1752 TRACE( "Enumerating attached surface (%p)\n", chain->surfaces[i]);
1753 if (esfcb((LPDIRECTDRAWSURFACE) chain->surfaces[i], &(chain->surfaces[i]->s.surface_desc), context) == DDENUMRET_CANCEL)
1754 return DD_OK; /* FIXME: return value correct? */
1755 }
1756 return DD_OK;
1757 }
1758
1759 static HRESULT WINAPI IDirectDrawSurface4Impl_Restore(LPDIRECTDRAWSURFACE4 iface) {
1760 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1761 FIXME("(%p)->(),stub!\n",This);
1762 return DD_OK;
1763 }
1764
1765 static HRESULT WINAPI IDirectDrawSurface4Impl_SetColorKey(
1766 LPDIRECTDRAWSURFACE4 iface, DWORD dwFlags, LPDDCOLORKEY ckey )
1767 {
1768 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1769 TRACE("(%p)->(0x%08lx,%p)\n",This,dwFlags,ckey);
1770 if (TRACE_ON(ddraw)) {
1771 _dump_colorkeyflag(dwFlags);
1772 DPRINTF(" : ");
1773 _dump_DDCOLORKEY((void *) ckey);
1774 DPRINTF("\n");
1775 }
1776
1777 /* If this surface was loaded as a texture, call also the texture
1778 SetColorKey callback */
1779 if (This->s.texture) {
1780 This->s.SetColorKey_cb(This->s.texture, dwFlags, ckey);
1781 }
1782
1783 if( dwFlags & DDCKEY_SRCBLT )
1784 {
1785 dwFlags &= ~DDCKEY_SRCBLT;
1786 This->s.surface_desc.dwFlags |= DDSD_CKSRCBLT;
1787 memcpy( &(This->s.surface_desc.ddckCKSrcBlt), ckey, sizeof( *ckey ) );
1788 }
1789
1790 if( dwFlags & DDCKEY_DESTBLT )
1791 {
1792 dwFlags &= ~DDCKEY_DESTBLT;
1793 This->s.surface_desc.dwFlags |= DDSD_CKDESTBLT;
1794 memcpy( &(This->s.surface_desc.ddckCKDestBlt), ckey, sizeof( *ckey ) );
1795 }
1796
1797 if( dwFlags & DDCKEY_SRCOVERLAY )
1798 {
1799 dwFlags &= ~DDCKEY_SRCOVERLAY;
1800 This->s.surface_desc.dwFlags |= DDSD_CKSRCOVERLAY;
1801 memcpy( &(This->s.surface_desc.ddckCKSrcOverlay), ckey, sizeof( *ckey ) );
1802 }
1803
1804 if( dwFlags & DDCKEY_DESTOVERLAY )
1805 {
1806 dwFlags &= ~DDCKEY_DESTOVERLAY;
1807 This->s.surface_desc.dwFlags |= DDSD_CKDESTOVERLAY;
1808 memcpy( &(This->s.surface_desc.ddckCKDestOverlay), ckey, sizeof( *ckey ) );
1809 }
1810
1811 if( dwFlags )
1812 {
1813 FIXME("unhandled dwFlags: 0x%08lx\n", dwFlags );
1814 }
1815
1816 return DD_OK;
1817
1818 }
1819
1820 static HRESULT WINAPI IDirectDrawSurface4Impl_AddOverlayDirtyRect(
1821 LPDIRECTDRAWSURFACE4 iface,
1822 LPRECT lpRect )
1823 {
1824 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1825 FIXME("(%p)->(%p),stub!\n",This,lpRect);
1826
1827 return DD_OK;
1828 }
1829
1830 static HRESULT WINAPI IDirectDrawSurface4Impl_DeleteAttachedSurface(
1831 LPDIRECTDRAWSURFACE4 iface,
1832 DWORD dwFlags,
1833 LPDIRECTDRAWSURFACE4 lpDDSAttachedSurface )
1834 {
1835 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1836 int i;
1837 struct _surface_chain *chain;
1838
1839 TRACE("(%p)->(0x%08lx,%p)\n",This,dwFlags,lpDDSAttachedSurface);
1840 chain = This->s.chain;
1841 for (i=0;i<chain->nrofsurfaces;i++) {
1842 if ((IDirectDrawSurface4Impl*)lpDDSAttachedSurface==chain->surfaces[i]){
1843 IDirectDrawSurface4_Release(lpDDSAttachedSurface);
1844
1845 chain->surfaces[i]->s.chain = NULL;
1846 memcpy( chain->surfaces+i,
1847 chain->surfaces+(i+1),
1848 (chain->nrofsurfaces-i-1)*sizeof(chain->surfaces[i])
1849 );
1850 chain->surfaces = HeapReAlloc(
1851 GetProcessHeap(),
1852 0,
1853 chain->surfaces,
1854 sizeof(chain->surfaces[i])*(chain->nrofsurfaces-1)
1855 );
1856 chain->nrofsurfaces--;
1857 return DD_OK;
1858 }
1859 }
1860 return DD_OK;
1861 }
1862
1863 static HRESULT WINAPI IDirectDrawSurface4Impl_EnumOverlayZOrders(
1864 LPDIRECTDRAWSURFACE4 iface,
1865 DWORD dwFlags,
1866 LPVOID lpContext,
1867 LPDDENUMSURFACESCALLBACK lpfnCallback )
1868 {
1869 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1870 FIXME("(%p)->(0x%08lx,%p,%p),stub!\n", This,dwFlags,
1871 lpContext, lpfnCallback );
1872
1873 return DD_OK;
1874 }
1875
1876 static HRESULT WINAPI IDirectDrawSurface4Impl_GetClipper(
1877 LPDIRECTDRAWSURFACE4 iface,
1878 LPDIRECTDRAWCLIPPER* lplpDDClipper )
1879 {
1880 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1881 FIXME("(%p)->(%p),stub!\n", This, lplpDDClipper);
1882
1883 return DD_OK;
1884 }
1885
1886 static HRESULT WINAPI IDirectDrawSurface4Impl_GetColorKey(
1887 LPDIRECTDRAWSURFACE4 iface,
1888 DWORD dwFlags,
1889 LPDDCOLORKEY lpDDColorKey )
1890 {
1891 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1892 TRACE("(%p)->(0x%08lx,%p)\n", This, dwFlags, lpDDColorKey);
1893
1894 if( dwFlags & DDCKEY_SRCBLT ) {
1895 dwFlags &= ~DDCKEY_SRCBLT;
1896 memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKSrcBlt), sizeof( *lpDDColorKey ) );
1897 }
1898
1899 if( dwFlags & DDCKEY_DESTBLT )
1900 {
1901 dwFlags &= ~DDCKEY_DESTBLT;
1902 memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKDestBlt), sizeof( *lpDDColorKey ) );
1903 }
1904
1905 if( dwFlags & DDCKEY_SRCOVERLAY )
1906 {
1907 dwFlags &= ~DDCKEY_SRCOVERLAY;
1908 memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKSrcOverlay), sizeof( *lpDDColorKey ) );
1909 }
1910
1911 if( dwFlags & DDCKEY_DESTOVERLAY )
1912 {
1913 dwFlags &= ~DDCKEY_DESTOVERLAY;
1914 memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKDestOverlay), sizeof( *lpDDColorKey ) );
1915 }
1916
1917 if( dwFlags )
1918 {
1919 FIXME("unhandled dwFlags: 0x%08lx\n", dwFlags );
1920 }
1921
1922 return DD_OK;
1923 }
1924
1925 static HRESULT WINAPI IDirectDrawSurface4Impl_GetFlipStatus(
1926 LPDIRECTDRAWSURFACE4 iface,
1927 DWORD dwFlags )
1928 {
1929 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1930 FIXME("(%p)->(0x%08lx),stub!\n", This, dwFlags);
1931
1932 return DD_OK;
1933 }
1934
1935 static HRESULT WINAPI IDirectDrawSurface4Impl_GetPalette(
1936 LPDIRECTDRAWSURFACE4 iface,
1937 LPDIRECTDRAWPALETTE* lplpDDPalette )
1938 {
1939 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1940 FIXME("(%p)->(%p),stub!\n", This, lplpDDPalette);
1941
1942 return DD_OK;
1943 }
1944
1945 static HRESULT WINAPI IDirectDrawSurface4Impl_SetOverlayPosition(
1946 LPDIRECTDRAWSURFACE4 iface,
1947 LONG lX,
1948 LONG lY)
1949 {
1950 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1951 FIXME("(%p)->(%ld,%ld),stub!\n", This, lX, lY);
1952
1953 return DD_OK;
1954 }
1955
1956 static HRESULT WINAPI IDirectDrawSurface4Impl_UpdateOverlay(
1957 LPDIRECTDRAWSURFACE4 iface,
1958 LPRECT lpSrcRect,
1959 LPDIRECTDRAWSURFACE4 lpDDDestSurface,
1960 LPRECT lpDestRect,
1961 DWORD dwFlags,
1962 LPDDOVERLAYFX lpDDOverlayFx )
1963 {
1964 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1965 FIXME("(%p)->(%p,%p,%p,0x%08lx,%p),stub!\n", This,
1966 lpSrcRect, lpDDDestSurface, lpDestRect, dwFlags, lpDDOverlayFx );
1967
1968 return DD_OK;
1969 }
1970
1971 static HRESULT WINAPI IDirectDrawSurface4Impl_UpdateOverlayDisplay(
1972 LPDIRECTDRAWSURFACE4 iface,
1973 DWORD dwFlags )
1974 {
1975 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1976 FIXME("(%p)->(0x%08lx),stub!\n", This, dwFlags);
1977
1978 return DD_OK;
1979 }
1980
1981 static HRESULT WINAPI IDirectDrawSurface4Impl_UpdateOverlayZOrder(
1982 LPDIRECTDRAWSURFACE4 iface,
1983 DWORD dwFlags,
1984 LPDIRECTDRAWSURFACE4 lpDDSReference )
1985 {
1986 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1987 FIXME("(%p)->(0x%08lx,%p),stub!\n", This, dwFlags, lpDDSReference);
1988
1989 return DD_OK;
1990 }
1991
1992 static HRESULT WINAPI IDirectDrawSurface4Impl_GetDDInterface(
1993 LPDIRECTDRAWSURFACE4 iface,
1994 LPVOID* lplpDD )
1995 {
1996 ICOM_THIS(IDirectDrawSurface4Impl,iface);
1997 FIXME("(%p)->(%p),stub!\n", This, lplpDD);
1998
1999 /* Not sure about that... */
2000 *lplpDD = (void *) This->s.ddraw;
2001
2002 return DD_OK;
2003 }
2004
2005 static HRESULT WINAPI IDirectDrawSurface4Impl_PageLock(
2006 LPDIRECTDRAWSURFACE4 iface,
2007 DWORD dwFlags )
2008 {
2009 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2010 FIXME("(%p)->(0x%08lx),stub!\n", This, dwFlags);
2011
2012 return DD_OK;
2013 }
2014
2015 static HRESULT WINAPI IDirectDrawSurface4Impl_PageUnlock(
2016 LPDIRECTDRAWSURFACE4 iface,
2017 DWORD dwFlags )
2018 {
2019 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2020 FIXME("(%p)->(0x%08lx),stub!\n", This, dwFlags);
2021
2022 return DD_OK;
2023 }
2024
2025 static HRESULT WINAPI IDirectDrawSurface4Impl_SetSurfaceDesc(
2026 LPDIRECTDRAWSURFACE4 iface,
2027 LPDDSURFACEDESC lpDDSD,
2028 DWORD dwFlags )
2029 {
2030 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2031 FIXME("(%p)->(%p,0x%08lx),stub!\n", This, lpDDSD, dwFlags);
2032
2033 return DD_OK;
2034 }
2035
2036 static HRESULT WINAPI IDirectDrawSurface4Impl_SetPrivateData(LPDIRECTDRAWSURFACE4 iface,
2037 REFGUID guidTag,
2038 LPVOID lpData,
2039 DWORD cbSize,
2040 DWORD dwFlags) {
2041 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2042 FIXME("(%p)->(%p,%p,%ld,%08lx\n", This, guidTag, lpData, cbSize, dwFlags);
2043
2044 return DD_OK;
2045 }
2046
2047 static HRESULT WINAPI IDirectDrawSurface4Impl_GetPrivateData(LPDIRECTDRAWSURFACE4 iface,
2048 REFGUID guidTag,
2049 LPVOID lpBuffer,
2050 LPDWORD lpcbBufferSize) {
2051 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2052 FIXME("(%p)->(%p,%p,%p)\n", This, guidTag, lpBuffer, lpcbBufferSize);
2053
2054 return DD_OK;
2055 }
2056
2057 static HRESULT WINAPI IDirectDrawSurface4Impl_FreePrivateData(LPDIRECTDRAWSURFACE4 iface,
2058 REFGUID guidTag) {
2059 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2060 FIXME("(%p)->(%p)\n", This, guidTag);
2061
2062 return DD_OK;
2063 }
2064
2065 static HRESULT WINAPI IDirectDrawSurface4Impl_GetUniquenessValue(LPDIRECTDRAWSURFACE4 iface,
2066 LPDWORD lpValue) {
2067 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2068 FIXME("(%p)->(%p)\n", This, lpValue);
2069
2070 return DD_OK;
2071 }
2072
2073 static HRESULT WINAPI IDirectDrawSurface4Impl_ChangeUniquenessValue(LPDIRECTDRAWSURFACE4 iface) {
2074 ICOM_THIS(IDirectDrawSurface4Impl,iface);
2075 FIXME("(%p)\n", This);
2076
2077 return DD_OK;
2078 }
2079
2080 #ifdef HAVE_LIBXXF86DGA
2081 static ICOM_VTABLE(IDirectDrawSurface4) dga_dds4vt =
2082 {
2083 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2084 IDirectDrawSurface4Impl_QueryInterface,
2085 IDirectDrawSurface4Impl_AddRef,
2086 DGA_IDirectDrawSurface4Impl_Release,
2087 IDirectDrawSurface4Impl_AddAttachedSurface,
2088 IDirectDrawSurface4Impl_AddOverlayDirtyRect,
2089 IDirectDrawSurface4Impl_Blt,
2090 IDirectDrawSurface4Impl_BltBatch,
2091 IDirectDrawSurface4Impl_BltFast,
2092 IDirectDrawSurface4Impl_DeleteAttachedSurface,
2093 IDirectDrawSurface4Impl_EnumAttachedSurfaces,
2094 IDirectDrawSurface4Impl_EnumOverlayZOrders,
2095 DGA_IDirectDrawSurface4Impl_Flip,
2096 IDirectDrawSurface4Impl_GetAttachedSurface,
2097 IDirectDrawSurface4Impl_GetBltStatus,
2098 IDirectDrawSurface4Impl_GetCaps,
2099 IDirectDrawSurface4Impl_GetClipper,
2100 IDirectDrawSurface4Impl_GetColorKey,
2101 IDirectDrawSurface4Impl_GetDC,
2102 IDirectDrawSurface4Impl_GetFlipStatus,
2103 IDirectDrawSurface4Impl_GetOverlayPosition,
2104 IDirectDrawSurface4Impl_GetPalette,
2105 IDirectDrawSurface4Impl_GetPixelFormat,
2106 IDirectDrawSurface4Impl_GetSurfaceDesc,
2107 IDirectDrawSurface4Impl_Initialize,
2108 IDirectDrawSurface4Impl_IsLost,
2109 IDirectDrawSurface4Impl_Lock,
2110 IDirectDrawSurface4Impl_ReleaseDC,
2111 IDirectDrawSurface4Impl_Restore,
2112 IDirectDrawSurface4Impl_SetClipper,
2113 IDirectDrawSurface4Impl_SetColorKey,
2114 IDirectDrawSurface4Impl_SetOverlayPosition,
2115 DGA_IDirectDrawSurface4Impl_SetPalette,
2116 DGA_IDirectDrawSurface4Impl_Unlock,
2117 IDirectDrawSurface4Impl_UpdateOverlay,
2118 IDirectDrawSurface4Impl_UpdateOverlayDisplay,
2119 IDirectDrawSurface4Impl_UpdateOverlayZOrder,
2120 IDirectDrawSurface4Impl_GetDDInterface,
2121 IDirectDrawSurface4Impl_PageLock,
2122 IDirectDrawSurface4Impl_PageUnlock,
2123 IDirectDrawSurface4Impl_SetSurfaceDesc,
2124 IDirectDrawSurface4Impl_SetPrivateData,
2125 IDirectDrawSurface4Impl_GetPrivateData,
2126 IDirectDrawSurface4Impl_FreePrivateData,
2127 IDirectDrawSurface4Impl_GetUniquenessValue,
2128 IDirectDrawSurface4Impl_ChangeUniquenessValue
2129 };
2130 #endif /* defined(HAVE_LIBXXF86DGA) */
2131
2132 static ICOM_VTABLE(IDirectDrawSurface4) xlib_dds4vt =
2133 {
2134 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2135 IDirectDrawSurface4Impl_QueryInterface,
2136 IDirectDrawSurface4Impl_AddRef,
2137 Xlib_IDirectDrawSurface4Impl_Release,
2138 IDirectDrawSurface4Impl_AddAttachedSurface,
2139 IDirectDrawSurface4Impl_AddOverlayDirtyRect,
2140 IDirectDrawSurface4Impl_Blt,
2141 IDirectDrawSurface4Impl_BltBatch,
2142 IDirectDrawSurface4Impl_BltFast,
2143 IDirectDrawSurface4Impl_DeleteAttachedSurface,
2144 IDirectDrawSurface4Impl_EnumAttachedSurfaces,
2145 IDirectDrawSurface4Impl_EnumOverlayZOrders,
2146 Xlib_IDirectDrawSurface4Impl_Flip,
2147 IDirectDrawSurface4Impl_GetAttachedSurface,
2148 IDirectDrawSurface4Impl_GetBltStatus,
2149 IDirectDrawSurface4Impl_GetCaps,
2150 IDirectDrawSurface4Impl_GetClipper,
2151 IDirectDrawSurface4Impl_GetColorKey,
2152 IDirectDrawSurface4Impl_GetDC,
2153 IDirectDrawSurface4Impl_GetFlipStatus,
2154 IDirectDrawSurface4Impl_GetOverlayPosition,
2155 IDirectDrawSurface4Impl_GetPalette,
2156 IDirectDrawSurface4Impl_GetPixelFormat,
2157 IDirectDrawSurface4Impl_GetSurfaceDesc,
2158 IDirectDrawSurface4Impl_Initialize,
2159 IDirectDrawSurface4Impl_IsLost,
2160 IDirectDrawSurface4Impl_Lock,
2161 IDirectDrawSurface4Impl_ReleaseDC,
2162 IDirectDrawSurface4Impl_Restore,
2163 IDirectDrawSurface4Impl_SetClipper,
2164 IDirectDrawSurface4Impl_SetColorKey,
2165 IDirectDrawSurface4Impl_SetOverlayPosition,
2166 Xlib_IDirectDrawSurface4Impl_SetPalette,
2167 Xlib_IDirectDrawSurface4Impl_Unlock,
2168 IDirectDrawSurface4Impl_UpdateOverlay,
2169 IDirectDrawSurface4Impl_UpdateOverlayDisplay,
2170 IDirectDrawSurface4Impl_UpdateOverlayZOrder,
2171 IDirectDrawSurface4Impl_GetDDInterface,
2172 IDirectDrawSurface4Impl_PageLock,
2173 IDirectDrawSurface4Impl_PageUnlock,
2174 IDirectDrawSurface4Impl_SetSurfaceDesc,
2175 IDirectDrawSurface4Impl_SetPrivateData,
2176 IDirectDrawSurface4Impl_GetPrivateData,
2177 IDirectDrawSurface4Impl_FreePrivateData,
2178 IDirectDrawSurface4Impl_GetUniquenessValue,
2179 IDirectDrawSurface4Impl_ChangeUniquenessValue
2180 };
2181
2182 /******************************************************************************
2183 * DirectDrawCreateClipper (DDRAW.7)
2184 */
2185 HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags,
2186 LPDIRECTDRAWCLIPPER *lplpDDClipper,
2187 LPUNKNOWN pUnkOuter)
2188 {
2189 IDirectDrawClipperImpl** ilplpDDClipper=(IDirectDrawClipperImpl**)lplpDDClipper;
2190 TRACE("(%08lx,%p,%p)\n", dwFlags, ilplpDDClipper, pUnkOuter);
2191
2192 *ilplpDDClipper = (IDirectDrawClipperImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipperImpl));
2193 (*ilplpDDClipper)->lpvtbl = &ddclipvt;
2194 (*ilplpDDClipper)->ref = 1;
2195
2196 return DD_OK;
2197 }
2198
2199 /******************************************************************************
2200 * IDirectDrawClipper
2201 */
2202 static HRESULT WINAPI IDirectDrawClipperImpl_SetHwnd(
2203 LPDIRECTDRAWCLIPPER iface,DWORD x,HWND hwnd
2204 ) {
2205 ICOM_THIS(IDirectDrawClipperImpl,iface);
2206 FIXME("(%p)->SetHwnd(0x%08lx,0x%08lx),stub!\n",This,x,(DWORD)hwnd);
2207 return DD_OK;
2208 }
2209
2210 static ULONG WINAPI IDirectDrawClipperImpl_Release(LPDIRECTDRAWCLIPPER iface) {
2211 ICOM_THIS(IDirectDrawClipperImpl,iface);
2212 TRACE("(%p)->() decrementing from %lu.\n", This, This->ref );
2213
2214 This->ref--;
2215 if (This->ref)
2216 return This->ref;
2217 HeapFree(GetProcessHeap(),0,This);
2218 return S_OK;
2219 }
2220
2221 static HRESULT WINAPI IDirectDrawClipperImpl_GetClipList(
2222 LPDIRECTDRAWCLIPPER iface,LPRECT rects,LPRGNDATA lprgn,LPDWORD hmm
2223 ) {
2224 ICOM_THIS(IDirectDrawClipperImpl,iface);
2225 FIXME("(%p,%p,%p,%p),stub!\n",This,rects,lprgn,hmm);
2226 if (hmm) *hmm=0;
2227 return DD_OK;
2228 }
2229
2230 static HRESULT WINAPI IDirectDrawClipperImpl_SetClipList(
2231 LPDIRECTDRAWCLIPPER iface,LPRGNDATA lprgn,DWORD hmm
2232 ) {
2233 ICOM_THIS(IDirectDrawClipperImpl,iface);
2234 FIXME("(%p,%p,%ld),stub!\n",This,lprgn,hmm);
2235 return DD_OK;
2236 }
2237
2238 static HRESULT WINAPI IDirectDrawClipperImpl_QueryInterface(
2239 LPDIRECTDRAWCLIPPER iface,
2240 REFIID riid,
2241 LPVOID* ppvObj )
2242 {
2243 ICOM_THIS(IDirectDrawClipperImpl,iface);
2244 FIXME("(%p)->(%p,%p),stub!\n",This,riid,ppvObj);
2245 return OLE_E_ENUM_NOMORE;
2246 }
2247
2248 static ULONG WINAPI IDirectDrawClipperImpl_AddRef( LPDIRECTDRAWCLIPPER iface )
2249 {
2250 ICOM_THIS(IDirectDrawClipperImpl,iface);
2251 TRACE("(%p)->() incrementing from %lu.\n", This, This->ref );
2252 return ++(This->ref);
2253 }
2254
2255 static HRESULT WINAPI IDirectDrawClipperImpl_GetHWnd(
2256 LPDIRECTDRAWCLIPPER iface,
2257 HWND* HWndPtr )
2258 {
2259 ICOM_THIS(IDirectDrawClipperImpl,iface);
2260 FIXME("(%p)->(%p),stub!\n",This,HWndPtr);
2261 return DD_OK;
2262 }
2263
2264 static HRESULT WINAPI IDirectDrawClipperImpl_Initialize(
2265 LPDIRECTDRAWCLIPPER iface,
2266 LPDIRECTDRAW lpDD,
2267 DWORD dwFlags )
2268 {
2269 ICOM_THIS(IDirectDrawClipperImpl,iface);
2270 FIXME("(%p)->(%p,0x%08lx),stub!\n",This,lpDD,dwFlags);
2271 return DD_OK;
2272 }
2273
2274 static HRESULT WINAPI IDirectDrawClipperImpl_IsClipListChanged(
2275 LPDIRECTDRAWCLIPPER iface,
2276 BOOL* lpbChanged )
2277 {
2278 ICOM_THIS(IDirectDrawClipperImpl,iface);
2279 FIXME("(%p)->(%p),stub!\n",This,lpbChanged);
2280 return DD_OK;
2281 }
2282
2283 static ICOM_VTABLE(IDirectDrawClipper) ddclipvt =
2284 {
2285 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2286 IDirectDrawClipperImpl_QueryInterface,
2287 IDirectDrawClipperImpl_AddRef,
2288 IDirectDrawClipperImpl_Release,
2289 IDirectDrawClipperImpl_GetClipList,
2290 IDirectDrawClipperImpl_GetHWnd,
2291 IDirectDrawClipperImpl_Initialize,
2292 IDirectDrawClipperImpl_IsClipListChanged,
2293 IDirectDrawClipperImpl_SetClipList,
2294 IDirectDrawClipperImpl_SetHwnd
2295 };
2296
2297
2298 /******************************************************************************
2299 * IDirectDrawPalette
2300 */
2301 static HRESULT WINAPI IDirectDrawPaletteImpl_GetEntries(
2302 LPDIRECTDRAWPALETTE iface,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
2303 ) {
2304 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2305 int i;
2306
2307 TRACE("(%p)->GetEntries(%08lx,%ld,%ld,%p)\n",
2308 This,x,start,count,palent);
2309
2310 /* No palette created and not in depth-convertion mode -> BUG ! */
2311 if ((This->cm == None) &&
2312 (This->ddraw->d.palette_convert == NULL))
2313 {
2314 FIXME("app tried to read colormap for non-palettized mode\n");
2315 return DDERR_GENERIC;
2316 }
2317 for (i=0;i<count;i++) {
2318 palent[i].peRed = This->palents[start+i].peRed;
2319 palent[i].peBlue = This->palents[start+i].peBlue;
2320 palent[i].peGreen = This->palents[start+i].peGreen;
2321 palent[i].peFlags = This->palents[start+i].peFlags;
2322
2323 }
2324 return DD_OK;
2325 }
2326
2327 static HRESULT WINAPI Xlib_IDirectDrawPaletteImpl_SetEntries(
2328 LPDIRECTDRAWPALETTE iface,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
2329 ) {
2330 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2331 XColor xc;
2332 int i;
2333
2334 TRACE("(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
2335 This,x,start,count,palent
2336 );
2337 for (i=0;i<count;i++) {
2338 xc.red = palent[i].peRed<<8;
2339 xc.blue = palent[i].peBlue<<8;
2340 xc.green = palent[i].peGreen<<8;
2341 xc.flags = DoRed|DoBlue|DoGreen;
2342 xc.pixel = start+i;
2343
2344 if (This->cm)
2345 TSXStoreColor(display,This->cm,&xc);
2346
2347 This->palents[start+i].peRed = palent[i].peRed;
2348 This->palents[start+i].peBlue = palent[i].peBlue;
2349 This->palents[start+i].peGreen = palent[i].peGreen;
2350 This->palents[start+i].peFlags = palent[i].peFlags;
2351 }
2352
2353 /* Now, if we are in 'depth conversion mode', update the screen palette */
2354 /* FIXME: we need to update the image or we won't get palette fading. */
2355 if (This->ddraw->d.palette_convert != NULL)
2356 This->ddraw->d.palette_convert(palent, This->screen_palents, start, count);
2357
2358 return DD_OK;
2359 }
2360
2361 #ifdef HAVE_LIBXXF86DGA
2362 static HRESULT WINAPI DGA_IDirectDrawPaletteImpl_SetEntries(
2363 LPDIRECTDRAWPALETTE iface,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
2364 ) {
2365 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2366 XColor xc;
2367 Colormap cm;
2368 int i;
2369
2370 TRACE("(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
2371 This,x,start,count,palent
2372 );
2373 if (!This->cm) /* should not happen */ {
2374 FIXME("app tried to set colormap in non-palettized mode\n");
2375 return DDERR_GENERIC;
2376 }
2377 /* FIXME: free colorcells instead of freeing whole map */
2378 cm = This->cm;
2379 This->cm = TSXCopyColormapAndFree(display,This->cm);
2380 TSXFreeColormap(display,cm);
2381
2382 for (i=0;i<count;i++) {
2383 xc.red = palent[i].peRed<<8;
2384 xc.blue = palent[i].peBlue<<8;
2385 xc.green = palent[i].peGreen<<8;
2386 xc.flags = DoRed|DoBlue|DoGreen;
2387 xc.pixel = i+start;
2388
2389 TSXStoreColor(display,This->cm,&xc);
2390
2391 This->palents[start+i].peRed = palent[i].peRed;
2392 This->palents[start+i].peBlue = palent[i].peBlue;
2393 This->palents[start+i].peGreen = palent[i].peGreen;
2394 This->palents[start+i].peFlags = palent[i].peFlags;
2395 }
2396 TSXF86DGAInstallColormap(display,DefaultScreen(display),This->cm);
2397 return DD_OK;
2398 }
2399 #endif /* defined(HAVE_LIBXXF86DGA) */
2400
2401 static ULONG WINAPI IDirectDrawPaletteImpl_Release(LPDIRECTDRAWPALETTE iface) {
2402 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2403 TRACE("(%p)->() decrementing from %lu.\n", This, This->ref );
2404 if (!--(This->ref)) {
2405 if (This->cm) {
2406 TSXFreeColormap(display,This->cm);
2407 This->cm = 0;
2408 }
2409 HeapFree(GetProcessHeap(),0,This);
2410 return S_OK;
2411 }
2412 return This->ref;
2413 }
2414
2415 static ULONG WINAPI IDirectDrawPaletteImpl_AddRef(LPDIRECTDRAWPALETTE iface) {
2416 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2417
2418 TRACE("(%p)->() incrementing from %lu.\n", This, This->ref );
2419 return ++(This->ref);
2420 }
2421
2422 static HRESULT WINAPI IDirectDrawPaletteImpl_Initialize(
2423 LPDIRECTDRAWPALETTE iface,LPDIRECTDRAW ddraw,DWORD x,LPPALETTEENTRY palent
2424 ) {
2425 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2426 TRACE("(%p)->(%p,%ld,%p)\n", This, ddraw, x, palent);
2427
2428 return DDERR_ALREADYINITIALIZED;
2429 }
2430
2431 static HRESULT WINAPI IDirectDrawPaletteImpl_GetCaps(
2432 LPDIRECTDRAWPALETTE iface, LPDWORD lpdwCaps )
2433 {
2434 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2435 FIXME("(%p)->(%p) stub.\n", This, lpdwCaps );
2436 return DD_OK;
2437 }
2438
2439 static HRESULT WINAPI IDirectDrawPaletteImpl_QueryInterface(
2440 LPDIRECTDRAWPALETTE iface,REFIID refiid,LPVOID *obj )
2441 {
2442 ICOM_THIS(IDirectDrawPaletteImpl,iface);
2443 char xrefiid[50];
2444
2445 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2446 FIXME("(%p)->(%s,%p) stub.\n",This,xrefiid,obj);
2447
2448 return S_OK;
2449 }
2450
2451 #ifdef HAVE_LIBXXF86DGA
2452 static ICOM_VTABLE(IDirectDrawPalette) dga_ddpalvt =
2453 {
2454 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2455 IDirectDrawPaletteImpl_QueryInterface,
2456 IDirectDrawPaletteImpl_AddRef,
2457 IDirectDrawPaletteImpl_Release,
2458 IDirectDrawPaletteImpl_GetCaps,
2459 IDirectDrawPaletteImpl_GetEntries,
2460 IDirectDrawPaletteImpl_Initialize,
2461 DGA_IDirectDrawPaletteImpl_SetEntries
2462 };
2463 #endif /* defined(HAVE_LIBXXF86DGA) */
2464
2465 static ICOM_VTABLE(IDirectDrawPalette) xlib_ddpalvt =
2466 {
2467 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2468 IDirectDrawPaletteImpl_QueryInterface,
2469 IDirectDrawPaletteImpl_AddRef,
2470 IDirectDrawPaletteImpl_Release,
2471 IDirectDrawPaletteImpl_GetCaps,
2472 IDirectDrawPaletteImpl_GetEntries,
2473 IDirectDrawPaletteImpl_Initialize,
2474 Xlib_IDirectDrawPaletteImpl_SetEntries
2475 };
2476
2477 /*******************************************************************************
2478 * IDirect3D
2479 */
2480 static HRESULT WINAPI IDirect3DImpl_QueryInterface(
2481 LPDIRECT3D iface,REFIID refiid,LPVOID *obj
2482 ) {
2483 ICOM_THIS(IDirect3DImpl,iface);
2484 /* FIXME: Not sure if this is correct */
2485 char xrefiid[50];
2486
2487 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2488 TRACE("(%p)->(%s,%p)\n",This,xrefiid,obj);
2489 if ( ( IsEqualGUID( &IID_IDirectDraw, refiid ) ) ||
2490 ( IsEqualGUID (&IID_IDirectDraw2, refiid ) ) ||
2491 ( IsEqualGUID( &IID_IDirectDraw4, refiid ) ) ) {
2492 *obj = This->ddraw;
2493 IDirect3D_AddRef(iface);
2494
2495 TRACE(" Creating IDirectDrawX interface (%p)\n", *obj);
2496
2497 return S_OK;
2498 }
2499 if ( ( IsEqualGUID( &IID_IDirect3D, refiid ) ) ||
2500 ( IsEqualGUID( &IID_IUnknown, refiid ) ) ) {
2501 *obj = This;
2502 IDirect3D_AddRef(iface);
2503
2504 TRACE(" Creating IDirect3D interface (%p)\n", *obj);
2505
2506 return S_OK;
2507 }
2508 if ( IsEqualGUID( &IID_IDirect3D2, refiid ) ) {
2509 IDirect3D2Impl* d3d;
2510
2511 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
2512 d3d->ref = 1;
2513 d3d->ddraw = This->ddraw;
2514 IDirect3D_AddRef(iface);
2515 d3d->lpvtbl = &d3d2vt;
2516 *obj = d3d;
2517
2518 TRACE(" Creating IDirect3D2 interface (%p)\n", *obj);
2519
2520 return S_OK;
2521 }
2522 FIXME("(%p):interface for IID %s NOT found!\n",This,xrefiid);
2523 return OLE_E_ENUM_NOMORE;
2524 }
2525
2526 static ULONG WINAPI IDirect3DImpl_AddRef(LPDIRECT3D iface) {
2527 ICOM_THIS(IDirect3DImpl,iface);
2528 TRACE("(%p)->() incrementing from %lu.\n", This, This->ref );
2529
2530 return ++(This->ref);
2531 }
2532
2533 static ULONG WINAPI IDirect3DImpl_Release(LPDIRECT3D iface)
2534 {
2535 ICOM_THIS(IDirect3DImpl,iface);
2536 TRACE("(%p)->() decrementing from %lu.\n", This, This->ref );
2537
2538 if (!--(This->ref)) {
2539 IDirectDraw2_Release((IDirectDraw2*)This->ddraw);
2540 HeapFree(GetProcessHeap(),0,This);
2541 return S_OK;
2542 }
2543 return This->ref;
2544 }
2545
2546 static HRESULT WINAPI IDirect3DImpl_Initialize(
2547 LPDIRECT3D iface, REFIID refiid )
2548 {
2549 ICOM_THIS(IDirect3DImpl,iface);
2550 /* FIXME: Not sure if this is correct */
2551 char xrefiid[50];
2552
2553 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2554 FIXME("(%p)->(%s):stub.\n",This,xrefiid);
2555
2556 return DDERR_ALREADYINITIALIZED;
2557 }
2558
2559 static HRESULT WINAPI IDirect3DImpl_EnumDevices(LPDIRECT3D iface,
2560 LPD3DENUMDEVICESCALLBACK cb,
2561 LPVOID context) {
2562 ICOM_THIS(IDirect3DImpl,iface);
2563 FIXME("(%p)->(%p,%p),stub!\n",This,cb,context);
2564
2565 /* Call functions defined in d3ddevices.c */
2566 if (!d3d_OpenGL_dx3(cb, context))
2567 return DD_OK;
2568
2569 return DD_OK;
2570 }
2571
2572 static HRESULT WINAPI IDirect3DImpl_CreateLight(LPDIRECT3D iface,
2573 LPDIRECT3DLIGHT *lplight,
2574 IUnknown *lpunk)
2575 {
2576 ICOM_THIS(IDirect3DImpl,iface);
2577 TRACE("(%p)->(%p,%p): stub\n", This, lplight, lpunk);
2578
2579 /* Call the creation function that is located in d3dlight.c */
2580 *lplight = d3dlight_create_dx3(This);
2581
2582 return DD_OK;
2583 }
2584
2585 static HRESULT WINAPI IDirect3DImpl_CreateMaterial(LPDIRECT3D iface,
2586 LPDIRECT3DMATERIAL *lpmaterial,
2587 IUnknown *lpunk)
2588 {
2589 ICOM_THIS(IDirect3DImpl,iface);
2590 TRACE("(%p)->(%p,%p): stub\n", This, lpmaterial, lpunk);
2591
2592 /* Call the creation function that is located in d3dviewport.c */
2593 *lpmaterial = d3dmaterial_create(This);
2594
2595 return DD_OK;
2596 }
2597
2598 static HRESULT WINAPI IDirect3DImpl_CreateViewport(LPDIRECT3D iface,
2599 LPDIRECT3DVIEWPORT *lpviewport,
2600 IUnknown *lpunk)
2601 {
2602 ICOM_THIS(IDirect3DImpl,iface);
2603 TRACE("(%p)->(%p,%p): stub\n", This, lpviewport, lpunk);
2604
2605 /* Call the creation function that is located in d3dviewport.c */
2606 *lpviewport = d3dviewport_create(This);
2607
2608 return DD_OK;
2609 }
2610
2611 static HRESULT WINAPI IDirect3DImpl_FindDevice(LPDIRECT3D iface,
2612 LPD3DFINDDEVICESEARCH lpfinddevsrc,
2613 LPD3DFINDDEVICERESULT lpfinddevrst)
2614 {
2615 ICOM_THIS(IDirect3DImpl,iface);
2616 TRACE("(%p)->(%p,%p): stub\n", This, lpfinddevsrc, lpfinddevrst);
2617
2618 return DD_OK;
2619 }
2620
2621 static ICOM_VTABLE(IDirect3D) d3dvt =
2622 {
2623 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2624 IDirect3DImpl_QueryInterface,
2625 IDirect3DImpl_AddRef,
2626 IDirect3DImpl_Release,
2627 IDirect3DImpl_Initialize,
2628 IDirect3DImpl_EnumDevices,
2629 IDirect3DImpl_CreateLight,
2630 IDirect3DImpl_CreateMaterial,
2631 IDirect3DImpl_CreateViewport,
2632 IDirect3DImpl_FindDevice
2633 };
2634
2635 /*******************************************************************************
2636 * IDirect3D2
2637 */
2638 static HRESULT WINAPI IDirect3D2Impl_QueryInterface(
2639 LPDIRECT3D2 iface,REFIID refiid,LPVOID *obj) {
2640 ICOM_THIS(IDirect3D2Impl,iface);
2641
2642 /* FIXME: Not sure if this is correct */
2643 char xrefiid[50];
2644
2645 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2646 TRACE("(%p)->(%s,%p)\n",This,xrefiid,obj);
2647 if ( ( IsEqualGUID( &IID_IDirectDraw, refiid ) ) ||
2648 ( IsEqualGUID( &IID_IDirectDraw2, refiid ) ) ||
2649 ( IsEqualGUID( &IID_IDirectDraw4, refiid ) ) ) {
2650 *obj = This->ddraw;
2651 IDirect3D2_AddRef(iface);
2652
2653 TRACE(" Creating IDirectDrawX interface (%p)\n", *obj);
2654
2655 return S_OK;
2656 }
2657 if ( ( IsEqualGUID( &IID_IDirect3D2, refiid ) ) ||
2658 ( IsEqualGUID( &IID_IUnknown, refiid ) ) ) {
2659 *obj = This;
2660 IDirect3D2_AddRef(iface);
2661
2662 TRACE(" Creating IDirect3D2 interface (%p)\n", *obj);
2663
2664 return S_OK;
2665 }
2666 if ( IsEqualGUID( &IID_IDirect3D, refiid ) ) {
2667 IDirect3DImpl* d3d;
2668
2669 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
2670 d3d->ref = 1;
2671 d3d->ddraw = This->ddraw;
2672 IDirect3D2_AddRef(iface);
2673 d3d->lpvtbl = &d3dvt;
2674 *obj = d3d;
2675
2676 TRACE(" Creating IDirect3D interface (%p)\n", *obj);
2677
2678 return S_OK;
2679 }
2680 FIXME("(%p):interface for IID %s NOT found!\n",This,xrefiid);
2681 return OLE_E_ENUM_NOMORE;
2682 }
2683
2684 static ULONG WINAPI IDirect3D2Impl_AddRef(LPDIRECT3D2 iface) {
2685 ICOM_THIS(IDirect3D2Impl,iface);
2686 TRACE("(%p)->() incrementing from %lu.\n", This, This->ref );
2687
2688 return ++(This->ref);
2689 }
2690
2691 static ULONG WINAPI IDirect3D2Impl_Release(LPDIRECT3D2 iface) {
2692 ICOM_THIS(IDirect3D2Impl,iface);
2693 TRACE("(%p)->() decrementing from %lu.\n", This, This->ref );
2694
2695 if (!--(This->ref)) {
2696 IDirectDraw2_Release((IDirectDraw2*)This->ddraw);
2697 HeapFree(GetProcessHeap(),0,This);
2698 return S_OK;
2699 }
2700 return This->ref;
2701 }
2702
2703 static HRESULT WINAPI IDirect3D2Impl_EnumDevices(
2704 LPDIRECT3D2 iface,LPD3DENUMDEVICESCALLBACK cb, LPVOID context
2705 ) {
2706 ICOM_THIS(IDirect3D2Impl,iface);
2707 FIXME("(%p)->(%p,%p),stub!\n",This,cb,context);
2708
2709 /* Call functions defined in d3ddevices.c */
2710 if (!d3d_OpenGL(cb, context))
2711 return DD_OK;
2712
2713 return DD_OK;
2714 }
2715
2716 static HRESULT WINAPI IDirect3D2Impl_CreateLight(LPDIRECT3D2 iface,
2717 LPDIRECT3DLIGHT *lplight,
2718 IUnknown *lpunk)
2719 {
2720 ICOM_THIS(IDirect3D2Impl,iface);
2721 TRACE("(%p)->(%p,%p): stub\n", This, lplight, lpunk);
2722
2723 /* Call the creation function that is located in d3dlight.c */
2724 *lplight = d3dlight_create(This);
2725
2726 return DD_OK;
2727 }
2728
2729 static HRESULT WINAPI IDirect3D2Impl_CreateMaterial(LPDIRECT3D2 iface,
2730 LPDIRECT3DMATERIAL2 *lpmaterial,
2731 IUnknown *lpunk)
2732 {
2733 ICOM_THIS(IDirect3D2Impl,iface);
2734 TRACE("(%p)->(%p,%p): stub\n", This, lpmaterial, lpunk);
2735
2736 /* Call the creation function that is located in d3dviewport.c */
2737 *lpmaterial = d3dmaterial2_create(This);
2738
2739 return DD_OK;
2740 }
2741
2742 static HRESULT WINAPI IDirect3D2Impl_CreateViewport(LPDIRECT3D2 iface,
2743 LPDIRECT3DVIEWPORT2 *lpviewport,
2744 IUnknown *lpunk)
2745 {
2746 ICOM_THIS(IDirect3D2Impl,iface);
2747 TRACE("(%p)->(%p,%p): stub\n", This, lpviewport, lpunk);
2748
2749 /* Call the creation function that is located in d3dviewport.c */
2750 *lpviewport = d3dviewport2_create(This);
2751
2752 return DD_OK;
2753 }
2754
2755 static HRESULT WINAPI IDirect3D2Impl_FindDevice(LPDIRECT3D2 iface,
2756 LPD3DFINDDEVICESEARCH lpfinddevsrc,
2757 LPD3DFINDDEVICERESULT lpfinddevrst)
2758 {
2759 ICOM_THIS(IDirect3D2Impl,iface);
2760 TRACE("(%p)->(%p,%p): stub\n", This, lpfinddevsrc, lpfinddevrst);
2761
2762 return DD_OK;
2763 }
2764
2765 static HRESULT WINAPI IDirect3D2Impl_CreateDevice(LPDIRECT3D2 iface,
2766 REFCLSID rguid,
2767 LPDIRECTDRAWSURFACE surface,
2768 LPDIRECT3DDEVICE2 *device)
2769 {
2770 ICOM_THIS(IDirect3D2Impl,iface);
2771 char xbuf[50];
2772
2773 WINE_StringFromCLSID(rguid,xbuf);
2774 FIXME("(%p)->(%s,%p,%p): stub\n",This,xbuf,surface,device);
2775
2776 if (is_OpenGL(rguid, (IDirectDrawSurfaceImpl*)surface, (IDirect3DDevice2Impl**)device, This)) {
2777 IDirect3D2_AddRef(iface);
2778 return DD_OK;
2779 }
2780
2781 return DDERR_INVALIDPARAMS;
2782 }
2783
2784 static ICOM_VTABLE(IDirect3D2) d3d2vt =
2785 {
2786 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2787 IDirect3D2Impl_QueryInterface,
2788 IDirect3D2Impl_AddRef,
2789 IDirect3D2Impl_Release,
2790 IDirect3D2Impl_EnumDevices,
2791 IDirect3D2Impl_CreateLight,
2792 IDirect3D2Impl_CreateMaterial,
2793 IDirect3D2Impl_CreateViewport,
2794 IDirect3D2Impl_FindDevice,
2795 IDirect3D2Impl_CreateDevice
2796 };
2797
2798 /*******************************************************************************
2799 * IDirectDraw
2800 */
2801
2802 /* Used in conjunction with cbWndExtra for storage of the this ptr for the window.
2803 * Please adjust allocation in Xlib_DirectDrawCreate if you store more data here.
2804 */
2805 static INT ddrawXlibThisOffset = 0;
2806
2807 static HRESULT common_off_screen_CreateSurface(IDirectDraw2Impl* This,
2808 IDirectDrawSurfaceImpl* lpdsf)
2809 {
2810 int bpp;
2811
2812 /* The surface was already allocated when entering in this function */
2813 TRACE("using system memory for a surface (%p) \n", lpdsf);
2814
2815 if (lpdsf->s.surface_desc.dwFlags & DDSD_ZBUFFERBITDEPTH) {
2816 /* This is a Z Buffer */
2817 TRACE("Creating Z-Buffer of %ld bit depth\n", lpdsf->s.surface_desc.x.dwZBufferBitDepth);
2818 bpp = lpdsf->s.surface_desc.x.dwZBufferBitDepth / 8;
2819 } else {
2820 /* This is a standard image */
2821 if (!(lpdsf->s.surface_desc.dwFlags & DDSD_PIXELFORMAT)) {
2822 /* No pixel format => use DirectDraw's format */
2823 lpdsf->s.surface_desc.ddpfPixelFormat = This->d.directdraw_pixelformat;
2824 lpdsf->s.surface_desc.dwFlags |= DDSD_PIXELFORMAT;
2825 }
2826
2827 bpp = GET_BPP(lpdsf->s.surface_desc);
2828 }
2829
2830 if (lpdsf->s.surface_desc.dwFlags & DDSD_LPSURFACE) {
2831 /* The surface was preallocated : seems that we have nothing to do :-) */
2832 WARN("Creates a surface that is already allocated : assuming this is an application bug !\n");
2833 }
2834
2835 lpdsf->s.surface_desc.dwFlags |= DDSD_PITCH|DDSD_LPSURFACE;
2836 lpdsf->s.surface_desc.y.lpSurface =
2837 (LPBYTE)HeapAlloc(GetProcessHeap(),0,lpdsf->s.surface_desc.dwWidth * lpdsf->s.surface_desc.dwHeight * bpp);
2838 lpdsf->s.surface_desc.lPitch = lpdsf->s.surface_desc.dwWidth * bpp;
2839
2840 return DD_OK;
2841 }
2842
2843 #ifdef HAVE_LIBXXF86DGA
2844 static HRESULT WINAPI DGA_IDirectDraw2Impl_CreateSurface(
2845 LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
2846 ) {
2847 ICOM_THIS(IDirectDraw2Impl,iface);
2848 IDirectDrawSurfaceImpl** ilpdsf=(IDirectDrawSurfaceImpl**)lpdsf;
2849 int i, fbheight = This->e.dga.fb_height;
2850
2851 TRACE("(%p)->(%p,%p,%p)\n",This,lpddsd,ilpdsf,lpunk);
2852 if (TRACE_ON(ddraw)) { _dump_surface_desc(lpddsd); }
2853
2854 *ilpdsf = (IDirectDrawSurfaceImpl*)HeapAlloc(
2855 GetProcessHeap(),
2856 HEAP_ZERO_MEMORY,
2857 sizeof(IDirectDrawSurfaceImpl)
2858 );
2859 IDirectDraw2_AddRef(iface);
2860
2861 (*ilpdsf)->ref = 1;
2862 (*ilpdsf)->lpvtbl = (ICOM_VTABLE(IDirectDrawSurface)*)&dga_dds4vt;
2863 (*ilpdsf)->s.ddraw = This;
2864 (*ilpdsf)->s.palette = NULL;
2865 (*ilpdsf)->t.dga.fb_height = -1; /* This is to have non-on screen surfaces freed */
2866
2867 /* Copy the surface description */
2868 (*ilpdsf)->s.surface_desc = *lpddsd;
2869
2870 if (!(lpddsd->dwFlags & DDSD_WIDTH))
2871 (*ilpdsf)->s.surface_desc.dwWidth = This->d.width;
2872 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
2873 (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
2874
2875 (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT;
2876
2877 /* Check if this a 'primary surface' or not */
2878 if ((lpddsd->dwFlags & DDSD_CAPS) &&
2879 (lpddsd->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {
2880 /* This is THE primary surface => there is DGA-specific code */
2881
2882 /* First, store the surface description */
2883 (*ilpdsf)->s.surface_desc = *lpddsd;
2884
2885 /* Find a viewport */
2886 for (i=0;i<32;i++)
2887 if (!(This->e.dga.vpmask & (1<<i)))
2888 break;
2889 TRACE("using viewport %d for a primary surface\n",i);
2890 /* if i == 32 or maximum ... return error */
2891 This->e.dga.vpmask|=(1<<i);
2892 lpddsd->lPitch = (*ilpdsf)->s.surface_desc.lPitch =
2893 This->e.dga.fb_width*PFGET_BPP(This->d.directdraw_pixelformat);
2894
2895 (*ilpdsf)->s.surface_desc.y.lpSurface =
2896 This->e.dga.fb_addr + i*fbheight*lpddsd->lPitch;
2897
2898 (*ilpdsf)->t.dga.fb_height = i*fbheight;
2899
2900 /* Add flags if there were not present */
2901 (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_LPSURFACE|DDSD_PIXELFORMAT;
2902 (*ilpdsf)->s.surface_desc.dwWidth = This->d.width;
2903 (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
2904 TRACE("primary surface: dwWidth=%ld, dwHeight=%ld, lPitch=%ld\n",This->d.width,This->d.height,lpddsd->lPitch);
2905 /* We put our surface always in video memory */
2906 SDDSCAPS((*ilpdsf)) |= DDSCAPS_VISIBLE|DDSCAPS_VIDEOMEMORY;
2907 (*ilpdsf)->s.surface_desc.ddpfPixelFormat = This->d.directdraw_pixelformat;
2908 (*ilpdsf)->s.chain = NULL;
2909
2910 if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
2911 IDirectDrawSurface4Impl* back;
2912 int bbc;
2913
2914 for (bbc=lpddsd->dwBackBufferCount;bbc--;) {
2915 int i;
2916
2917 back = (IDirectDrawSurface4Impl*)HeapAlloc(
2918 GetProcessHeap(),
2919 HEAP_ZERO_MEMORY,
2920 sizeof(IDirectDrawSurface4Impl)
2921 );
2922 IDirectDraw2_AddRef(iface);
2923 back->ref = 1;
2924 back->lpvtbl = (ICOM_VTABLE(IDirectDrawSurface4)*)&dga_dds4vt;
2925 for (i=0;i<32;i++)
2926 if (!(This->e.dga.vpmask & (1<<i)))
2927 break;
2928 TRACE("using viewport %d for backbuffer %d\n",i, bbc);
2929 /* if i == 32 or maximum ... return error */
2930 This->e.dga.vpmask|=(1<<i);
2931 back->t.dga.fb_height = i*fbheight;
2932 /* Copy the surface description from the front buffer */
2933 back->s.surface_desc = (*ilpdsf)->s.surface_desc;
2934 /* Change the parameters that are not the same */
2935 back->s.surface_desc.y.lpSurface =
2936 This->e.dga.fb_addr + i*fbheight*lpddsd->lPitch;
2937
2938 back->s.ddraw = This;
2939 /* Add relevant info to front and back buffers */
2940 /* FIXME: backbuffer/frontbuffer handling broken here, but
2941 * will be fixed up in _Flip().
2942 */
2943 SDDSCAPS((*ilpdsf)) |= DDSCAPS_FRONTBUFFER;
2944 SDDSCAPS(back) |= DDSCAPS_FLIP|DDSCAPS_BACKBUFFER|DDSCAPS_VIDEOMEMORY;
2945 back->s.surface_desc.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
2946 SDDSCAPS(back) &= ~DDSCAPS_VISIBLE;
2947 IDirectDrawSurface4_AddAttachedSurface((LPDIRECTDRAWSURFACE4)(*ilpdsf),(LPDIRECTDRAWSURFACE4)back);
2948 }
2949 }
2950 } else {
2951 /* There is no DGA-specific code here...
2952 Go to the common surface creation function */
2953 return common_off_screen_CreateSurface(This, *ilpdsf);
2954 }
2955 return DD_OK;
2956 }
2957 #endif /* defined(HAVE_LIBXXF86DGA) */
2958
2959 #ifdef HAVE_LIBXXSHM
2960 /* Error handlers for Image creation */
2961 static int XShmErrorHandler(Display *dpy, XErrorEvent *event) {
2962 XShmErrorFlag = 1;
2963 return 0;
2964 }
2965
2966 static XImage *create_xshmimage(IDirectDraw2Impl* This, IDirectDrawSurface4Impl* lpdsf) {
2967 XImage *img;
2968 int (*WineXHandler)(Display *, XErrorEvent *);
2969
2970 img = TSXShmCreateImage(display,
2971 DefaultVisualOfScreen(X11DRV_GetXScreen()),
2972 This->d.pixmap_depth,
2973 ZPixmap,
2974 NULL,
2975 &(lpdsf->t.xlib.shminfo),
2976 lpdsf->s.surface_desc.dwWidth,
2977 lpdsf->s.surface_desc.dwHeight
2978 );
2979
2980 if (img == NULL) {
2981 FIXME("Couldn't create XShm image (due to X11 remote display or failure).\nReverting to standard X images !\n");
2982 This->e.xlib.xshm_active = 0;
2983 return NULL;
2984 }
2985
2986 lpdsf->t.xlib.shminfo.shmid = shmget( IPC_PRIVATE, img->bytes_per_line * img->height, IPC_CREAT|0777 );
2987 if (lpdsf->t.xlib.shminfo.shmid < 0) {
2988 FIXME("Couldn't create shared memory segment (due to X11 remote display or failure).\nReverting to standard X images !\n");
2989 This->e.xlib.xshm_active = 0;
2990 TSXDestroyImage(img);
2991 return NULL;
2992 }
2993
2994 lpdsf->t.xlib.shminfo.shmaddr = img->data = (char*)shmat(lpdsf->t.xlib.shminfo.shmid, 0, 0);
2995
2996 if (img->data == (char *) -1) {
2997 FIXME("Couldn't attach shared memory segment (due to X11 remote display or failure).\nReverting to standard X images !\n");
2998 This->e.xlib.xshm_active = 0;
2999 TSXDestroyImage(img);
3000 shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
3001 return NULL;
3002 }
3003 lpdsf->t.xlib.shminfo.readOnly = False;
3004
3005 /* This is where things start to get trickier....
3006 * First, we flush the current X connections to be sure to catch all
3007 * non-XShm related errors
3008 */
3009 TSXSync(display, False);
3010 /* Then we enter in the non-thread safe part of the tests */
3011 EnterCriticalSection( &X11DRV_CritSection );
3012
3013 /* Reset the error flag, sets our new error handler and try to attach
3014 * the surface
3015 */
3016 XShmErrorFlag = 0;
3017 WineXHandler = XSetErrorHandler(XShmErrorHandler);
3018 XShmAttach(display, &(lpdsf->t.xlib.shminfo));
3019 XSync(display, False);
3020
3021 /* Check the error flag */
3022 if (XShmErrorFlag) {
3023 /* An error occured */
3024 XFlush(display);
3025 XShmErrorFlag = 0;
3026 XDestroyImage(img);
3027 shmdt(lpdsf->t.xlib.shminfo.shmaddr);
3028 shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
3029 XSetErrorHandler(WineXHandler);
3030
3031 FIXME("Couldn't attach shared memory segment to X server (due to X11 remote display or failure).\nReverting to standard X images !\n");
3032 This->e.xlib.xshm_active = 0;
3033
3034 /* Leave the critical section */
3035 LeaveCriticalSection( &X11DRV_CritSection );
3036 return NULL;
3037 }
3038 /* Here, to be REALLY sure, I should do a XShmPutImage to check if
3039 * this works, but it may be a bit overkill....
3040 */
3041 XSetErrorHandler(WineXHandler);
3042 LeaveCriticalSection( &X11DRV_CritSection );
3043
3044 shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
3045
3046 if (This->d.pixel_convert != NULL) {
3047 lpdsf->s.surface_desc.y.lpSurface = HeapAlloc(
3048 GetProcessHeap(),
3049 HEAP_ZERO_MEMORY,
3050 lpdsf->s.surface_desc.dwWidth *
3051 lpdsf->s.surface_desc.dwHeight *
3052 PFGET_BPP(This->d.directdraw_pixelformat)
3053 );
3054 } else {
3055 lpdsf->s.surface_desc.y.lpSurface = img->data;
3056 }
3057 return img;
3058 }
3059 #endif /* HAVE_LIBXXSHM */
3060
3061 static XImage *create_ximage(IDirectDraw2Impl* This, IDirectDrawSurface4Impl* lpdsf) {
3062 XImage *img = NULL;
3063 void *img_data;
3064
3065 #ifdef HAVE_LIBXXSHM
3066 if (This->e.xlib.xshm_active)
3067 img = create_xshmimage(This, lpdsf);
3068
3069 if (img == NULL) {
3070 #endif
3071 /* Allocate surface memory */
3072 lpdsf->s.surface_desc.y.lpSurface = HeapAlloc(
3073 GetProcessHeap(),HEAP_ZERO_MEMORY,
3074 lpdsf->s.surface_desc.dwWidth *
3075 lpdsf->s.surface_desc.dwHeight *
3076 PFGET_BPP(This->d.directdraw_pixelformat)
3077 );
3078
3079 if (This->d.pixel_convert != NULL) {
3080 img_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
3081 lpdsf->s.surface_desc.dwWidth *
3082 lpdsf->s.surface_desc.dwHeight *
3083 PFGET_BPP(This->d.screen_pixelformat)
3084 );
3085 } else {
3086 img_data = lpdsf->s.surface_desc.y.lpSurface;
3087 }
3088
3089 /* In this case, create an XImage */
3090 img = TSXCreateImage(display,
3091 DefaultVisualOfScreen(X11DRV_GetXScreen()),
3092 This->d.pixmap_depth,
3093 ZPixmap,
3094 0,
3095 img_data,
3096 lpdsf->s.surface_desc.dwWidth,
3097 lpdsf->s.surface_desc.dwHeight,
3098 32,
3099 lpdsf->s.surface_desc.dwWidth* PFGET_BPP(This->d.screen_pixelformat)
3100 );
3101 #ifdef HAVE_LIBXXSHM
3102 }
3103 #endif
3104 if (This->d.pixel_convert != NULL)
3105 lpdsf->s.surface_desc.lPitch = PFGET_BPP(This->d.directdraw_pixelformat) * lpdsf->s.surface_desc.dwWidth;
3106 else
3107 lpdsf->s.surface_desc.lPitch = img->bytes_per_line;
3108 return img;
3109 }
3110
3111 static HRESULT WINAPI Xlib_IDirectDraw2Impl_CreateSurface(
3112 LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
3113 ) {
3114 ICOM_THIS(IDirectDraw2Impl,iface);
3115 IDirectDrawSurfaceImpl** ilpdsf=(IDirectDrawSurfaceImpl**)lpdsf;
3116
3117 TRACE("(%p)->CreateSurface(%p,%p,%p)\n", This,lpddsd,ilpdsf,lpunk);
3118
3119 if (TRACE_ON(ddraw)) { _dump_surface_desc(lpddsd); }
3120
3121 *ilpdsf = (IDirectDrawSurfaceImpl*)HeapAlloc(
3122 GetProcessHeap(),HEAP_ZERO_MEMORY, sizeof(IDirectDrawSurfaceImpl)
3123 );
3124
3125 IDirectDraw2_AddRef(iface);
3126
3127 (*ilpdsf)->s.ddraw = This;
3128 (*ilpdsf)->ref = 1;
3129 (*ilpdsf)->lpvtbl = (ICOM_VTABLE(IDirectDrawSurface)*)&xlib_dds4vt;
3130 (*ilpdsf)->s.palette = NULL;
3131 (*ilpdsf)->t.xlib.image = NULL; /* This is for off-screen buffers */
3132
3133 /* Copy the surface description */
3134 (*ilpdsf)->s.surface_desc = *lpddsd;
3135
3136 if (!(lpddsd->dwFlags & DDSD_WIDTH))
3137 (*ilpdsf)->s.surface_desc.dwWidth = This->d.width;
3138 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
3139 (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
3140 (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT;
3141
3142 /* Check if this a 'primary surface' or not */
3143 if ((lpddsd->dwFlags & DDSD_CAPS) &&
3144 (lpddsd->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {
3145 XImage *img;
3146
3147 TRACE("using standard XImage for a primary surface (%p)\n", *ilpdsf);
3148 /* Create the XImage */
3149 img = create_ximage(This, (IDirectDrawSurface4Impl*) *ilpdsf);
3150 if (img == NULL)
3151 return DDERR_OUTOFMEMORY;
3152 (*ilpdsf)->t.xlib.image = img;
3153
3154 /* Add flags if there were not present */
3155 (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_LPSURFACE|DDSD_PIXELFORMAT;
3156 (*ilpdsf)->s.surface_desc.dwWidth = This->d.width;
3157 (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
3158 (*ilpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VISIBLE|DDSCAPS_VIDEOMEMORY;
3159 (*ilpdsf)->s.surface_desc.ddpfPixelFormat = This->d.directdraw_pixelformat;
3160
3161 /* Check for backbuffers */
3162 if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
3163 IDirectDrawSurface4Impl* back;
3164 XImage *img;
3165 int i;
3166
3167 for (i=lpddsd->dwBackBufferCount;i--;) {
3168 back = (IDirectDrawSurface4Impl*)HeapAlloc(
3169 GetProcessHeap(),HEAP_ZERO_MEMORY,
3170 sizeof(IDirectDrawSurface4Impl)
3171 );
3172
3173 TRACE("allocated back-buffer (%p)\n", back);
3174
3175 IDirectDraw2_AddRef(iface);
3176 back->s.ddraw = This;
3177
3178 back->ref = 1;
3179 back->lpvtbl = (ICOM_VTABLE(IDirectDrawSurface4)*)&xlib_dds4vt;
3180 /* Copy the surface description from the front buffer */
3181 back->s.surface_desc = (*ilpdsf)->s.surface_desc;
3182
3183 /* Create the XImage */
3184 img = create_ximage(This, back);
3185 if (img == NULL)
3186 return DDERR_OUTOFMEMORY;
3187 back->t.xlib.image = img;
3188
3189 /* Add relevant info to front and back buffers */
3190 /* FIXME: backbuffer/frontbuffer handling broken here, but
3191 * will be fixed up in _Flip().
3192 */
3193 SDDSCAPS((*ilpdsf)) |= DDSCAPS_FRONTBUFFER;
3194 SDDSCAPS(back) |= DDSCAPS_BACKBUFFER|DDSCAPS_VIDEOMEMORY|DDSCAPS_FLIP;
3195 back->s.surface_desc.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
3196 SDDSCAPS(back) &= ~DDSCAPS_VISIBLE;
3197 IDirectDrawSurface4_AddAttachedSurface((LPDIRECTDRAWSURFACE4)(*ilpdsf),(LPDIRECTDRAWSURFACE4)back);
3198 }
3199 }
3200 } else {
3201 /* There is no Xlib-specific code here...
3202 Go to the common surface creation function */
3203 return common_off_screen_CreateSurface(This, *ilpdsf);
3204 }
3205 return DD_OK;
3206 }
3207
3208 static HRESULT WINAPI IDirectDraw2Impl_DuplicateSurface(
3209 LPDIRECTDRAW2 iface,LPDIRECTDRAWSURFACE src,LPDIRECTDRAWSURFACE *dst
3210 ) {
3211 ICOM_THIS(IDirectDraw2Impl,iface);
3212 FIXME("(%p)->(%p,%p) simply copies\n",This,src,dst);
3213 *dst = src; /* FIXME */
3214 return DD_OK;
3215 }
3216
3217 /*
3218 * The Xlib Implementation tries to use the passed hwnd as drawing window,
3219 * even when the approbiate bitmasks are not specified.
3220 */
3221 static HRESULT WINAPI IDirectDraw2Impl_SetCooperativeLevel(
3222 LPDIRECTDRAW2 iface,HWND hwnd,DWORD cooplevel
3223 ) {
3224 ICOM_THIS(IDirectDraw2Impl,iface);
3225 /*
3226 int i;
3227 const struct {
3228 int mask;
3229 char *name;
3230 } flagmap[] = {
3231 #define FE(x) { x, #x},
3232 FE(DDSCL_FULLSCREEN)
3233 FE(DDSCL_ALLOWREBOOT)
3234 FE(DDSCL_NOWINDOWCHANGES)
3235 FE(DDSCL_NORMAL)
3236 FE(DDSCL_ALLOWMODEX)
3237 FE(DDSCL_EXCLUSIVE)
3238 FE(DDSCL_SETFOCUSWINDOW)
3239 FE(DDSCL_SETDEVICEWINDOW)
3240 FE(DDSCL_CREATEDEVICEWINDOW)
3241 #undef FE
3242 };
3243 */
3244
3245 FIXME("(%p)->(%08lx,%08lx)\n",This,(DWORD)hwnd,cooplevel);
3246 This->d.mainWindow = hwnd;
3247
3248 /* This will be overwritten in the case of Full Screen mode.
3249 Windowed games could work with that :-) */
3250 if (hwnd)
3251 {
3252 WND *tmpWnd = WIN_FindWndPtr(hwnd);
3253 This->d.drawable = X11DRV_WND_GetXWindow(tmpWnd);
3254 WIN_ReleaseWndPtr(tmpWnd);
3255
3256 if( !This->d.drawable ) {
3257 This->d.drawable = ((X11DRV_WND_DATA *) WIN_GetDesktop()->pDriverData)->window;
3258 WIN_ReleaseDesktop();
3259 }
3260 TRACE("Setting drawable to %ld\n", This->d.drawable);
3261 }
3262
3263 return DD_OK;
3264 }
3265
3266 /* Small helper to either use the cooperative window or create a new
3267 * one (for mouse and keyboard input) and drawing in the Xlib implementation.
3268 */
3269 static void _common_IDirectDrawImpl_SetDisplayMode(IDirectDrawImpl* This) {
3270 RECT rect;
3271
3272 /* Do not destroy the application supplied cooperative window */
3273 if (This->d.window && This->d.window != This->d.mainWindow) {
3274 DestroyWindow(This->d.window);
3275 This->d.window = 0;
3276 }
3277 /* Sanity check cooperative window before assigning it to drawing. */
3278 if ( IsWindow(This->d.mainWindow) &&
3279 IsWindowVisible(This->d.mainWindow)
3280 ) {
3281 /* if it does not fit, resize the cooperative window.
3282 * and hope the app likes it
3283 */
3284 GetWindowRect(This->d.mainWindow,&rect);
3285 if ((((rect.right-rect.left) >= This->d.width) &&
3286 ((rect.bottom-rect.top) >= This->d.height))
3287 )
3288 This->d.window = This->d.mainWindow;
3289 /*SetWindowPos(This->d.mainWindow,HWND_TOPMOST,0,0,This->d.width,This->d.height,SWP_NOMOVE|SWP_NOOWNERZORDER);*/
3290
3291
3292 }
3293 /* ... failed, create new one. */
3294 if (!This->d.window) {
3295 This->d.window = CreateWindowExA(
3296 0,
3297 "WINE_DirectDraw",
3298 "WINE_DirectDraw",
3299 WS_VISIBLE|WS_SYSMENU|WS_THICKFRAME,
3300 0,0,
3301 This->d.width,
3302 This->d.height,
3303 0,
3304 0,
3305 0,
3306 NULL
3307 );
3308 /*Store THIS with the window. We'll use it in the window procedure*/
3309 SetWindowLongA(This->d.window,ddrawXlibThisOffset,(LONG)This);
3310 ShowWindow(This->d.window,TRUE);
3311 UpdateWindow(This->d.window);
3312 }
3313 SetFocus(This->d.window);
3314 }
3315
3316 static int _common_depth_to_pixelformat(DWORD depth,
3317 DDPIXELFORMAT *pixelformat,
3318 DDPIXELFORMAT *screen_pixelformat,
3319 int *pix_depth) {
3320 XVisualInfo *vi;
3321 XPixmapFormatValues *pf;
3322 XVisualInfo vt;
3323 int nvisuals, npixmap, i;
3324 int match = 0;
3325 int index = -2;
3326
3327 vi = TSXGetVisualInfo(display, VisualNoMask, &vt, &nvisuals);
3328 pf = XListPixmapFormats(display, &npixmap);
3329
3330 for (i = 0; i < npixmap; i++) {
3331 if (pf[i].depth == depth) {
3332 int j;
3333
3334 for (j = 0; j < nvisuals; j++) {
3335 if (vi[j].depth == pf[i].depth) {
3336 pixelformat->dwSize = sizeof(*pixelformat);
3337 if (depth == 8) {
3338 pixelformat->dwFlags = DDPF_PALETTEINDEXED8;
3339 pixelformat->y.dwRBitMask = 0;
3340 pixelformat->z.dwGBitMask = 0;
3341 pixelformat->xx.dwBBitMask = 0;
3342 } else {
3343 pixelformat->dwFlags = DDPF_RGB;
3344 pixelformat->y.dwRBitMask = vi[j].red_mask;
3345 pixelformat->z.dwGBitMask = vi[j].green_mask;
3346 pixelformat->xx.dwBBitMask = vi[j].blue_mask;
3347 }
3348 pixelformat->dwFourCC = 0;
3349 pixelformat->x.dwRGBBitCount = pf[i].bits_per_pixel;
3350 pixelformat->xy.dwRGBAlphaBitMask= 0;
3351
3352 *screen_pixelformat = *pixelformat;
3353
3354 if (pix_depth != NULL)
3355 *pix_depth = vi[j].depth;
3356
3357 match = 1;
3358 index = -1;
3359
3360 goto clean_up_and_exit;
3361 }
3362 }
3363
3364 ERR("No visual corresponding to pixmap format !\n");
3365 }
3366 }
3367
3368 if (match == 0) {
3369 /* We try now to find an emulated mode */
3370 int c;
3371
3372 for (c = 0; c < sizeof(ModeEmulations) / sizeof(Convert); c++) {
3373 if (ModeEmulations[c].dest.depth == depth) {
3374 /* Found an emulation function, now tries to find a matching visual / pixel format pair */
3375 for (i = 0; i < npixmap; i++) {
3376 if ((pf[i].depth == ModeEmulations[c].screen.depth) &&
3377 (pf[i].bits_per_pixel == ModeEmulations[c].screen.bpp)) {
3378 int j;
3379
3380 for (j = 0; j < nvisuals; j++) {
3381 if (vi[j].depth == pf[i].depth) {
3382 screen_pixelformat->dwSize = sizeof(*screen_pixelformat);
3383 screen_pixelformat->dwFlags = DDPF_RGB;
3384 screen_pixelformat->dwFourCC = 0;
3385 screen_pixelformat->x.dwRGBBitCount = pf[i].bits_per_pixel;
3386 screen_pixelformat->y.dwRBitMask = vi[j].red_mask;
3387 screen_pixelformat->z.dwGBitMask = vi[j].green_mask;
3388 screen_pixelformat->xx.dwBBitMask = vi[j].blue_mask;
3389 screen_pixelformat->xy.dwRGBAlphaBitMask= 0;
3390
3391 pixelformat->dwSize = sizeof(*pixelformat);
3392 pixelformat->dwFourCC = 0;
3393 if (depth == 8) {
3394 pixelformat->dwFlags = DDPF_PALETTEINDEXED8;
3395 pixelformat->x.dwRGBBitCount = 8;
3396 pixelformat->y.dwRBitMask = 0;
3397 pixelformat->z.dwGBitMask = 0;
3398 pixelformat->xx.dwBBitMask = 0;
3399 } else {
3400 pixelformat->dwFlags = DDPF_RGB;
3401 pixelformat->x.dwRGBBitCount = ModeEmulations[c].dest.bpp;
3402 pixelformat->y.dwRBitMask = ModeEmulations[c].dest.rmask;
3403 pixelformat->z.dwGBitMask = ModeEmulations[c].dest.gmask;
3404 pixelformat->xx.dwBBitMask = ModeEmulations[c].dest.bmask;
3405 }
3406 pixelformat->xy.dwRGBAlphaBitMask= 0;
3407
3408 if (pix_depth != NULL)
3409 *pix_depth = vi[j].depth;
3410
3411 match = 2;
3412 index = c;
3413
3414 goto clean_up_and_exit;
3415 }
3416
3417 ERR("No visual corresponding to pixmap format !\n");
3418 }
3419 }
3420 }
3421 }
3422 }
3423 }
3424
3425 clean_up_and_exit:
3426 TSXFree(vi);
3427 TSXFree(pf);
3428
3429 return index;
3430 }
3431
3432 #ifdef HAVE_LIBXXF86DGA
3433 static HRESULT WINAPI DGA_IDirectDrawImpl_SetDisplayMode(
3434 LPDIRECTDRAW iface,DWORD width,DWORD height,DWORD depth
3435 ) {
3436 ICOM_THIS(IDirectDrawImpl,iface);
3437 int i,mode_count;
3438
3439 TRACE("(%p)->(%ld,%ld,%ld)\n", This, width, height, depth);
3440
3441 /* We hope getting the asked for depth */
3442 if (_common_depth_to_pixelformat(depth, &(This->d.directdraw_pixelformat), &(This->d.screen_pixelformat), NULL) != -1) {
3443 /* I.e. no visual found or emulated */
3444 ERR("(w=%ld,h=%ld,d=%ld), unsupported depth!\n",width,height,depth);
3445 return DDERR_UNSUPPORTEDMODE;
3446 }
3447
3448 if (This->d.width < width) {
3449 ERR("SetDisplayMode(w=%ld,h=%ld,d=%ld), width %ld exceeds framebuffer width %ld\n",width,height,depth,width,This->d.width);
3450 return DDERR_UNSUPPORTEDMODE;
3451 }
3452 This->d.width = width;
3453 This->d.height = height;
3454
3455 /* adjust fb_height, so we don't overlap */
3456 if (This->e.dga.fb_height < height)
3457 This->e.dga.fb_height = height;
3458 _common_IDirectDrawImpl_SetDisplayMode(This);
3459
3460 #ifdef HAVE_LIBXXF86VM
3461 {
3462 XF86VidModeModeInfo **all_modes, *vidmode = NULL;
3463 XF86VidModeModeLine mod_tmp;
3464 /* int dotclock_tmp; */
3465
3466 /* save original video mode and set fullscreen if available*/
3467 orig_mode = (XF86VidModeModeInfo *) malloc (sizeof(XF86VidModeModeInfo));
3468 TSXF86VidModeGetModeLine(display, DefaultScreen(display), &orig_mode->dotclock, &mod_tmp);
3469 orig_mode->hdisplay = mod_tmp.hdisplay;
3470 orig_mode->hsyncstart = mod_tmp.hsyncstart;
3471 orig_mode->hsyncend = mod_tmp.hsyncend;
3472 orig_mode->htotal = mod_tmp.htotal;
3473 orig_mode->vdisplay = mod_tmp.vdisplay;
3474 orig_mode->vsyncstart = mod_tmp.vsyncstart;
3475 orig_mode->vsyncend = mod_tmp.vsyncend;
3476 orig_mode->vtotal = mod_tmp.vtotal;
3477 orig_mode->flags = mod_tmp.flags;
3478 orig_mode->private = mod_tmp.private;
3479
3480 TSXF86VidModeGetAllModeLines(display,DefaultScreen(display),&mode_count,&all_modes);
3481 for (i=0;i<mode_count;i++)
3482 {
3483 if (all_modes[i]->hdisplay == width && all_modes[i]->vdisplay == height)
3484 {
3485 vidmode = (XF86VidModeModeInfo *)malloc(sizeof(XF86VidModeModeInfo));
3486 *vidmode = *(all_modes[i]);
3487 break;
3488 } else
3489 TSXFree(all_modes[i]->private);
3490 }
3491 for (i++;i<mode_count;i++) TSXFree(all_modes[i]->private);
3492 TSXFree(all_modes);
3493
3494 if (!vidmode)
3495 WARN("Fullscreen mode not available!\n");
3496
3497 if (vidmode)
3498 {
3499 TRACE("SwitchToMode(%dx%d)\n",vidmode->hdisplay,vidmode->vdisplay);
3500 TSXF86VidModeSwitchToMode(display, DefaultScreen(display), vidmode);
3501 #if 0 /* This messes up my screen (XF86_Mach64, 3.3.2.3a) for some reason, and should now be unnecessary */
3502 TSXF86VidModeSetViewPort(display, DefaultScreen(display), 0, 0);
3503 #endif
3504 }
3505 }
3506 #endif
3507
3508 /* FIXME: this function OVERWRITES several signal handlers.
3509 * can we save them? and restore them later? In a way that
3510 * it works for the library too?
3511 */
3512 TSXF86DGADirectVideo(display,DefaultScreen(display),XF86DGADirectGraphics);
3513 TSXF86DGASetViewPort(display,DefaultScreen(display),0,0);
3514
3515 #ifdef RESTORE_SIGNALS
3516 SIGNAL_Init();
3517 #endif
3518 return DD_OK;
3519 }
3520 #endif /* defined(HAVE_LIBXXF86DGA) */
3521
3522 /* *************************************
3523 16 / 15 bpp to palettized 8 bpp
3524 ************************************* */
3525 static void pixel_convert_16_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) {
3526 unsigned char *c_src = (unsigned char *) src;
3527 unsigned short *c_dst = (unsigned short *) dst;
3528 int y;
3529
3530 if (palette != NULL) {
3531 const unsigned short * pal = (unsigned short *) palette->screen_palents;
3532
3533 for (y = height; y--; ) {
3534 #if defined(__i386__) && defined(__GNUC__)
3535 /* gcc generates slightly inefficient code for the the copy / lookup,
3536 * it generates one excess memory access (to pal) per pixel. Since
3537 * we know that pal is not modified by the memory write we can
3538 * put it into a register and reduce the number of memory accesses
3539 * from 4 to 3 pp. There are two xor eax,eax to avoid pipeline stalls.
3540 * (This is not guaranteed to be the fastest method.)
3541 */
3542 __asm__ __volatile__(
3543 "xor %%eax,%%eax\n"
3544 "1:\n"
3545 " lodsb\n"
3546 " movw (%%edx,%%eax,2),%%ax\n"
3547 " stosw\n"
3548 " xor %%eax,%%eax\n"
3549 " loop 1b\n"
3550 : "=S" (c_src), "=D" (c_dst)
3551 : "S" (c_src), "D" (c_dst) , "c" (width), "d" (pal)
3552 : "eax", "cc", "memory"
3553 );
3554 c_src+=(pitch-width);
3555 #else
3556 unsigned char * srclineend = c_src+width;
3557 while (c_src < srclineend)
3558 *c_dst++ = pal[*c_src++];
3559 c_src+=(pitch-width);
3560 #endif
3561 }
3562 } else {
3563 WARN("No palette set...\n");
3564 memset(dst, 0, width * height * 2);
3565 }
3566 }
3567 static void palette_convert_16_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) {
3568 int i;
3569 unsigned short *pal = (unsigned short *) screen_palette;
3570
3571 for (i = 0; i < count; i++)
3572 pal[start + i] = (((((unsigned short) palent[i].peRed) & 0xF8) << 8) |
3573 ((((unsigned short) palent[i].peBlue) & 0xF8) >> 3) |
3574 ((((unsigned short) palent[i].peGreen) & 0xFC) << 3));
3575 }
3576 static void palette_convert_15_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) {
3577 int i;
3578 unsigned short *pal = (unsigned short *) screen_palette;
3579
3580 for (i = 0; i < count; i++)
3581 pal[start + i] = (((((unsigned short) palent[i].peRed) & 0xF8) << 7) |
3582 ((((unsigned short) palent[i].peBlue) & 0xF8) >> 3) |
3583 ((((unsigned short) palent[i].peGreen) & 0xF8) << 2));
3584 }
3585
3586 /* *************************************
3587 24 to palettized 8 bpp
3588 ************************************* */
3589 static void pixel_convert_24_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) {
3590 unsigned char *c_src = (unsigned char *) src;
3591 unsigned char *c_dst = (unsigned char *) dst;
3592 int y;
3593
3594 if (palette != NULL) {
3595 const unsigned int *pal = (unsigned int *) palette->screen_palents;
3596
3597 for (y = height; y--; ) {
3598 unsigned char * srclineend = c_src+width;
3599 while (c_src < srclineend ) {
3600 register long pixel = pal[*c_src++];
3601 *c_dst++ = pixel;
3602 *c_dst++ = pixel>>8;
3603 *c_dst++ = pixel>>16;
3604 }
3605 c_src+=(pitch-width);
3606 }
3607 } else {
3608 WARN("No palette set...\n");
3609 memset(dst, 0, width * height * 4);
3610 }
3611 }
3612 /* *************************************
3613 32 bpp to palettized 8 bpp
3614 ************************************* */
3615 static void pixel_convert_32_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) {
3616 unsigned char *c_src = (unsigned char *) src;
3617 unsigned int *c_dst = (unsigned int *) dst;
3618 int y;
3619
3620 if (palette != NULL) {
3621 const unsigned int *pal = (unsigned int *) palette->screen_palents;
3622
3623 for (y = height; y--; ) {
3624 #if defined(__i386__) && defined(__GNUC__)
3625 /* See comment in pixel_convert_16_to_8 */
3626 __asm__ __volatile__(
3627 "xor %%eax,%%eax\n"
3628 "1:\n"
3629 " lodsb\n"
3630 " movl (%%edx,%%eax,4),%%eax\n"
3631 " stosl\n"
3632 " xor %%eax,%%eax\n"
3633 " loop 1b\n"
3634 : "=S" (c_src), "=D" (c_dst)
3635 : "S" (c_src), "D" (c_dst) , "c" (width), "d" (pal)
3636 : "eax", "cc", "memory"
3637 );
3638 c_src+=(pitch-width);
3639 #else
3640 unsigned char * srclineend = c_src+width;
3641 while (c_src < srclineend )
3642 *c_dst++ = pal[*c_src++];
3643 c_src+=(pitch-width);
3644 #endif
3645 }
3646 } else {
3647 WARN("No palette set...\n");
3648 memset(dst, 0, width * height * 4);
3649 }
3650 }
3651
3652 static void palette_convert_24_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) {
3653 int i;
3654 unsigned int *pal = (unsigned int *) screen_palette;
3655
3656 for (i = 0; i < count; i++)
3657 pal[start + i] = ((((unsigned int) palent[i].peRed) << 16) |
3658 (((unsigned int) palent[i].peGreen) << 8) |
3659 ((unsigned int) palent[i].peBlue));
3660 }
3661
3662 /* *************************************
3663 32 bpp to 16 bpp
3664 ************************************* */
3665 static void pixel_convert_32_to_16(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) {
3666 unsigned short *c_src = (unsigned short *) src;
3667 unsigned int *c_dst = (unsigned int *) dst;
3668 int y;
3669
3670 for (y = height; y--; ) {
3671 unsigned short * srclineend = c_src+width;
3672 while (c_src < srclineend ) {
3673 *c_dst++ = (((*c_src & 0xF800) << 8) |
3674 ((*c_src & 0x07E0) << 5) |
3675 ((*c_src & 0x001F) << 3));
3676 c_src++;
3677 }
3678 c_src+=((pitch/2)-width);
3679 }
3680 }
3681
3682
3683 static HRESULT WINAPI Xlib_IDirectDrawImpl_SetDisplayMode(
3684 LPDIRECTDRAW iface,DWORD width,DWORD height,DWORD depth
3685 ) {
3686 ICOM_THIS(IDirectDrawImpl,iface);
3687 char buf[200];
3688 WND *tmpWnd;
3689 int c;
3690
3691 TRACE("(%p)->SetDisplayMode(%ld,%ld,%ld)\n",
3692 This, width, height, depth);
3693
3694 switch ((c = _common_depth_to_pixelformat(depth,
3695 &(This->d.directdraw_pixelformat),
3696 &(This->d.screen_pixelformat),
3697 &(This->d.pixmap_depth)))) {
3698 case -2:
3699 sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), unsupported depth!",width,height,depth);
3700 MessageBoxA(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
3701 return DDERR_UNSUPPORTEDMODE;
3702
3703 case -1:
3704 /* No convertion */
3705 This->d.pixel_convert = NULL;
3706 This->d.palette_convert = NULL;
3707 break;
3708
3709 default:
3710 WARN("Warning : running in depth-convertion mode. Should run using a %ld depth for optimal performances.\n", depth);
3711
3712 /* Set the depth convertion routines */
3713 This->d.pixel_convert = ModeEmulations[c].funcs.pixel_convert;
3714 This->d.palette_convert = ModeEmulations[c].funcs.palette_convert;
3715 }
3716
3717 This->d.width = width;
3718 This->d.height = height;
3719
3720 _common_IDirectDrawImpl_SetDisplayMode(This);
3721
3722 tmpWnd = WIN_FindWndPtr(This->d.window);
3723 This->d.paintable = 1;
3724 This->d.drawable = ((X11DRV_WND_DATA *) tmpWnd->pDriverData)->window;
3725 WIN_ReleaseWndPtr(tmpWnd);
3726
3727 /* We don't have a context for this window. Host off the desktop */
3728 if( !This->d.drawable )
3729 {
3730 This->d.drawable = ((X11DRV_WND_DATA *) WIN_GetDesktop()->pDriverData)->window;
3731 WIN_ReleaseDesktop();
3732 }
3733 TRACE("Setting drawable to %ld\n", This->d.drawable);
3734
3735 return DD_OK;
3736 }
3737
3738 #ifdef HAVE_LIBXXF86DGA
3739 static HRESULT WINAPI DGA_IDirectDraw2Impl_GetCaps(
3740 LPDIRECTDRAW2 iface,LPDDCAPS caps1,LPDDCAPS caps2
3741 ) {
3742 ICOM_THIS(IDirectDraw2Impl,iface);
3743 TRACE("(%p)->GetCaps(%p,%p)\n",This,caps1,caps2);
3744 if (!caps1 && !caps2)
3745 return DDERR_INVALIDPARAMS;
3746 if (caps1) {
3747 caps1->dwVidMemTotal = This->e.dga.fb_memsize;
3748 caps1->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED); /* we can do anything */
3749 caps1->ddsCaps.dwCaps = 0xffffffff; /* we can do anything */
3750 }
3751 if (caps2) {
3752 caps2->dwVidMemTotal = This->e.dga.fb_memsize;
3753 caps2->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED); /* we can do anything */
3754 caps2->ddsCaps.dwCaps = 0xffffffff; /* we can do anything */
3755 }
3756 return DD_OK;
3757 }
3758 #endif /* defined(HAVE_LIBXXF86DGA) */
3759
3760 static void fill_caps(LPDDCAPS caps) {
3761 /* This function tries to fill the capabilities of Wine's DDraw implementation.
3762 Need to be fixed, though.. */
3763 if (caps == NULL)
3764 return;
3765
3766 caps->dwSize = sizeof(*caps);
3767 caps->dwCaps = DDCAPS_ALPHA | DDCAPS_BLT | DDCAPS_BLTSTRETCH | DDCAPS_BLTCOLORFILL | DDCAPS_BLTDEPTHFILL | DDCAPS_CANBLTSYSMEM | DDCAPS_COLORKEY | DDCAPS_PALETTE | DDCAPS_NOHARDWARE;
3768 caps->dwCaps2 = DDCAPS2_CERTIFIED | DDCAPS2_NOPAGELOCKREQUIRED | DDCAPS2_WIDESURFACES;
3769 caps->dwCKeyCaps = 0xFFFFFFFF; /* Should put real caps here one day... */
3770 caps->dwFXCaps = 0;
3771 caps->dwFXAlphaCaps = 0;
3772 caps->dwPalCaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
3773 caps->dwSVCaps = 0;
3774 caps->dwZBufferBitDepths = DDBD_16;
3775 /* I put here 8 Mo so that D3D applications will believe they have enough memory
3776 to put textures in video memory.
3777 BTW, is this only frame buffer memory or also texture memory (for Voodoo boards
3778 for example) ? */
3779 caps->dwVidMemTotal = 8192 * 1024;
3780 caps->dwVidMemFree = 8192 * 1024;
3781 /* These are all the supported capabilities of the surfaces */
3782 caps->ddsCaps.dwCaps = DDSCAPS_ALPHA | DDSCAPS_BACKBUFFER | DDSCAPS_COMPLEX | DDSCAPS_FLIP |
3783 DDSCAPS_FRONTBUFFER | DDSCAPS_LOCALVIDMEM | DDSCAPS_NONLOCALVIDMEM | DDSCAPS_OFFSCREENPLAIN |
3784 DDSCAPS_OVERLAY | DDSCAPS_PALETTE | DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY |
3785 DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE;
3786 #ifdef HAVE_MESAGL
3787 caps->dwCaps |= DDCAPS_3D | DDCAPS_ZBLTS;
3788 caps->dwCaps2 |= DDCAPS2_NO2DDURING3DSCENE;
3789 caps->ddsCaps.dwCaps |= DDSCAPS_3DDEVICE | DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_ZBUFFER;
3790 #endif
3791 }
3792
3793 static HRESULT WINAPI Xlib_IDirectDraw2Impl_GetCaps(
3794 LPDIRECTDRAW2 iface,LPDDCAPS caps1,LPDDCAPS caps2
3795 ) {
3796 ICOM_THIS(IDirectDraw2Impl,iface);
3797 TRACE("(%p)->GetCaps(%p,%p)\n",This,caps1,caps2);
3798
3799 /* Put the same caps for the two capabilities */
3800 fill_caps(caps1);
3801 fill_caps(caps2);
3802
3803 return DD_OK;
3804 }
3805
3806 static HRESULT WINAPI IDirectDraw2Impl_CreateClipper(
3807 LPDIRECTDRAW2 iface,DWORD x,LPDIRECTDRAWCLIPPER *lpddclip,LPUNKNOWN lpunk
3808 ) {
3809 ICOM_THIS(IDirectDraw2Impl,iface);
3810 IDirectDrawClipperImpl** ilpddclip=(IDirectDrawClipperImpl**)lpddclip;
3811 FIXME("(%p)->(%08lx,%p,%p),stub!\n",
3812 This,x,ilpddclip,lpunk
3813 );
3814 *ilpddclip = (IDirectDrawClipperImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipperImpl));
3815 (*ilpddclip)->ref = 1;
3816 (*ilpddclip)->lpvtbl = &ddclipvt;
3817 return DD_OK;
3818 }
3819
3820 static HRESULT WINAPI common_IDirectDraw2Impl_CreatePalette(
3821 IDirectDraw2Impl* This,DWORD dwFlags,LPPALETTEENTRY palent,IDirectDrawPaletteImpl **lpddpal,LPUNKNOWN lpunk,int *psize
3822 ) {
3823 int size = 0;
3824
3825 if (TRACE_ON(ddraw))
3826 _dump_paletteformat(dwFlags);
3827
3828 *lpddpal = (IDirectDrawPaletteImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawPaletteImpl));
3829 if (*lpddpal == NULL) return E_OUTOFMEMORY;
3830 (*lpddpal)->ref = 1;
3831 (*lpddpal)->ddraw = (IDirectDrawImpl*)This;
3832 (*lpddpal)->installed = 0;
3833
3834 if (dwFlags & DDPCAPS_1BIT)
3835 size = 2;
3836 else if (dwFlags & DDPCAPS_2BIT)
3837 size = 4;
3838 else if (dwFlags & DDPCAPS_4BIT)
3839 size = 16;
3840 else if (dwFlags & DDPCAPS_8BIT)
3841 size = 256;
3842 else
3843 ERR("unhandled palette format\n");
3844 *psize = size;
3845
3846 if (palent)
3847 {
3848 /* Now, if we are in 'depth conversion mode', create the screen palette */
3849 if (This->d.palette_convert != NULL)
3850 This->d.palette_convert(palent, (*lpddpal)->screen_palents, 0, size);
3851
3852 memcpy((*lpddpal)->palents, palent, size * sizeof(PALETTEENTRY));
3853 } else if (This->d.palette_convert != NULL) {
3854 /* In that case, put all 0xFF */
3855 memset((*lpddpal)->screen_palents, 0xFF, 256 * sizeof(int));
3856 }
3857
3858 return DD_OK;
3859 }
3860
3861 #ifdef HAVE_LIBXXF86DGA
3862 static HRESULT WINAPI DGA_IDirectDraw2Impl_CreatePalette(
3863 LPDIRECTDRAW2 iface,DWORD dwFlags,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
3864 ) {
3865 ICOM_THIS(IDirectDraw2Impl,iface);
3866 IDirectDrawPaletteImpl** ilpddpal=(IDirectDrawPaletteImpl**)lpddpal;
3867 HRESULT res;
3868 int xsize = 0,i;
3869
3870 TRACE("(%p)->(%08lx,%p,%p,%p)\n",This,dwFlags,palent,ilpddpal,lpunk);
3871 res = common_IDirectDraw2Impl_CreatePalette(This,dwFlags,palent,ilpddpal,lpunk,&xsize);
3872 if (res != 0) return res;
3873 (*ilpddpal)->lpvtbl = &dga_ddpalvt;
3874 if (This->d.directdraw_pixelformat.x.dwRGBBitCount<=8) {
3875 (*ilpddpal)->cm = TSXCreateColormap(display,DefaultRootWindow(display),DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll);
3876 } else {
3877 FIXME("why are we doing CreatePalette in hi/truecolor?\n");
3878 (*ilpddpal)->cm = 0;
3879 }
3880 if (((*ilpddpal)->cm)&&xsize) {
3881 for (i=0;i<xsize;i++) {
3882 XColor xc;
3883
3884 xc.red = (*ilpddpal)->palents[i].peRed<<8;
3885 xc.blue = (*ilpddpal)->palents[i].peBlue<<8;
3886 xc.green = (*ilpddpal)->palents[i].peGreen<<8;
3887 xc.flags = DoRed|DoBlue|DoGreen;
3888 xc.pixel = i;
3889 TSXStoreColor(display,(*ilpddpal)->cm,&xc);
3890 }
3891 }
3892 return DD_OK;
3893 }
3894 #endif /* defined(HAVE_LIBXXF86DGA) */
3895
3896 static HRESULT WINAPI Xlib_IDirectDraw2Impl_CreatePalette(
3897 LPDIRECTDRAW2 iface,DWORD dwFlags,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
3898 ) {
3899 ICOM_THIS(IDirectDraw2Impl,iface);
3900 IDirectDrawPaletteImpl** ilpddpal=(IDirectDrawPaletteImpl**)lpddpal;
3901 int xsize;
3902 HRESULT res;
3903
3904 TRACE("(%p)->(%08lx,%p,%p,%p)\n",This,dwFlags,palent,ilpddpal,lpunk);
3905 res = common_IDirectDraw2Impl_CreatePalette(This,dwFlags,palent,ilpddpal,lpunk,&xsize);
3906 if (res != 0) return res;
3907 (*ilpddpal)->lpvtbl = &xlib_ddpalvt;
3908 return DD_OK;
3909 }
3910
3911 #ifdef HAVE_LIBXXF86DGA
3912 static HRESULT WINAPI DGA_IDirectDraw2Impl_RestoreDisplayMode(LPDIRECTDRAW2 iface) {
3913 ICOM_THIS(IDirectDraw2Impl,iface);
3914 TRACE("(%p)->()\n",This);
3915 Sleep(1000);
3916 TSXF86DGADirectVideo(display,DefaultScreen(display),0);
3917 #ifdef RESTORE_SIGNALS
3918 SIGNAL_Init();
3919 #endif
3920 return DD_OK;
3921 }
3922 #endif /* defined(HAVE_LIBXXF86DGA) */
3923
3924 static HRESULT WINAPI Xlib_IDirectDraw2Impl_RestoreDisplayMode(LPDIRECTDRAW2 iface) {
3925 ICOM_THIS(IDirectDraw2Impl,iface);
3926 TRACE("(%p)->RestoreDisplayMode()\n", This);
3927 Sleep(1000);
3928 return DD_OK;
3929 }
3930
3931 static HRESULT WINAPI IDirectDraw2Impl_WaitForVerticalBlank(
3932 LPDIRECTDRAW2 iface,DWORD x,HANDLE h
3933 ) {
3934 ICOM_THIS(IDirectDraw2Impl,iface);
3935 TRACE("(%p)->(0x%08lx,0x%08x)\n",This,x,h);
3936 return DD_OK;
3937 }
3938
3939 static ULONG WINAPI IDirectDraw2Impl_AddRef(LPDIRECTDRAW2 iface) {
3940 ICOM_THIS(IDirectDraw2Impl,iface);
3941 TRACE("(%p)->() incrementing from %lu.\n", This, This->ref );
3942
3943 return ++(This->ref);
3944 }
3945
3946 #ifdef HAVE_LIBXXF86DGA
3947 static ULONG WINAPI DGA_IDirectDraw2Impl_Release(LPDIRECTDRAW2 iface) {
3948 ICOM_THIS(IDirectDraw2Impl,iface);
3949 TRACE("(%p)->() decrementing from %lu.\n", This, This->ref );
3950
3951 if (!--(This->ref)) {
3952 TSXF86DGADirectVideo(display,DefaultScreen(display),0);
3953 if (This->d.window && (This->d.mainWindow != This->d.window))
3954 DestroyWindow(This->d.window);
3955 #ifdef HAVE_LIBXXF86VM
3956 if (orig_mode) {
3957 TSXF86VidModeSwitchToMode(
3958 display,
3959 DefaultScreen(display),
3960 orig_mode);
3961 if (orig_mode->privsize)
3962 TSXFree(orig_mode->private);
3963 free(orig_mode);
3964 orig_mode = NULL;
3965 }
3966 #endif
3967
3968 #ifdef RESTORE_SIGNALS
3969 SIGNAL_Init();
3970 #endif
3971 HeapFree(GetProcessHeap(),0,This);
3972 return S_OK;
3973 }
3974 return This->ref;
3975 }
3976 #endif /* defined(HAVE_LIBXXF86DGA) */
3977
3978 static ULONG WINAPI Xlib_IDirectDraw2Impl_Release(LPDIRECTDRAW2 iface) {
3979 ICOM_THIS(IDirectDraw2Impl,iface);
3980 TRACE("(%p)->() decrementing from %lu.\n", This, This->ref );
3981
3982 if (!--(This->ref)) {
3983 if (This->d.window && (This->d.mainWindow != This->d.window))
3984 DestroyWindow(This->d.window);
3985 HeapFree(GetProcessHeap(),0,This);
3986 return S_OK;
3987 }
3988 /* FIXME: destroy window ... */
3989 return This->ref;
3990 }
3991
3992 #ifdef HAVE_LIBXXF86DGA
3993 static HRESULT WINAPI DGA_IDirectDraw2Impl_QueryInterface(
3994 LPDIRECTDRAW2 iface,REFIID refiid,LPVOID *obj
3995 ) {
3996 ICOM_THIS(IDirectDraw2Impl,iface);
3997 char xrefiid[50];
3998
3999 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
4000 TRACE("(%p)->(%s,%p)\n",This,xrefiid,obj);
4001 if ( IsEqualGUID( &IID_IUnknown, refiid ) ) {
4002 *obj = This;
4003 IDirectDraw2_AddRef(iface);
4004
4005 TRACE(" Creating IUnknown interface (%p)\n", *obj);
4006
4007 return S_OK;
4008 }
4009 if ( IsEqualGUID( &IID_IDirectDraw, refiid ) ) {
4010 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&dga_ddvt;
4011 IDirectDraw2_AddRef(iface);
4012 *obj = This;
4013
4014 TRACE(" Creating IDirectDraw interface (%p)\n", *obj);
4015
4016 return S_OK;
4017 }
4018 if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) ) {
4019 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&dga_dd2vt;
4020 IDirectDraw2_AddRef(iface);
4021 *obj = This;
4022
4023 TRACE(" Creating IDirectDraw2 interface (%p)\n", *obj);
4024
4025 return S_OK;
4026 }
4027 if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) ) {
4028 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&dga_dd4vt;
4029 IDirectDraw2_AddRef(iface);
4030 *obj = This;
4031
4032 TRACE(" Creating IDirectDraw4 interface (%p)\n", *obj);
4033
4034 return S_OK;
4035 }
4036 if ( IsEqualGUID( &IID_IDirect3D, refiid ) ) {
4037 IDirect3DImpl* d3d;
4038
4039 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
4040 d3d->ref = 1;
4041 d3d->ddraw = (IDirectDrawImpl*)This;
4042 IDirectDraw2_AddRef(iface);
4043 d3d->lpvtbl = &d3dvt;
4044 *obj = d3d;
4045
4046 TRACE(" Creating IDirect3D interface (%p)\n", *obj);
4047
4048 return S_OK;
4049 }
4050 if ( IsEqualGUID( &IID_IDirect3D2, refiid ) ) {
4051 IDirect3D2Impl* d3d;
4052
4053 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
4054 d3d->ref = 1;
4055 d3d->ddraw = (IDirectDrawImpl*)This;
4056 IDirectDraw2_AddRef(iface);
4057 d3d->lpvtbl = &d3d2vt;
4058 *obj = d3d;
4059
4060 TRACE(" Creating IDirect3D2 interface (%p)\n", *obj);
4061
4062 return S_OK;
4063 }
4064 WARN("(%p):interface for IID %s _NOT_ found!\n",This,xrefiid);
4065 return OLE_E_ENUM_NOMORE;
4066 }
4067 #endif /* defined(HAVE_LIBXXF86DGA) */
4068
4069 static HRESULT WINAPI Xlib_IDirectDraw2Impl_QueryInterface(
4070 LPDIRECTDRAW2 iface,REFIID refiid,LPVOID *obj
4071 ) {
4072 ICOM_THIS(IDirectDraw2Impl,iface);
4073 char xrefiid[50];
4074
4075 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
4076 TRACE("(%p)->(%s,%p)\n",This,xrefiid,obj);
4077 if ( IsEqualGUID( &IID_IUnknown, refiid ) ) {
4078 *obj = This;
4079 IDirectDraw2_AddRef(iface);
4080
4081 TRACE(" Creating IUnknown interface (%p)\n", *obj);
4082
4083 return S_OK;
4084 }
4085 if ( IsEqualGUID( &IID_IDirectDraw, refiid ) ) {
4086 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&xlib_ddvt;
4087 IDirectDraw2_AddRef(iface);
4088 *obj = This;
4089
4090 TRACE(" Creating IDirectDraw interface (%p)\n", *obj);
4091
4092 return S_OK;
4093 }
4094 if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) ) {
4095 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&xlib_dd2vt;
4096 IDirectDraw2_AddRef(iface);
4097 *obj = This;
4098
4099 TRACE(" Creating IDirectDraw2 interface (%p)\n", *obj);
4100
4101 return S_OK;
4102 }
4103 if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) ) {
4104 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&xlib_dd4vt;
4105 IDirectDraw2_AddRef(iface);
4106 *obj = This;
4107
4108 TRACE(" Creating IDirectDraw4 interface (%p)\n", *obj);
4109
4110 return S_OK;
4111 }
4112 if ( IsEqualGUID( &IID_IDirect3D, refiid ) ) {
4113 IDirect3DImpl* d3d;
4114
4115 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
4116 d3d->ref = 1;
4117 d3d->ddraw = (IDirectDrawImpl*)This;
4118 IDirectDraw2_AddRef(iface);
4119 d3d->lpvtbl = &d3dvt;
4120 *obj = d3d;
4121
4122 TRACE(" Creating IDirect3D interface (%p)\n", *obj);
4123
4124 return S_OK;
4125 }
4126 if ( IsEqualGUID( &IID_IDirect3D2, refiid ) ) {
4127 IDirect3D2Impl* d3d;
4128
4129 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
4130 d3d->ref = 1;
4131 d3d->ddraw = (IDirectDrawImpl*)This;
4132 IDirectDraw2_AddRef(iface);
4133 d3d->lpvtbl = &d3d2vt;
4134 *obj = d3d;
4135
4136 TRACE(" Creating IDirect3D2 interface (%p)\n", *obj);
4137
4138 return S_OK;
4139 }
4140 WARN("(%p):interface for IID %s _NOT_ found!\n",This,xrefiid);
4141 return OLE_E_ENUM_NOMORE;
4142 }
4143
4144 static HRESULT WINAPI IDirectDraw2Impl_GetVerticalBlankStatus(
4145 LPDIRECTDRAW2 iface,BOOL *status
4146 ) {
4147 ICOM_THIS(IDirectDraw2Impl,iface);
4148 TRACE("(%p)->(%p)\n",This,status);
4149 *status = TRUE;
4150 return DD_OK;
4151 }
4152
4153 #ifdef HAVE_LIBXXF86DGA
4154 static HRESULT WINAPI DGA_IDirectDraw2Impl_EnumDisplayModes(
4155 LPDIRECTDRAW2 iface,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
4156 ) {
4157 ICOM_THIS(IDirectDraw2Impl,iface);
4158 DDSURFACEDESC ddsfd;
4159 static struct {
4160 int w,h;
4161 } modes[5] = { /* some of the usual modes */
4162 {512,384},
4163 {640,400},
4164 {640,480},
4165 {800,600},
4166 {1024,768},
4167 };
4168 static int depths[4] = {8,16,24,32};
4169 int i,j;
4170
4171 TRACE("(%p)->(0x%08lx,%p,%p,%p)\n",This,dwFlags,lpddsfd,context,modescb);
4172 ddsfd.dwSize = sizeof(ddsfd);
4173 ddsfd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
4174 if (dwFlags & DDEDM_REFRESHRATES) {
4175 ddsfd.dwFlags |= DDSD_REFRESHRATE;
4176 ddsfd.x.dwRefreshRate = 60;
4177 }
4178
4179 for (i=0;i<sizeof(depths)/sizeof(depths[0]);i++) {
4180 ddsfd.dwBackBufferCount = 1;
4181 ddsfd.ddpfPixelFormat.dwFourCC = 0;
4182 ddsfd.ddpfPixelFormat.dwFlags = DDPF_RGB;
4183 ddsfd.ddpfPixelFormat.x.dwRGBBitCount = depths[i];
4184 /* FIXME: those masks would have to be set in depth > 8 */
4185 if (depths[i]==8) {
4186 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0;
4187 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0;
4188 ddsfd.ddpfPixelFormat.xx.dwBBitMask = 0;
4189 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4190 ddsfd.ddsCaps.dwCaps=DDSCAPS_PALETTE;
4191 ddsfd.ddpfPixelFormat.dwFlags|=DDPF_PALETTEINDEXED8;
4192 } else {
4193 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4194
4195 /* FIXME: We should query those from X itself */
4196 switch (depths[i]) {
4197 case 16:
4198 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0xF800;
4199 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x07E0;
4200 ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x001F;
4201 break;
4202 case 24:
4203 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0x00FF0000;
4204 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x0000FF00;
4205 ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x000000FF;
4206 break;
4207 case 32:
4208 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0x00FF0000;
4209 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x0000FF00;
4210 ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x000000FF;
4211 break;
4212 }
4213 }
4214
4215 ddsfd.dwWidth = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
4216 ddsfd.dwHeight = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
4217 TRACE(" enumerating (%ldx%ldx%d)\n",ddsfd.dwWidth,ddsfd.dwHeight,depths[i]);
4218 if (!modescb(&ddsfd,context)) return DD_OK;
4219
4220 for (j=0;j<sizeof(modes)/sizeof(modes[0]);j++) {
4221 ddsfd.dwWidth = modes[j].w;
4222 ddsfd.dwHeight = modes[j].h;
4223 TRACE(" enumerating (%ldx%ldx%d)\n",ddsfd.dwWidth,ddsfd.dwHeight,depths[i]);
4224 if (!modescb(&ddsfd,context)) return DD_OK;
4225 }
4226
4227 if (!(dwFlags & DDEDM_STANDARDVGAMODES)) {
4228 /* modeX is not standard VGA */
4229
4230 ddsfd.dwHeight = 200;
4231 ddsfd.dwWidth = 320;
4232 TRACE(" enumerating (320x200x%d)\n",depths[i]);
4233 if (!modescb(&ddsfd,context)) return DD_OK;
4234 }
4235 }
4236 return DD_OK;
4237 }
4238 #endif /* defined(HAVE_LIBXXF86DGA) */
4239
4240 static HRESULT WINAPI Xlib_IDirectDraw2Impl_EnumDisplayModes(
4241 LPDIRECTDRAW2 iface,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
4242 ) {
4243 ICOM_THIS(IDirectDraw2Impl,iface);
4244 XVisualInfo *vi;
4245 XPixmapFormatValues *pf;
4246 XVisualInfo vt;
4247 int nvisuals, npixmap, i, emu;
4248 int has_mode[] = { 0, 0, 0, 0 };
4249 int has_depth[] = { 8, 15, 16, 24 };
4250 DDSURFACEDESC ddsfd;
4251 static struct {
4252 int w,h;
4253 } modes[] = { /* some of the usual modes */
4254 {512,384},
4255 {640,400},
4256 {640,480},
4257 {800,600},
4258 {1024,768},
4259 {1280,1024}
4260 };
4261 DWORD maxWidth, maxHeight;
4262
4263 TRACE("(%p)->(0x%08lx,%p,%p,%p)\n",This,dwFlags,lpddsfd,context,modescb);
4264 ddsfd.dwSize = sizeof(ddsfd);
4265 ddsfd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_CAPS;
4266 if (dwFlags & DDEDM_REFRESHRATES) {
4267 ddsfd.dwFlags |= DDSD_REFRESHRATE;
4268 ddsfd.x.dwRefreshRate = 60;
4269 }
4270 maxWidth = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
4271 maxHeight = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
4272
4273 vi = TSXGetVisualInfo(display, VisualNoMask, &vt, &nvisuals);
4274 pf = XListPixmapFormats(display, &npixmap);
4275
4276 i = 0;
4277 emu = 0;
4278 while ((i < npixmap) ||
4279 (emu != 4)) {
4280 int mode_index;
4281 int send_mode = 0;
4282 int j;
4283
4284 if (i < npixmap) {
4285 for (j = 0; j < 4; j++) {
4286 if (has_depth[j] == pf[i].depth) {
4287 mode_index = j;
4288 break;
4289 }
4290 }
4291 if (j == 4) {
4292 i++;
4293 continue;
4294 }
4295
4296
4297 if (has_mode[mode_index] == 0) {
4298 if (mode_index == 0) {
4299 send_mode = 1;
4300
4301 ddsfd.ddsCaps.dwCaps = DDSCAPS_PALETTE;
4302 ddsfd.ddpfPixelFormat.dwSize = sizeof(ddsfd.ddpfPixelFormat);
4303 ddsfd.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8;
4304 ddsfd.ddpfPixelFormat.dwFourCC = 0;
4305 ddsfd.ddpfPixelFormat.x.dwRGBBitCount = 8;
4306 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0;
4307 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0;
4308 ddsfd.ddpfPixelFormat.xx.dwBBitMask = 0;
4309 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4310
4311 has_mode[mode_index] = 1;
4312 } else {
4313 /* All the 'true color' depths (15, 16 and 24)
4314 First, find the corresponding visual to extract the bit masks */
4315 for (j = 0; j < nvisuals; j++) {
4316 if (vi[j].depth == pf[i].depth) {
4317 ddsfd.ddsCaps.dwCaps = 0;
4318 ddsfd.ddpfPixelFormat.dwSize = sizeof(ddsfd.ddpfPixelFormat);
4319 ddsfd.ddpfPixelFormat.dwFlags = DDPF_RGB;
4320 ddsfd.ddpfPixelFormat.dwFourCC = 0;
4321 ddsfd.ddpfPixelFormat.x.dwRGBBitCount = pf[i].bits_per_pixel;
4322 ddsfd.ddpfPixelFormat.y.dwRBitMask = vi[j].red_mask;
4323 ddsfd.ddpfPixelFormat.z.dwGBitMask = vi[j].green_mask;
4324 ddsfd.ddpfPixelFormat.xx.dwBBitMask = vi[j].blue_mask;
4325 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4326
4327 send_mode = 1;
4328 has_mode[mode_index] = 1;
4329 break;
4330 }
4331 }
4332
4333 if (j == nvisuals)
4334 ERR("Did not find visual corresponding the the pixmap format !\n");
4335 }
4336 }
4337
4338 i++;
4339 } else {
4340 /* Now to emulated modes */
4341 if (has_mode[emu] == 0) {
4342 int c;
4343 int l;
4344 int depth = has_depth[emu];
4345
4346 for (c = 0; (c < sizeof(ModeEmulations) / sizeof(Convert)) && (send_mode == 0); c++) {
4347 if (ModeEmulations[c].dest.depth == depth) {
4348 /* Found an emulation function, now tries to find a matching visual / pixel format pair */
4349 for (l = 0; (l < npixmap) && (send_mode == 0); l++) {
4350 if ((pf[l].depth == ModeEmulations[c].screen.depth) &&
4351 (pf[l].bits_per_pixel == ModeEmulations[c].screen.bpp)) {
4352 int j;
4353 for (j = 0; (j < nvisuals) && (send_mode == 0); j++) {
4354 if ((vi[j].depth == pf[l].depth) &&
4355 (vi[j].red_mask == ModeEmulations[c].screen.rmask) &&
4356 (vi[j].green_mask == ModeEmulations[c].screen.gmask) &&
4357 (vi[j].blue_mask == ModeEmulations[c].screen.bmask)) {
4358 ddsfd.ddpfPixelFormat.dwSize = sizeof(ddsfd.ddpfPixelFormat);
4359 ddsfd.ddpfPixelFormat.dwFourCC = 0;
4360 if (depth == 8) {
4361 ddsfd.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8;
4362 ddsfd.ddpfPixelFormat.x.dwRGBBitCount = 8;
4363 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0;
4364 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0;
4365 ddsfd.ddpfPixelFormat.xx.dwBBitMask = 0;
4366 } else {
4367 ddsfd.ddpfPixelFormat.dwFlags = DDPF_RGB;
4368 ddsfd.ddpfPixelFormat.x.dwRGBBitCount = ModeEmulations[c].dest.bpp;
4369 ddsfd.ddpfPixelFormat.y.dwRBitMask = ModeEmulations[c].dest.rmask;
4370 ddsfd.ddpfPixelFormat.z.dwGBitMask = ModeEmulations[c].dest.gmask;
4371 ddsfd.ddpfPixelFormat.xx.dwBBitMask = ModeEmulations[c].dest.bmask;
4372 }
4373 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4374 send_mode = 1;
4375 }
4376
4377 if (send_mode == 0)
4378 ERR("No visual corresponding to pixmap format !\n");
4379 }
4380 }
4381 }
4382 }
4383 }
4384 }
4385
4386 emu++;
4387 }
4388
4389 if (send_mode) {
4390 int mode;
4391
4392 if (TRACE_ON(ddraw)) {
4393 TRACE("Enumerating with pixel format : \n");
4394 _dump_pixelformat(&(ddsfd.ddpfPixelFormat));
4395 DPRINTF("\n");
4396 }
4397
4398 for (mode = 0; mode < sizeof(modes)/sizeof(modes[0]); mode++) {
4399 /* Do not enumerate modes we cannot handle anyway */
4400 if ((modes[mode].w > maxWidth) || (modes[mode].h > maxHeight))
4401 break;
4402
4403 ddsfd.dwWidth = modes[mode].w;
4404 ddsfd.dwHeight = modes[mode].h;
4405
4406 /* Now, send the mode description to the application */
4407 TRACE(" - mode %4ld - %4ld\n", ddsfd.dwWidth, ddsfd.dwHeight);
4408 if (!modescb(&ddsfd, context))
4409 goto exit_enum;
4410 }
4411
4412 if (!(dwFlags & DDEDM_STANDARDVGAMODES)) {
4413 /* modeX is not standard VGA */
4414 ddsfd.dwWidth = 320;
4415 ddsfd.dwHeight = 200;
4416 if (!modescb(&ddsfd, context))
4417 goto exit_enum;
4418 }
4419 }
4420 }
4421
4422 exit_enum:
4423 TSXFree(vi);
4424 TSXFree(pf);
4425
4426 return DD_OK;
4427 }
4428
4429 #ifdef HAVE_LIBXXF86DGA
4430 static HRESULT WINAPI DGA_IDirectDraw2Impl_GetDisplayMode(
4431 LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsfd
4432 ) {
4433 ICOM_THIS(IDirectDraw2Impl,iface);
4434 TRACE("(%p)->(%p)\n",This,lpddsfd);
4435 lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
4436 lpddsfd->dwHeight = This->d.height;
4437 lpddsfd->dwWidth = This->d.width;
4438 lpddsfd->lPitch = This->e.dga.fb_width*PFGET_BPP(This->d.directdraw_pixelformat);
4439 lpddsfd->dwBackBufferCount = 1;
4440 lpddsfd->x.dwRefreshRate = 60;
4441 lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
4442 lpddsfd->ddpfPixelFormat = This->d.directdraw_pixelformat;
4443 return DD_OK;
4444 }
4445 #endif /* defined(HAVE_LIBXXF86DGA) */
4446
4447 static HRESULT WINAPI Xlib_IDirectDraw2Impl_GetDisplayMode(
4448 LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsfd
4449 ) {
4450 ICOM_THIS(IDirectDraw2Impl,iface);
4451 TRACE("(%p)->GetDisplayMode(%p)\n",This,lpddsfd);
4452 lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
4453 lpddsfd->dwHeight = This->d.height;
4454 lpddsfd->dwWidth = This->d.width;
4455 lpddsfd->lPitch = lpddsfd->dwWidth * PFGET_BPP(This->d.directdraw_pixelformat);
4456 lpddsfd->dwBackBufferCount = 1;
4457 lpddsfd->x.dwRefreshRate = 60;
4458 lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
4459 lpddsfd->ddpfPixelFormat = This->d.directdraw_pixelformat;
4460 return DD_OK;
4461 }
4462
4463 static HRESULT WINAPI IDirectDraw2Impl_FlipToGDISurface(LPDIRECTDRAW2 iface) {
4464 ICOM_THIS(IDirectDraw2Impl,iface);
4465 TRACE("(%p)->()\n",This);
4466 return DD_OK;
4467 }
4468
4469 static HRESULT WINAPI IDirectDraw2Impl_GetMonitorFrequency(
4470 LPDIRECTDRAW2 iface,LPDWORD freq
4471 ) {
4472 ICOM_THIS(IDirectDraw2Impl,iface);
4473 FIXME("(%p)->(%p) returns 60 Hz always\n",This,freq);
4474 *freq = 60*100; /* 60 Hz */
4475 return DD_OK;
4476 }
4477
4478 /* what can we directly decompress? */
4479 static HRESULT WINAPI IDirectDraw2Impl_GetFourCCCodes(
4480 LPDIRECTDRAW2 iface,LPDWORD x,LPDWORD y
4481 ) {
4482 ICOM_THIS(IDirectDraw2Impl,iface);
4483 FIXME("(%p,%p,%p), stub\n",This,x,y);
4484 return DD_OK;
4485 }
4486
4487 static HRESULT WINAPI IDirectDraw2Impl_EnumSurfaces(
4488 LPDIRECTDRAW2 iface,DWORD x,LPDDSURFACEDESC ddsfd,LPVOID context,LPDDENUMSURFACESCALLBACK ddsfcb
4489 ) {
4490 ICOM_THIS(IDirectDraw2Impl,iface);
4491 FIXME("(%p)->(0x%08lx,%p,%p,%p),stub!\n",This,x,ddsfd,context,ddsfcb);
4492 return DD_OK;
4493 }
4494
4495 static HRESULT WINAPI IDirectDraw2Impl_Compact(
4496 LPDIRECTDRAW2 iface )
4497 {
4498 ICOM_THIS(IDirectDraw2Impl,iface);
4499 FIXME("(%p)->()\n", This );
4500
4501 return DD_OK;
4502 }
4503
4504 static HRESULT WINAPI IDirectDraw2Impl_GetGDISurface(LPDIRECTDRAW2 iface,
4505 LPDIRECTDRAWSURFACE *lplpGDIDDSSurface) {
4506 ICOM_THIS(IDirectDraw2Impl,iface);
4507 FIXME("(%p)->(%p)\n", This, lplpGDIDDSSurface);
4508
4509 return DD_OK;
4510 }
4511
4512 static HRESULT WINAPI IDirectDraw2Impl_GetScanLine(LPDIRECTDRAW2 iface,
4513 LPDWORD lpdwScanLine) {
4514 ICOM_THIS(IDirectDraw2Impl,iface);
4515 FIXME("(%p)->(%p)\n", This, lpdwScanLine);
4516
4517 return DD_OK;
4518 }
4519
4520 static HRESULT WINAPI IDirectDraw2Impl_Initialize(LPDIRECTDRAW2 iface,
4521 GUID *lpGUID) {
4522 ICOM_THIS(IDirectDraw2Impl,iface);
4523 FIXME("(%p)->(%p)\n", This, lpGUID);
4524
4525 return DD_OK;
4526 }
4527
4528 #ifdef HAVE_LIBXXF86DGA
4529
4530 /* Note: Hack so we can reuse the old functions without compiler warnings */
4531 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4532 # define XCAST(fun) (typeof(dga_ddvt.fn##fun))
4533 #else
4534 # define XCAST(fun) (void *)
4535 #endif
4536
4537 static ICOM_VTABLE(IDirectDraw) dga_ddvt =
4538 {
4539 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4540 XCAST(QueryInterface)DGA_IDirectDraw2Impl_QueryInterface,
4541 XCAST(AddRef)IDirectDraw2Impl_AddRef,
4542 XCAST(Release)DGA_IDirectDraw2Impl_Release,
4543 XCAST(Compact)IDirectDraw2Impl_Compact,
4544 XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4545 XCAST(CreatePalette)DGA_IDirectDraw2Impl_CreatePalette,
4546 XCAST(CreateSurface)DGA_IDirectDraw2Impl_CreateSurface,
4547 XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4548 XCAST(EnumDisplayModes)DGA_IDirectDraw2Impl_EnumDisplayModes,
4549 XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4550 XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4551 XCAST(GetCaps)DGA_IDirectDraw2Impl_GetCaps,
4552 XCAST(GetDisplayMode)DGA_IDirectDraw2Impl_GetDisplayMode,
4553 XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4554 XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4555 XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4556 XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4557 XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4558 XCAST(Initialize)IDirectDraw2Impl_Initialize,
4559 XCAST(RestoreDisplayMode)DGA_IDirectDraw2Impl_RestoreDisplayMode,
4560 XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4561 DGA_IDirectDrawImpl_SetDisplayMode,
4562 XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4563 };
4564
4565 #undef XCAST
4566
4567 #endif /* defined(HAVE_LIBXXF86DGA) */
4568
4569 /* Note: Hack so we can reuse the old functions without compiler warnings */
4570 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4571 # define XCAST(fun) (typeof(xlib_ddvt.fn##fun))
4572 #else
4573 # define XCAST(fun) (void *)
4574 #endif
4575
4576 static ICOM_VTABLE(IDirectDraw) xlib_ddvt =
4577 {
4578 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4579 XCAST(QueryInterface)Xlib_IDirectDraw2Impl_QueryInterface,
4580 XCAST(AddRef)IDirectDraw2Impl_AddRef,
4581 XCAST(Release)Xlib_IDirectDraw2Impl_Release,
4582 XCAST(Compact)IDirectDraw2Impl_Compact,
4583 XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4584 XCAST(CreatePalette)Xlib_IDirectDraw2Impl_CreatePalette,
4585 XCAST(CreateSurface)Xlib_IDirectDraw2Impl_CreateSurface,
4586 XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4587 XCAST(EnumDisplayModes)Xlib_IDirectDraw2Impl_EnumDisplayModes,
4588 XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4589 XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4590 XCAST(GetCaps)Xlib_IDirectDraw2Impl_GetCaps,
4591 XCAST(GetDisplayMode)Xlib_IDirectDraw2Impl_GetDisplayMode,
4592 XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4593 XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4594 XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4595 XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4596 XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4597 XCAST(Initialize)IDirectDraw2Impl_Initialize,
4598 XCAST(RestoreDisplayMode)Xlib_IDirectDraw2Impl_RestoreDisplayMode,
4599 XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4600 Xlib_IDirectDrawImpl_SetDisplayMode,
4601 XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4602 };
4603
4604 #undef XCAST
4605
4606 /*****************************************************************************
4607 * IDirectDraw2
4608 *
4609 */
4610
4611
4612 #ifdef HAVE_LIBXXF86DGA
4613 static HRESULT WINAPI DGA_IDirectDraw2Impl_SetDisplayMode(
4614 LPDIRECTDRAW2 iface,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
4615 ) {
4616 return DGA_IDirectDrawImpl_SetDisplayMode((LPDIRECTDRAW)iface,width,height,depth);
4617 }
4618 #endif /* defined(HAVE_LIBXXF86DGA) */
4619
4620 static HRESULT WINAPI Xlib_IDirectDraw2Impl_SetDisplayMode(
4621 LPDIRECTDRAW2 iface,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
4622 ) {
4623 return Xlib_IDirectDrawImpl_SetDisplayMode((LPDIRECTDRAW)iface,width,height,depth);
4624 }
4625
4626 #ifdef HAVE_LIBXXF86DGA
4627 static HRESULT WINAPI DGA_IDirectDraw2Impl_GetAvailableVidMem(
4628 LPDIRECTDRAW2 iface,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
4629 ) {
4630 ICOM_THIS(IDirectDraw2Impl,iface);
4631 TRACE("(%p)->(%p,%p,%p)\n",
4632 This,ddscaps,total,free
4633 );
4634 if (total) *total = This->e.dga.fb_memsize * 1024;
4635 if (free) *free = This->e.dga.fb_memsize * 1024;
4636 return DD_OK;
4637 }
4638 #endif /* defined(HAVE_LIBXXF86DGA) */
4639
4640 static HRESULT WINAPI Xlib_IDirectDraw2Impl_GetAvailableVidMem(
4641 LPDIRECTDRAW2 iface,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
4642 ) {
4643 ICOM_THIS(IDirectDraw2Impl,iface);
4644 TRACE("(%p)->(%p,%p,%p)\n",
4645 This,ddscaps,total,free
4646 );
4647 if (total) *total = 2048 * 1024;
4648 if (free) *free = 2048 * 1024;
4649 return DD_OK;
4650 }
4651
4652 #ifdef HAVE_LIBXXF86DGA
4653 static ICOM_VTABLE(IDirectDraw2) dga_dd2vt =
4654 {
4655 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4656 DGA_IDirectDraw2Impl_QueryInterface,
4657 IDirectDraw2Impl_AddRef,
4658 DGA_IDirectDraw2Impl_Release,
4659 IDirectDraw2Impl_Compact,
4660 IDirectDraw2Impl_CreateClipper,
4661 DGA_IDirectDraw2Impl_CreatePalette,
4662 DGA_IDirectDraw2Impl_CreateSurface,
4663 IDirectDraw2Impl_DuplicateSurface,
4664 DGA_IDirectDraw2Impl_EnumDisplayModes,
4665 IDirectDraw2Impl_EnumSurfaces,
4666 IDirectDraw2Impl_FlipToGDISurface,
4667 DGA_IDirectDraw2Impl_GetCaps,
4668 DGA_IDirectDraw2Impl_GetDisplayMode,
4669 IDirectDraw2Impl_GetFourCCCodes,
4670 IDirectDraw2Impl_GetGDISurface,
4671 IDirectDraw2Impl_GetMonitorFrequency,
4672 IDirectDraw2Impl_GetScanLine,
4673 IDirectDraw2Impl_GetVerticalBlankStatus,
4674 IDirectDraw2Impl_Initialize,
4675 DGA_IDirectDraw2Impl_RestoreDisplayMode,
4676 IDirectDraw2Impl_SetCooperativeLevel,
4677 DGA_IDirectDraw2Impl_SetDisplayMode,
4678 IDirectDraw2Impl_WaitForVerticalBlank,
4679 DGA_IDirectDraw2Impl_GetAvailableVidMem
4680 };
4681 #endif /* defined(HAVE_LIBXXF86DGA) */
4682
4683 static ICOM_VTABLE(IDirectDraw2) xlib_dd2vt =
4684 {
4685 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4686 Xlib_IDirectDraw2Impl_QueryInterface,
4687 IDirectDraw2Impl_AddRef,
4688 Xlib_IDirectDraw2Impl_Release,
4689 IDirectDraw2Impl_Compact,
4690 IDirectDraw2Impl_CreateClipper,
4691 Xlib_IDirectDraw2Impl_CreatePalette,
4692 Xlib_IDirectDraw2Impl_CreateSurface,
4693 IDirectDraw2Impl_DuplicateSurface,
4694 Xlib_IDirectDraw2Impl_EnumDisplayModes,
4695 IDirectDraw2Impl_EnumSurfaces,
4696 IDirectDraw2Impl_FlipToGDISurface,
4697 Xlib_IDirectDraw2Impl_GetCaps,
4698 Xlib_IDirectDraw2Impl_GetDisplayMode,
4699 IDirectDraw2Impl_GetFourCCCodes,
4700 IDirectDraw2Impl_GetGDISurface,
4701 IDirectDraw2Impl_GetMonitorFrequency,
4702 IDirectDraw2Impl_GetScanLine,
4703 IDirectDraw2Impl_GetVerticalBlankStatus,
4704 IDirectDraw2Impl_Initialize,
4705 Xlib_IDirectDraw2Impl_RestoreDisplayMode,
4706 IDirectDraw2Impl_SetCooperativeLevel,
4707 Xlib_IDirectDraw2Impl_SetDisplayMode,
4708 IDirectDraw2Impl_WaitForVerticalBlank,
4709 Xlib_IDirectDraw2Impl_GetAvailableVidMem
4710 };
4711
4712 /*****************************************************************************
4713 * IDirectDraw4
4714 *
4715 */
4716
4717 static HRESULT WINAPI IDirectDraw4Impl_GetSurfaceFromDC(LPDIRECTDRAW4 iface,
4718 HDC hdc,
4719 LPDIRECTDRAWSURFACE *lpDDS) {
4720 ICOM_THIS(IDirectDraw4Impl,iface);
4721 FIXME("(%p)->(%08ld,%p)\n", This, (DWORD) hdc, lpDDS);
4722
4723 return DD_OK;
4724 }
4725
4726 static HRESULT WINAPI IDirectDraw4Impl_RestoreAllSurfaces(LPDIRECTDRAW4 iface) {
4727 ICOM_THIS(IDirectDraw4Impl,iface);
4728 FIXME("(%p)->()\n", This);
4729
4730 return DD_OK;
4731 }
4732
4733 static HRESULT WINAPI IDirectDraw4Impl_TestCooperativeLevel(LPDIRECTDRAW4 iface) {
4734 ICOM_THIS(IDirectDraw4Impl,iface);
4735 FIXME("(%p)->()\n", This);
4736
4737 return DD_OK;
4738 }
4739
4740 static HRESULT WINAPI IDirectDraw4Impl_GetDeviceIdentifier(LPDIRECTDRAW4 iface,
4741 LPDDDEVICEIDENTIFIER lpdddi,
4742 DWORD dwFlags) {
4743 ICOM_THIS(IDirectDraw4Impl,iface);
4744 FIXME("(%p)->(%p,%08lx)\n", This, lpdddi, dwFlags);
4745
4746 return DD_OK;
4747 }
4748
4749 #ifdef HAVE_LIBXXF86DGA
4750
4751 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4752 # define XCAST(fun) (typeof(dga_dd4vt.fn##fun))
4753 #else
4754 # define XCAST(fun) (void*)
4755 #endif
4756
4757 static ICOM_VTABLE(IDirectDraw4) dga_dd4vt =
4758 {
4759 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4760 XCAST(QueryInterface)DGA_IDirectDraw2Impl_QueryInterface,
4761 XCAST(AddRef)IDirectDraw2Impl_AddRef,
4762 XCAST(Release)DGA_IDirectDraw2Impl_Release,
4763 XCAST(Compact)IDirectDraw2Impl_Compact,
4764 XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4765 XCAST(CreatePalette)DGA_IDirectDraw2Impl_CreatePalette,
4766 XCAST(CreateSurface)DGA_IDirectDraw2Impl_CreateSurface,
4767 XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4768 XCAST(EnumDisplayModes)DGA_IDirectDraw2Impl_EnumDisplayModes,
4769 XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4770 XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4771 XCAST(GetCaps)DGA_IDirectDraw2Impl_GetCaps,
4772 XCAST(GetDisplayMode)DGA_IDirectDraw2Impl_GetDisplayMode,
4773 XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4774 XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4775 XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4776 XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4777 XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4778 XCAST(Initialize)IDirectDraw2Impl_Initialize,
4779 XCAST(RestoreDisplayMode)DGA_IDirectDraw2Impl_RestoreDisplayMode,
4780 XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4781 XCAST(SetDisplayMode)DGA_IDirectDrawImpl_SetDisplayMode,
4782 XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4783 XCAST(GetAvailableVidMem)DGA_IDirectDraw2Impl_GetAvailableVidMem,
4784 IDirectDraw4Impl_GetSurfaceFromDC,
4785 IDirectDraw4Impl_RestoreAllSurfaces,
4786 IDirectDraw4Impl_TestCooperativeLevel,
4787 IDirectDraw4Impl_GetDeviceIdentifier
4788 };
4789
4790 #undef XCAST
4791
4792 #endif /* defined(HAVE_LIBXXF86DGA) */
4793
4794 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4795 # define XCAST(fun) (typeof(xlib_dd4vt.fn##fun))
4796 #else
4797 # define XCAST(fun) (void*)
4798 #endif
4799
4800 static ICOM_VTABLE(IDirectDraw4) xlib_dd4vt =
4801 {
4802 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4803 XCAST(QueryInterface)Xlib_IDirectDraw2Impl_QueryInterface,
4804 XCAST(AddRef)IDirectDraw2Impl_AddRef,
4805 XCAST(Release)Xlib_IDirectDraw2Impl_Release,
4806 XCAST(Compact)IDirectDraw2Impl_Compact,
4807 XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4808 XCAST(CreatePalette)Xlib_IDirectDraw2Impl_CreatePalette,
4809 XCAST(CreateSurface)Xlib_IDirectDraw2Impl_CreateSurface,
4810 XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4811 XCAST(EnumDisplayModes)Xlib_IDirectDraw2Impl_EnumDisplayModes,
4812 XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4813 XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4814 XCAST(GetCaps)Xlib_IDirectDraw2Impl_GetCaps,
4815 XCAST(GetDisplayMode)Xlib_IDirectDraw2Impl_GetDisplayMode,
4816 XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4817 XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4818 XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4819 XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4820 XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4821 XCAST(Initialize)IDirectDraw2Impl_Initialize,
4822 XCAST(RestoreDisplayMode)Xlib_IDirectDraw2Impl_RestoreDisplayMode,
4823 XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4824 XCAST(SetDisplayMode)Xlib_IDirectDrawImpl_SetDisplayMode,
4825 XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4826 XCAST(GetAvailableVidMem)Xlib_IDirectDraw2Impl_GetAvailableVidMem,
4827 IDirectDraw4Impl_GetSurfaceFromDC,
4828 IDirectDraw4Impl_RestoreAllSurfaces,
4829 IDirectDraw4Impl_TestCooperativeLevel,
4830 IDirectDraw4Impl_GetDeviceIdentifier
4831 };
4832
4833 #undef XCAST
4834
4835 /******************************************************************************
4836 * DirectDrawCreate
4837 */
4838
4839 static LRESULT WINAPI Xlib_DDWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
4840 {
4841 LRESULT ret;
4842 IDirectDrawImpl* ddraw = NULL;
4843 DWORD lastError;
4844
4845 /* FIXME(ddraw,"(0x%04x,%s,0x%08lx,0x%08lx),stub!\n",(int)hwnd,SPY_GetMsgName(msg),(long)wParam,(long)lParam); */
4846
4847 SetLastError( ERROR_SUCCESS );
4848 ddraw = (IDirectDrawImpl*)GetWindowLongA( hwnd, ddrawXlibThisOffset );
4849 if( (!ddraw) &&
4850 ( ( lastError = GetLastError() ) != ERROR_SUCCESS )
4851 )
4852 {
4853 ERR("Unable to retrieve this ptr from window. Error %08lx\n", lastError );
4854 }
4855
4856 if( ddraw )
4857 {
4858 /* Perform any special direct draw functions */
4859 if (msg==WM_PAINT)
4860 ddraw->d.paintable = 1;
4861
4862 /* Now let the application deal with the rest of this */
4863 if( ddraw->d.mainWindow )
4864 {
4865
4866 /* Don't think that we actually need to call this but...
4867 might as well be on the safe side of things... */
4868
4869 /* I changed hwnd to ddraw->d.mainWindow as I did not see why
4870 it should be the procedures of our fake window that gets called
4871 instead of those of the window provided by the application.
4872 And with this patch, mouse clicks work with Monkey Island III
4873 - Lionel */
4874 ret = DefWindowProcA( ddraw->d.mainWindow, msg, wParam, lParam );
4875
4876 if( !ret )
4877 {
4878 WND *tmpWnd =WIN_FindWndPtr(ddraw->d.mainWindow);
4879 /* We didn't handle the message - give it to the application */
4880 if (ddraw && ddraw->d.mainWindow && tmpWnd)
4881 {
4882 ret = CallWindowProcA(tmpWnd->winproc,
4883 ddraw->d.mainWindow, msg, wParam, lParam );
4884 }
4885 WIN_ReleaseWndPtr(tmpWnd);
4886
4887 }
4888
4889 } else {
4890 ret = DefWindowProcA(hwnd, msg, wParam, lParam );
4891 }
4892
4893 }
4894 else
4895 {
4896 ret = DefWindowProcA(hwnd,msg,wParam,lParam);
4897 }
4898
4899 return ret;
4900 }
4901
4902 static HRESULT WINAPI DGA_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
4903 #ifdef HAVE_LIBXXF86DGA
4904 IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
4905 int memsize,banksize,width,major,minor,flags,height;
4906 char *addr;
4907 int fd;
4908 int depth;
4909
4910 /* Must be able to access /dev/mem for DGA extensions to work, root is not neccessary. --stephenc */
4911 if ((fd = open("/dev/mem", O_RDWR)) != -1)
4912 close(fd);
4913
4914 if (fd == -1) {
4915 MESSAGE("Must be able to access /dev/mem to use XF86DGA!\n");
4916 MessageBoxA(0,"Using the XF86DGA extension requires access to /dev/mem.","WINE DirectDraw",MB_OK|MB_ICONSTOP);
4917 return E_UNEXPECTED;
4918 }
4919 if (!DDRAW_DGA_Available()) {
4920 TRACE("No XF86DGA detected.\n");
4921 return DDERR_GENERIC;
4922 }
4923 *ilplpDD = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawImpl));
4924 (*ilplpDD)->lpvtbl = &dga_ddvt;
4925 (*ilplpDD)->ref = 1;
4926 TSXF86DGAQueryVersion(display,&major,&minor);
4927 TRACE("XF86DGA is version %d.%d\n",major,minor);
4928 TSXF86DGAQueryDirectVideo(display,DefaultScreen(display),&flags);
4929 if (!(flags & XF86DGADirectPresent))
4930 MESSAGE("direct video is NOT PRESENT.\n");
4931 TSXF86DGAGetVideo(display,DefaultScreen(display),&addr,&width,&banksize,&memsize);
4932 (*ilplpDD)->e.dga.fb_width = width;
4933 TSXF86DGAGetViewPortSize(display,DefaultScreen(display),&width,&height);
4934 TSXF86DGASetViewPort(display,DefaultScreen(display),0,0);
4935 (*ilplpDD)->e.dga.fb_height = height;
4936 TRACE("video framebuffer: begin %p, width %d,banksize %d,memsize %d\n",
4937 addr,width,banksize,memsize
4938 );
4939 TRACE("viewport height: %d\n",height);
4940
4941 /* Get the screen dimensions as seen by Wine.
4942 In that case, it may be better to ignore the -desktop mode and return the
4943 real screen size => print a warning */
4944 (*ilplpDD)->d.height = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
4945 (*ilplpDD)->d.width = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
4946 if (((*ilplpDD)->d.height != height) ||
4947 ((*ilplpDD)->d.width != width))
4948 WARN("You seem to be runnin in -desktop mode. This may prove dangerous in DGA mode...\n");
4949 (*ilplpDD)->e.dga.fb_addr = addr;
4950 (*ilplpDD)->e.dga.fb_memsize = memsize;
4951 (*ilplpDD)->e.dga.fb_banksize = banksize;
4952 (*ilplpDD)->e.dga.vpmask = 0;
4953
4954 /* just assume the default depth is the DGA depth too */
4955 depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
4956 _common_depth_to_pixelformat(depth, &((*ilplpDD)->d.directdraw_pixelformat), &((*ilplpDD)->d.screen_pixelformat), NULL);
4957 #ifdef RESTORE_SIGNALS
4958 SIGNAL_Init();
4959 #endif
4960
4961 return DD_OK;
4962 #else /* defined(HAVE_LIBXXF86DGA) */
4963 return DDERR_INVALIDDIRECTDRAWGUID;
4964 #endif /* defined(HAVE_LIBXXF86DGA) */
4965 }
4966
4967 static BOOL
4968 DDRAW_XSHM_Available(void)
4969 {
4970 #ifdef HAVE_LIBXXSHM
4971 if (TSXShmQueryExtension(display))
4972 {
4973 int major, minor;
4974 Bool shpix;
4975
4976 if ((TSXShmQueryVersion(display, &major, &minor, &shpix)) &&
4977 (Options.noXSHM != 1))
4978 return 1;
4979 else
4980 return 0;
4981 }
4982 else
4983 return 0;
4984 #else
4985 return 0;
4986 #endif
4987 }
4988
4989 static HRESULT WINAPI Xlib_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
4990 IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
4991 int depth;
4992
4993 *ilplpDD = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawImpl));
4994 (*ilplpDD)->lpvtbl = &xlib_ddvt;
4995 (*ilplpDD)->ref = 1;
4996 (*ilplpDD)->d.drawable = 0; /* in SetDisplayMode */
4997
4998 /* At DirectDraw creation, the depth is the default depth */
4999 depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
5000 _common_depth_to_pixelformat(depth,
5001 &((*ilplpDD)->d.directdraw_pixelformat),
5002 &((*ilplpDD)->d.screen_pixelformat),
5003 &((*ilplpDD)->d.pixmap_depth));
5004 (*ilplpDD)->d.height = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
5005 (*ilplpDD)->d.width = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
5006
5007 #ifdef HAVE_LIBXXSHM
5008 /* Test if XShm is available. */
5009 if (((*ilplpDD)->e.xlib.xshm_active = DDRAW_XSHM_Available()))
5010 TRACE("Using XShm extension.\n");
5011 #endif
5012
5013 return DD_OK;
5014 }
5015
5016 HRESULT WINAPI DirectDrawCreate( LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter ) {
5017 IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
5018 char xclsid[50];
5019 WNDCLASSA wc;
5020 /* WND* pParentWindow; */
5021 HRESULT ret;
5022
5023 if (HIWORD(lpGUID))
5024 WINE_StringFromCLSID(lpGUID,xclsid);
5025 else {
5026 sprintf(xclsid,"<guid-0x%08x>",(int)lpGUID);
5027 lpGUID = NULL;
5028 }
5029
5030 TRACE("(%s,%p,%p)\n",xclsid,ilplpDD,pUnkOuter);
5031
5032 if ( ( !lpGUID ) ||
5033 ( IsEqualGUID( &IID_IDirectDraw, lpGUID ) ) ||
5034 ( IsEqualGUID( &IID_IDirectDraw2, lpGUID ) ) ||
5035 ( IsEqualGUID( &IID_IDirectDraw4, lpGUID ) ) ) {
5036 /* if they didn't request a particular interface, use the best
5037 * supported one */
5038 if (DDRAW_DGA_Available())
5039 lpGUID = &DGA_DirectDraw_GUID;
5040 else
5041 lpGUID = &XLIB_DirectDraw_GUID;
5042 }
5043
5044 wc.style = CS_GLOBALCLASS;
5045 wc.lpfnWndProc = Xlib_DDWndProc;
5046 wc.cbClsExtra = 0;
5047 wc.cbWndExtra = /* Defines extra mem for window. This is used for storing this */
5048 sizeof( LPDIRECTDRAW ); /* ddrawXlibThisOffset */
5049
5050 /* We can be a child of the desktop since we're really important */
5051 /*
5052 This code is not useful since hInstance is forced to 0 afterward
5053 pParentWindow = WIN_GetDesktop();
5054 wc.hInstance = pParentWindow ? pParentWindow->hwndSelf : 0;
5055 */
5056 wc.hInstance = 0;
5057
5058
5059 wc.hIcon = 0;
5060 wc.hCursor = (HCURSOR)IDC_ARROWA;
5061 wc.hbrBackground= NULL_BRUSH;
5062 wc.lpszMenuName = 0;
5063 wc.lpszClassName= "WINE_DirectDraw";
5064 RegisterClassA(&wc);
5065
5066 if ( IsEqualGUID( &DGA_DirectDraw_GUID, lpGUID ) ) {
5067 ret = DGA_DirectDrawCreate(lplpDD, pUnkOuter);
5068 }
5069 else if ( IsEqualGUID( &XLIB_DirectDraw_GUID, &XLIB_DirectDraw_GUID ) ) {
5070 ret = Xlib_DirectDrawCreate(lplpDD, pUnkOuter);
5071 }
5072 else {
5073 goto err;
5074 }
5075
5076
5077 (*ilplpDD)->d.winclass = RegisterClassA(&wc);
5078 return ret;
5079
5080 err:
5081 ERR("DirectDrawCreate(%s,%p,%p): did not recognize requested GUID\n",xclsid,lplpDD,pUnkOuter);
5082 return DDERR_INVALIDDIRECTDRAWGUID;
5083 }
5084
5085 /*******************************************************************************
5086 * DirectDraw ClassFactory
5087 *
5088 * Heavily inspired (well, can you say completely copied :-) ) from DirectSound
5089 *
5090 */
5091 typedef struct
5092 {
5093 /* IUnknown fields */
5094 ICOM_VTABLE(IClassFactory)* lpvtbl;
5095 DWORD ref;
5096 } IClassFactoryImpl;
5097
5098 static HRESULT WINAPI
5099 DDCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
5100 ICOM_THIS(IClassFactoryImpl,iface);
5101 char buf[80];
5102
5103 if (HIWORD(riid))
5104 WINE_StringFromCLSID(riid,buf);
5105 else
5106 sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
5107 FIXME("(%p)->(%s,%p),stub!\n",This,buf,ppobj);
5108 return E_NOINTERFACE;
5109 }
5110
5111 static ULONG WINAPI
5112 DDCF_AddRef(LPCLASSFACTORY iface) {
5113 ICOM_THIS(IClassFactoryImpl,iface);
5114 return ++(This->ref);
5115 }
5116
5117 static ULONG WINAPI DDCF_Release(LPCLASSFACTORY iface) {
5118 ICOM_THIS(IClassFactoryImpl,iface);
5119 /* static class, won't be freed */
5120 return --(This->ref);
5121 }
5122
5123 static HRESULT WINAPI DDCF_CreateInstance(
5124 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
5125 ) {
5126 ICOM_THIS(IClassFactoryImpl,iface);
5127 char buf[80];
5128
5129 WINE_StringFromCLSID(riid,buf);
5130 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,buf,ppobj);
5131 if ( ( IsEqualGUID( &IID_IDirectDraw, riid ) ) ||
5132 ( IsEqualGUID( &IID_IDirectDraw2, riid ) ) ||
5133 ( IsEqualGUID( &IID_IDirectDraw4, riid ) ) ) {
5134 /* FIXME: reuse already created DirectDraw if present? */
5135 return DirectDrawCreate((LPGUID) riid,(LPDIRECTDRAW*)ppobj,pOuter);
5136 }
5137 return CLASS_E_CLASSNOTAVAILABLE;
5138 }
5139
5140 static HRESULT WINAPI DDCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
5141 ICOM_THIS(IClassFactoryImpl,iface);
5142 FIXME("(%p)->(%d),stub!\n",This,dolock);
5143 return S_OK;
5144 }
5145
5146 static ICOM_VTABLE(IClassFactory) DDCF_Vtbl =
5147 {
5148 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
5149 DDCF_QueryInterface,
5150 DDCF_AddRef,
5151 DDCF_Release,
5152 DDCF_CreateInstance,
5153 DDCF_LockServer
5154 };
5155 static IClassFactoryImpl DDRAW_CF = {&DDCF_Vtbl, 1 };
5156
5157 /*******************************************************************************
5158 * DllGetClassObject [DDRAW.13]
5159 * Retrieves class object from a DLL object
5160 *
5161 * NOTES
5162 * Docs say returns STDAPI
5163 *
5164 * PARAMS
5165 * rclsid [I] CLSID for the class object
5166 * riid [I] Reference to identifier of interface for class object
5167 * ppv [O] Address of variable to receive interface pointer for riid
5168 *
5169 * RETURNS
5170 * Success: S_OK
5171 * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
5172 * E_UNEXPECTED
5173 */
5174 DWORD WINAPI DDRAW_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
5175 {
5176 char buf[80],xbuf[80];
5177
5178 if (HIWORD(rclsid))
5179 WINE_StringFromCLSID(rclsid,xbuf);
5180 else
5181 sprintf(xbuf,"<guid-0x%04x>",LOWORD(rclsid));
5182 if (HIWORD(riid))
5183 WINE_StringFromCLSID(riid,buf);
5184 else
5185 sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
5186 WINE_StringFromCLSID(riid,xbuf);
5187 TRACE("(%p,%p,%p)\n", xbuf, buf, ppv);
5188 if ( IsEqualCLSID( &IID_IClassFactory, riid ) ) {
5189 *ppv = (LPVOID)&DDRAW_CF;
5190 IClassFactory_AddRef((IClassFactory*)*ppv);
5191 return S_OK;
5192 }
5193 FIXME("(%p,%p,%p): no interface found.\n", xbuf, buf, ppv);
5194 return CLASS_E_CLASSNOTAVAILABLE;
5195 }
5196
5197
5198 /*******************************************************************************
5199 * DllCanUnloadNow [DDRAW.12] Determines whether the DLL is in use.
5200 *
5201 * RETURNS
5202 * Success: S_OK
5203 * Failure: S_FALSE
5204 */
5205 DWORD WINAPI DDRAW_DllCanUnloadNow(void)
5206 {
5207 FIXME("(void): stub\n");
5208 return S_FALSE;
5209 }
5210
5211 #else /* !defined(X_DISPLAY_MISSING) */
5212
5213 #include "windef.h"
5214 #include "winerror.h"
5215 #include "wtypes.h"
5216
5217 #define DD_OK 0
5218
5219 typedef void *LPUNKNOWN;
5220 typedef void *LPDIRECTDRAW;
5221 typedef void *LPDIRECTDRAWCLIPPER;
5222 typedef void *LPDDENUMCALLBACKA;
5223 typedef void *LPDDENUMCALLBACKEXA;
5224 typedef void *LPDDENUMCALLBACKEXW;
5225 typedef void *LPDDENUMCALLBACKW;
5226
5227 HRESULT WINAPI DSoundHelp(DWORD x, DWORD y, DWORD z)
5228 {
5229 return DD_OK;
5230 }
5231
5232 HRESULT WINAPI DirectDrawCreate(
5233 LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter)
5234 {
5235 return DD_OK;
5236 }
5237
5238 HRESULT WINAPI DirectDrawCreateClipper(
5239 DWORD dwFlags, LPDIRECTDRAWCLIPPER *lplpDDClipper, LPUNKNOWN pUnkOuter)
5240 {
5241 return DD_OK;
5242 }
5243
5244 HRESULT WINAPI DirectDrawEnumerateA(
5245 LPDDENUMCALLBACKA lpCallback, LPVOID lpContext)
5246 {
5247 return DD_OK;
5248 }
5249
5250 HRESULT WINAPI DirectDrawEnumerateExA(
5251 LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
5252 {
5253 return DD_OK;
5254 }
5255
5256 HRESULT WINAPI DirectDrawEnumerateExW(
5257 LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
5258 {
5259 return DD_OK;
5260 }
5261
5262 HRESULT WINAPI DirectDrawEnumerateW(
5263 LPDDENUMCALLBACKW lpCallback, LPVOID lpContext)
5264 {
5265 return DD_OK;
5266 }
5267
5268 DWORD WINAPI DDRAW_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
5269 {
5270 return CLASS_E_CLASSNOTAVAILABLE;
5271 }
5272
5273 DWORD WINAPI DDRAW_DllCanUnloadNow(void)
5274 {
5275 return DD_OK;
5276 }
5277
5278 #endif /* !defined(X_DISPLAY_MISSING) */
5279
5280
5281
5282