wined3d: Stencil states -> misc table.
[wine] / dlls / wined3d / surface_gdi.c
1 /*
2  * 2D Surface implementation without OpenGL
3  *
4  * Copyright 1997-2000 Marcus Meissner
5  * Copyright 1998-2000 Lionel Ulmer
6  * Copyright 2000-2001 TransGaming Technologies Inc.
7  * Copyright 2002-2005 Jason Edmeades
8  * Copyright 2002-2003 Raphael Junqueira
9  * Copyright 2004 Christian Costa
10  * Copyright 2005 Oliver Stieber
11  * Copyright 2006-2008 Stefan Dösinger
12  *
13  * This library is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU Lesser General Public
15  * License as published by the Free Software Foundation; either
16  * version 2.1 of the License, or (at your option) any later version.
17  *
18  * This library is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21  * Lesser General Public License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public
24  * License along with this library; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26  */
27
28 #include "config.h"
29 #include "wine/port.h"
30 #include "wined3d_private.h"
31
32 #include <assert.h>
33 #include <stdio.h>
34
35 /* Use the d3d_surface debug channel to have one channel for all surfaces */
36 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
37 WINE_DECLARE_DEBUG_CHANNEL(fps);
38
39 /*****************************************************************************
40  * x11_copy_to_screen
41  *
42  * Helper function that blts the front buffer contents to the target window
43  *
44  * Params:
45  *  This: Surface to copy from
46  *  rc: Rectangle to copy
47  *
48  *****************************************************************************/
49 static void
50 x11_copy_to_screen(IWineD3DSurfaceImpl *This,
51                    LPRECT rc)
52 {
53     if(This->resource.usage & WINED3DUSAGE_RENDERTARGET)
54     {
55         POINT offset = {0,0};
56         HWND hDisplayWnd;
57         HDC hDisplayDC;
58         HDC hSurfaceDC = 0;
59         RECT drawrect;
60         TRACE("(%p)->(%p): Copying to screen\n", This, rc);
61
62         hSurfaceDC = This->hDC;
63
64         hDisplayWnd = This->resource.wineD3DDevice->ddraw_window;
65         hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS|DCX_CACHE);
66         if(rc)
67         {
68             TRACE(" copying rect (%d,%d)->(%d,%d), offset (%d,%d)\n",
69             rc->left, rc->top, rc->right, rc->bottom, offset.x, offset.y);
70         }
71
72         /* Front buffer coordinates are screen coordinates. Map them to the destination
73          * window if not fullscreened
74          */
75         if(!This->resource.wineD3DDevice->ddraw_fullscreen) {
76             ClientToScreen(hDisplayWnd, &offset);
77         }
78 #if 0
79         /* FIXME: this doesn't work... if users really want to run
80         * X in 8bpp, then we need to call directly into display.drv
81         * (or Wine's equivalent), and force a private colormap
82         * without default entries. */
83         if (This->palette) {
84             SelectPalette(hDisplayDC, This->palette->hpal, FALSE);
85             RealizePalette(hDisplayDC); /* sends messages => deadlocks */
86         }
87 #endif
88         drawrect.left   = 0;
89         drawrect.right  = This->currentDesc.Width;
90         drawrect.top    = 0;
91         drawrect.bottom = This->currentDesc.Height;
92
93 #if 0
94         /* TODO: Support clippers */
95         if (This->clipper)
96         {
97             RECT xrc;
98             HWND hwnd = ((IWineD3DClipperImpl *) This->clipper)->hWnd;
99             if (hwnd && GetClientRect(hwnd,&xrc))
100             {
101                 OffsetRect(&xrc,offset.x,offset.y);
102                 IntersectRect(&drawrect,&drawrect,&xrc);
103             }
104         }
105 #endif
106         if (rc)
107         {
108             IntersectRect(&drawrect,&drawrect,rc);
109         }
110         else
111         {
112             /* Only use this if the caller did not pass a rectangle, since
113              * due to double locking this could be the wrong one ...
114              */
115             if (This->lockedRect.left != This->lockedRect.right)
116             {
117                 IntersectRect(&drawrect,&drawrect,&This->lockedRect);
118             }
119         }
120
121         BitBlt(hDisplayDC,
122                drawrect.left-offset.x, drawrect.top-offset.y,
123                drawrect.right-drawrect.left, drawrect.bottom-drawrect.top,
124                hSurfaceDC,
125                drawrect.left, drawrect.top,
126                SRCCOPY);
127         ReleaseDC(hDisplayWnd, hDisplayDC);
128     }
129 }
130
131 /*****************************************************************************
132  * IWineD3DSurface::Release, GDI version
133  *
134  * In general a normal COM Release method, but the GDI version doesn't have
135  * to destroy all the GL things.
136  *
137  *****************************************************************************/
138 ULONG WINAPI IWineGDISurfaceImpl_Release(IWineD3DSurface *iface) {
139     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
140     ULONG ref = InterlockedDecrement(&This->resource.ref);
141     TRACE("(%p) : Releasing from %d\n", This, ref + 1);
142     if (ref == 0) {
143         IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
144         TRACE("(%p) : cleaning up\n", This);
145
146         if(This->Flags & SFLAG_DIBSECTION) {
147             /* Release the DC */
148             SelectObject(This->hDC, This->dib.holdbitmap);
149             DeleteDC(This->hDC);
150             /* Release the DIB section */
151             DeleteObject(This->dib.DIBsection);
152             This->dib.bitmap_data = NULL;
153             This->resource.allocatedMemory = NULL;
154         }
155         if(This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem(iface, NULL);
156
157         HeapFree(GetProcessHeap(), 0, This->palette9);
158
159         IWineD3DResourceImpl_CleanUp((IWineD3DResource *)iface);
160         if(iface == device->ddraw_primary)
161             device->ddraw_primary = NULL;
162
163         TRACE("(%p) Released\n", This);
164         HeapFree(GetProcessHeap(), 0, This);
165
166     }
167     return ref;
168 }
169
170 /*****************************************************************************
171  * IWineD3DSurface::PreLoad, GDI version
172  *
173  * This call is unsupported on GDI surfaces, if it's called something went
174  * wrong in the parent library. Write an informative warning
175  *
176  *****************************************************************************/
177 static void WINAPI
178 IWineGDISurfaceImpl_PreLoad(IWineD3DSurface *iface)
179 {
180     ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface);
181     ERR("(%p): Most likely the parent library did something wrong.\n", iface);
182     ERR("(%p): Please report to wine-devel\n", iface);
183 }
184
185 /*****************************************************************************
186  * IWineD3DSurface::UnLoad, GDI version
187  *
188  * This call is unsupported on GDI surfaces, if it's called something went
189  * wrong in the parent library. Write an informative warning.
190  *
191  *****************************************************************************/
192 static void WINAPI IWineGDISurfaceImpl_UnLoad(IWineD3DSurface *iface)
193 {
194     ERR("(%p): UnLoad is not supported on X11 surfaces!\n", iface);
195     ERR("(%p): Most likely the parent library did something wrong.\n", iface);
196     ERR("(%p): Please report to wine-devel\n", iface);
197 }
198
199 /*****************************************************************************
200  * IWineD3DSurface::LockRect, GDI version
201  *
202  * Locks the surface and returns a pointer to the surface memory
203  *
204  * Params:
205  *  pLockedRect: Address to return the locking info at
206  *  pRect: Rectangle to lock
207  *  Flags: Some flags
208  *
209  * Returns:
210  *  WINED3D_OK on success
211  *  WINED3DERR_INVALIDCALL on errors
212  *
213  *****************************************************************************/
214 static HRESULT WINAPI
215 IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface,
216                              WINED3DLOCKED_RECT* pLockedRect,
217                              CONST RECT* pRect,
218                              DWORD Flags)
219 {
220     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
221
222     /* Already locked? */
223     if(This->Flags & SFLAG_LOCKED)
224     {
225         ERR("(%p) Surface already locked\n", This);
226         /* What should I return here? */
227         return WINED3DERR_INVALIDCALL;
228     }
229     This->Flags |= SFLAG_LOCKED;
230
231     if(!This->resource.allocatedMemory) {
232         /* This happens on gdi surfaces if the application set a user pointer and resets it.
233          * Recreate the DIB section
234          */
235         IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
236         This->resource.allocatedMemory = This->dib.bitmap_data;
237     }
238
239     return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags);
240 }
241
242 /*****************************************************************************
243  * IWineD3DSurface::UnlockRect, GDI version
244  *
245  * Unlocks a surface. This implementation doesn't do much, except updating
246  * the window if the front buffer is unlocked
247  *
248  * Returns:
249  *  WINED3D_OK on success
250  *  WINED3DERR_INVALIDCALL on failure
251  *
252  *****************************************************************************/
253 static HRESULT WINAPI
254 IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface *iface)
255 {
256     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
257     IWineD3DDeviceImpl *dev = This->resource.wineD3DDevice;
258     TRACE("(%p)\n", This);
259
260     if (!(This->Flags & SFLAG_LOCKED))
261     {
262         WARN("trying to Unlock an unlocked surf@%p\n", This);
263         return WINED3DERR_INVALIDCALL;
264     }
265
266     /* Can be useful for debugging */
267 #if 0
268         {
269             static unsigned int gen = 0;
270             char buffer[4096];
271             ++gen;
272             if ((gen % 10) == 0) {
273                 snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
274                 IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
275             }
276             /*
277              * debugging crash code
278             if (gen == 250) {
279               void** test = NULL;
280               *test = 0;
281             }
282             */
283         }
284 #endif
285
286     /* Update the screen */
287     if(This == (IWineD3DSurfaceImpl *) dev->ddraw_primary)
288     {
289         x11_copy_to_screen(This, &This->lockedRect);
290     }
291
292     This->Flags &= ~SFLAG_LOCKED;
293     memset(&This->lockedRect, 0, sizeof(RECT));
294     return WINED3D_OK;
295 }
296
297 /*****************************************************************************
298  * IWineD3DSurface::Flip, GDI version
299  *
300  * Flips 2 flipping enabled surfaces. Determining the 2 targets is done by
301  * the parent library. This implementation changes the data pointers of the
302  * surfaces and copies the new front buffer content to the screen
303  *
304  * Params:
305  *  override: Flipping target(e.g. back buffer)
306  *
307  * Returns:
308  *  WINED3D_OK on success
309  *
310  *****************************************************************************/
311 static HRESULT WINAPI
312 IWineGDISurfaceImpl_Flip(IWineD3DSurface *iface,
313                          IWineD3DSurface *override,
314                          DWORD Flags)
315 {
316     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
317     IWineD3DSurfaceImpl *Target = (IWineD3DSurfaceImpl *) override;
318     TRACE("(%p)->(%p,%x)\n", This, override, Flags);
319
320     TRACE("(%p) Flipping to surface %p\n", This, Target);
321
322     if(Target == NULL)
323     {
324         ERR("(%p): Can't flip without a target\n", This);
325         return WINED3DERR_INVALIDCALL;
326     }
327
328     /* Flip the DC */
329     {
330         HDC tmp;
331         tmp = This->hDC;
332         This->hDC = Target->hDC;
333         Target->hDC = tmp;
334     }
335
336     /* Flip the DIBsection */
337     {
338         HBITMAP tmp;
339         tmp = This->dib.DIBsection;
340         This->dib.DIBsection = Target->dib.DIBsection;
341         Target->dib.DIBsection = tmp;
342     }
343
344     /* Flip the surface data */
345     {
346         void* tmp;
347
348         tmp = This->dib.bitmap_data;
349         This->dib.bitmap_data = Target->dib.bitmap_data;
350         Target->dib.bitmap_data = tmp;
351
352         tmp = This->resource.allocatedMemory;
353         This->resource.allocatedMemory = Target->resource.allocatedMemory;
354         Target->resource.allocatedMemory = tmp;
355
356         if(This->resource.heapMemory) {
357             ERR("GDI Surface %p has heap memory allocated\n", This);
358         }
359         if(Target->resource.heapMemory) {
360             ERR("GDI Surface %p has heap memory allocated\n", Target);
361         }
362     }
363
364     /* client_memory should not be different, but just in case */
365     {
366         BOOL tmp;
367         tmp = This->dib.client_memory;
368         This->dib.client_memory = Target->dib.client_memory;
369         Target->dib.client_memory = tmp;
370     }
371
372     /* Useful for debugging */
373 #if 0
374         {
375             static unsigned int gen = 0;
376             char buffer[4096];
377             ++gen;
378             if ((gen % 10) == 0) {
379                 snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
380                 IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
381             }
382             /*
383              * debugging crash code
384             if (gen == 250) {
385               void** test = NULL;
386               *test = 0;
387             }
388             */
389         }
390 #endif
391
392     /* Update the screen */
393     x11_copy_to_screen(This, NULL);
394
395     /* FPS support */
396     if (TRACE_ON(fps))
397     {
398         static long prev_time, frames;
399
400         DWORD time = GetTickCount();
401         frames++;
402         /* every 1.5 seconds */
403         if (time - prev_time > 1500) {
404             TRACE_(fps)("@ approx %.2ffps\n", 1000.0*frames/(time - prev_time));
405             prev_time = time;
406             frames = 0;
407         }
408     }
409
410     return WINED3D_OK;
411 }
412
413 /*****************************************************************************
414  * IWineD3DSurface::LoadTexture, GDI version
415  *
416  * This is mutually unsupported by GDI surfaces
417  *
418  * Returns:
419  *  D3DERR_INVALIDCALL
420  *
421  *****************************************************************************/
422 HRESULT WINAPI
423 IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode)
424 {
425     ERR("Unsupported on X11 surfaces\n");
426     return WINED3DERR_INVALIDCALL;
427 }
428
429 /*****************************************************************************
430  * IWineD3DSurface::SaveSnapshot, GDI version
431  *
432  * This method writes the surface's contents to the in tga format to the
433  * file specified in filename.
434  *
435  * Params:
436  *  filename: File to write to
437  *
438  * Returns:
439  *  WINED3DERR_INVALIDCALL if the file couldn't be opened
440  *  WINED3D_OK on success
441  *
442  *****************************************************************************/
443 static int get_shift(DWORD color_mask) {
444     int shift = 0;
445     while (color_mask > 0xFF) {
446         color_mask >>= 1;
447         shift += 1;
448     }
449     while ((color_mask & 0x80) == 0) {
450         color_mask <<= 1;
451         shift -= 1;
452     }
453     return shift;
454 }
455
456
457 HRESULT WINAPI
458 IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface *iface,
459 const char* filename)
460 {
461     FILE* f = NULL;
462     UINT y = 0, x = 0;
463     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
464     static char *output = NULL;
465     static int size = 0;
466     const StaticPixelFormatDesc *formatEntry = getFormatDescEntry(This->resource.format, NULL, NULL);
467
468     if (This->pow2Width > size) {
469         output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pow2Width * 3);
470         size = This->pow2Width;
471     }
472
473
474     f = fopen(filename, "w+");
475     if (NULL == f) {
476         ERR("opening of %s failed with\n", filename);
477         return WINED3DERR_INVALIDCALL;
478     }
479     fprintf(f, "P6\n%d %d\n255\n", This->pow2Width, This->pow2Height);
480
481     if (This->resource.format == WINED3DFMT_P8) {
482         unsigned char table[256][3];
483         int i;
484
485         if (This->palette == NULL) {
486             fclose(f);
487             return WINED3DERR_INVALIDCALL;
488         }
489         for (i = 0; i < 256; i++) {
490             table[i][0] = This->palette->palents[i].peRed;
491             table[i][1] = This->palette->palents[i].peGreen;
492             table[i][2] = This->palette->palents[i].peBlue;
493         }
494         for (y = 0; y < This->pow2Height; y++) {
495             unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
496             for (x = 0; x < This->pow2Width; x++) {
497                 unsigned char color = *src;
498                 src += 1;
499
500                 output[3 * x + 0] = table[color][0];
501                 output[3 * x + 1] = table[color][1];
502                 output[3 * x + 2] = table[color][2];
503             }
504             fwrite(output, 3 * This->pow2Width, 1, f);
505         }
506     } else {
507         int red_shift, green_shift, blue_shift, pix_width, alpha_shift;
508
509         pix_width = This->bytesPerPixel;
510
511         red_shift = get_shift(formatEntry->redMask);
512         green_shift = get_shift(formatEntry->greenMask);
513         blue_shift = get_shift(formatEntry->blueMask);
514         alpha_shift = get_shift(formatEntry->alphaMask);
515
516         for (y = 0; y < This->pow2Height; y++) {
517             unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
518             for (x = 0; x < This->pow2Width; x++) {         
519                 unsigned int color;
520                 unsigned int comp;
521                 int i;
522
523                 color = 0;
524                 for (i = 0; i < pix_width; i++) {
525                     color |= src[i] << (8 * i);
526                 }
527                 src += 1 * pix_width;
528
529                 comp = color & formatEntry->redMask;
530                 output[3 * x + 0] = red_shift > 0 ? comp >> red_shift : comp << -red_shift;
531                 comp = color & formatEntry->greenMask;
532                 output[3 * x + 1] = green_shift > 0 ? comp >> green_shift : comp << -green_shift;
533                 comp = color & formatEntry->alphaMask;
534                 output[3 * x + 2] = alpha_shift > 0 ? comp >> alpha_shift : comp << -alpha_shift;
535             }
536             fwrite(output, 3 * This->pow2Width, 1, f);
537         }
538     }
539     fclose(f);
540     return WINED3D_OK;
541 }
542
543 HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC) {
544     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
545     WINED3DLOCKED_RECT lock;
546     HRESULT hr;
547     RGBQUAD col[256];
548
549     TRACE("(%p)->(%p)\n",This,pHDC);
550
551     if(This->Flags & SFLAG_USERPTR) {
552         ERR("Not supported on surfaces with an application-provided surfaces\n");
553         return WINEDDERR_NODC;
554     }
555
556     /* Give more detailed info for ddraw */
557     if (This->Flags & SFLAG_DCINUSE)
558         return WINEDDERR_DCALREADYCREATED;
559
560     /* Can't GetDC if the surface is locked */
561     if (This->Flags & SFLAG_LOCKED)
562         return WINED3DERR_INVALIDCALL;
563
564     memset(&lock, 0, sizeof(lock)); /* To be sure */
565
566     /* Should have a DIB section already */
567
568     /* Lock the surface */
569     hr = IWineD3DSurface_LockRect(iface,
570                                   &lock,
571                                   NULL,
572                                   0);
573     if(FAILED(hr)) {
574         ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
575         /* keep the dib section */
576         return hr;
577     }
578
579     if(This->resource.format == WINED3DFMT_P8 ||
580        This->resource.format == WINED3DFMT_A8P8) {
581         unsigned int n;
582         PALETTEENTRY *pal = NULL;
583
584         if(This->palette) {
585             pal = This->palette->palents;
586         } else {
587             IWineD3DSurfaceImpl *dds_primary = (IWineD3DSurfaceImpl *)This->resource.wineD3DDevice->ddraw_primary;
588             if (dds_primary && dds_primary->palette)
589                 pal = dds_primary->palette->palents;
590         }
591
592         if (pal) {
593             for (n=0; n<256; n++) {
594                 col[n].rgbRed   = pal[n].peRed;
595                 col[n].rgbGreen = pal[n].peGreen;
596                 col[n].rgbBlue  = pal[n].peBlue;
597                 col[n].rgbReserved = 0;
598             }
599             SetDIBColorTable(This->hDC, 0, 256, col);
600         }
601     }
602
603     *pHDC = This->hDC;
604     TRACE("returning %p\n",*pHDC);
605     This->Flags |= SFLAG_DCINUSE;
606
607     return WINED3D_OK;
608 }
609
610 HRESULT WINAPI IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) {
611     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
612
613     TRACE("(%p)->(%p)\n",This,hDC);
614
615     if (!(This->Flags & SFLAG_DCINUSE))
616         return WINED3DERR_INVALIDCALL;
617
618     if (This->hDC !=hDC) {
619         WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
620         return WINED3DERR_INVALIDCALL;
621     }
622
623     /* we locked first, so unlock now */
624     IWineD3DSurface_UnlockRect(iface);
625
626     This->Flags &= ~SFLAG_DCINUSE;
627
628     return WINED3D_OK;
629 }
630
631 HRESULT WINAPI IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface *iface) {
632     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
633     RGBQUAD col[256];
634     IWineD3DPaletteImpl *pal = This->palette;
635     unsigned int n;
636     TRACE("(%p)\n", This);
637
638     if (!pal) return WINED3D_OK;
639
640     if(This->Flags & SFLAG_DIBSECTION) {
641         TRACE("(%p): Updating the hdc's palette\n", This);
642         for (n=0; n<256; n++) {
643             col[n].rgbRed   = pal->palents[n].peRed;
644             col[n].rgbGreen = pal->palents[n].peGreen;
645             col[n].rgbBlue  = pal->palents[n].peBlue;
646             col[n].rgbReserved = 0;
647         }
648         SetDIBColorTable(This->hDC, 0, 256, col);
649     }
650
651     /* Update the image because of the palette change. Some games like e.g Red Alert
652        call SetEntries a lot to implement fading. */
653     if(This == (IWineD3DSurfaceImpl *) This->resource.wineD3DDevice->ddraw_primary)
654         x11_copy_to_screen(This, NULL);
655
656     return WINED3D_OK;
657 }
658
659 /*****************************************************************************
660  * IWineD3DSurface::PrivateSetup, GDI version
661  *
662  * Initializes the GDI surface, aka creates the DIB section we render to
663  * The DIB section creation is done by calling GetDC, which will create the
664  * section and releasing the dc to allow the app to use it. The dib section
665  * will stay until the surface is released
666  *
667  * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
668  * are set to the real sizes to save memory. The NONPOW2 flag is unset to
669  * avoid confusion in the shared surface code.
670  *
671  * Returns:
672  *  WINED3D_OK on success
673  *  The return values of called methods on failure
674  *
675  *****************************************************************************/
676 HRESULT WINAPI
677 IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface *iface)
678 {
679     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
680
681     if(This->resource.usage & WINED3DUSAGE_OVERLAY)
682     {
683         ERR("(%p) Overlays not yet supported by GDI surfaces\n", This);
684         return WINED3DERR_INVALIDCALL;
685     }
686     /* Sysmem textures have memory already allocated -
687      * release it, this avoids an unnecessary memcpy
688      */
689     HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
690     This->resource.allocatedMemory = NULL;
691     This->resource.heapMemory = NULL;
692
693     /* We don't mind the nonpow2 stuff in GDI */
694     This->pow2Width = This->currentDesc.Width;
695     This->pow2Height = This->currentDesc.Height;
696
697     IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
698     This->resource.allocatedMemory = This->dib.bitmap_data;
699
700     return WINED3D_OK;
701 }
702
703 void WINAPI IWineGDISurfaceImpl_SetGlTextureDesc(IWineD3DSurface *iface, UINT textureName, int target) {
704     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
705
706     /* Ignore 0 textureName and target. D3D textures can be created with gdi surfaces as plain
707      * containers, but they're useless until the app creates a d3d device from a d3d point of
708      * view, it's not an implementation limitation. This avoids false warnings when the texture
709      * is destroyed and sets the description back to 0/0
710      */
711     if(textureName != 0 || target != 0) {
712         FIXME("(%p) : Should not be called on a GDI surface. textureName %u, target %i\n", This, textureName, target);
713         DebugBreak();
714     }
715 }
716
717 void WINAPI IWineGDISurfaceImpl_GetGlDesc(IWineD3DSurface *iface, glDescriptor **glDescription) {
718     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
719     FIXME("(%p) : Should not be called on a GDI surface\n", This);
720     *glDescription = NULL;
721 }
722
723 HRESULT WINAPI IWineGDISurfaceImpl_AddDirtyRect(IWineD3DSurface *iface, CONST RECT* pDirtyRect) {
724     /* GDI surface data can only be in one location, the system memory dib section. So they are
725      * always clean by definition.
726      */
727     TRACE("No dirtification in GDI surfaces\n");
728     return WINED3D_OK;
729 }
730
731 HRESULT WINAPI IWineGDISurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
732     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
733
734     /* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
735     if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
736         ERR("Not supported on render targets\n");
737         return WINED3DERR_INVALIDCALL;
738     }
739
740     if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
741         WARN("Surface is locked or the HDC is in use\n");
742         return WINED3DERR_INVALIDCALL;
743     }
744
745     if(Mem && Mem != This->resource.allocatedMemory) {
746         void *release = NULL;
747
748         /* Do I have to copy the old surface content? */
749         if(This->Flags & SFLAG_DIBSECTION) {
750                 /* Release the DC. No need to hold the critical section for the update
751             * Thread because this thread runs only on front buffers, but this method
752             * fails for render targets in the check above.
753                 */
754             SelectObject(This->hDC, This->dib.holdbitmap);
755             DeleteDC(This->hDC);
756             /* Release the DIB section */
757             DeleteObject(This->dib.DIBsection);
758             This->dib.bitmap_data = NULL;
759             This->resource.allocatedMemory = NULL;
760             This->hDC = NULL;
761             This->Flags &= ~SFLAG_DIBSECTION;
762         } else if(!(This->Flags & SFLAG_USERPTR)) {
763             release = This->resource.allocatedMemory;
764         }
765         This->resource.allocatedMemory = Mem;
766         This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
767
768         /* Now free the old memory if any */
769         HeapFree(GetProcessHeap(), 0, release);
770     } else if(This->Flags & SFLAG_USERPTR) {
771         /* LockRect and GetDC will re-create the dib section and allocated memory */
772         This->resource.allocatedMemory = NULL;
773         This->Flags &= ~SFLAG_USERPTR;
774     }
775     return WINED3D_OK;
776 }
777
778 /***************************
779  *
780  ***************************/
781 static void WINAPI IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
782     TRACE("(%p)->(%s, %s)\n", iface,
783           flag == SFLAG_INSYSMEM ? "SFLAG_INSYSMEM" : flag == SFLAG_INDRAWABLE ? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
784           persistent ? "TRUE" : "FALSE");
785     /* GDI surfaces can be in system memory only */
786     if(flag != SFLAG_INSYSMEM) {
787         ERR("GDI Surface requested in gl %s memory\n", flag == SFLAG_INDRAWABLE ? "drawable" : "texture");
788     }
789 }
790
791 static HRESULT WINAPI IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface *iface, DWORD flag, const RECT *rect) {
792     if(flag != SFLAG_INSYSMEM) {
793         ERR("GDI Surface requested to be copied to gl %s\n", flag == SFLAG_INTEXTURE ? "texture" : "drawable");
794     } else {
795         TRACE("Surface requested in surface memory\n");
796     }
797     return WINED3D_OK;
798 }
799
800 static WINED3DSURFTYPE WINAPI IWineGDISurfaceImpl_GetImplType(IWineD3DSurface *iface) {
801     return SURFACE_GDI;
802 }
803
804 /* FIXME: This vtable should not use any IWineD3DSurface* implementation functions,
805  * only IWineD3DBaseSurface and IWineGDISurface ones.
806  */
807 const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
808 {
809     /* IUnknown */
810     IWineD3DBaseSurfaceImpl_QueryInterface,
811     IWineD3DBaseSurfaceImpl_AddRef,
812     IWineGDISurfaceImpl_Release,
813     /* IWineD3DResource */
814     IWineD3DBaseSurfaceImpl_GetParent,
815     IWineD3DBaseSurfaceImpl_GetDevice,
816     IWineD3DBaseSurfaceImpl_SetPrivateData,
817     IWineD3DBaseSurfaceImpl_GetPrivateData,
818     IWineD3DBaseSurfaceImpl_FreePrivateData,
819     IWineD3DBaseSurfaceImpl_SetPriority,
820     IWineD3DBaseSurfaceImpl_GetPriority,
821     IWineGDISurfaceImpl_PreLoad,
822     IWineGDISurfaceImpl_UnLoad,
823     IWineD3DBaseSurfaceImpl_GetType,
824     /* IWineD3DSurface */
825     IWineD3DBaseSurfaceImpl_GetContainer,
826     IWineD3DBaseSurfaceImpl_GetDesc,
827     IWineGDISurfaceImpl_LockRect,
828     IWineGDISurfaceImpl_UnlockRect,
829     IWineGDISurfaceImpl_GetDC,
830     IWineGDISurfaceImpl_ReleaseDC,
831     IWineGDISurfaceImpl_Flip,
832     IWineD3DBaseSurfaceImpl_Blt,
833     IWineD3DBaseSurfaceImpl_GetBltStatus,
834     IWineD3DBaseSurfaceImpl_GetFlipStatus,
835     IWineD3DBaseSurfaceImpl_IsLost,
836     IWineD3DBaseSurfaceImpl_Restore,
837     IWineD3DBaseSurfaceImpl_BltFast,
838     IWineD3DBaseSurfaceImpl_GetPalette,
839     IWineD3DBaseSurfaceImpl_SetPalette,
840     IWineGDISurfaceImpl_RealizePalette,
841     IWineD3DBaseSurfaceImpl_SetColorKey,
842     IWineD3DBaseSurfaceImpl_GetPitch,
843     IWineGDISurfaceImpl_SetMem,
844     IWineD3DBaseSurfaceImpl_SetOverlayPosition,
845     IWineD3DBaseSurfaceImpl_GetOverlayPosition,
846     IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
847     IWineD3DBaseSurfaceImpl_UpdateOverlay,
848     IWineD3DBaseSurfaceImpl_SetClipper,
849     IWineD3DBaseSurfaceImpl_GetClipper,
850     /* Internal use: */
851     IWineGDISurfaceImpl_AddDirtyRect,
852     IWineGDISurfaceImpl_LoadTexture,
853     IWineD3DBaseSurfaceImpl_BindTexture,
854     IWineGDISurfaceImpl_SaveSnapshot,
855     IWineD3DBaseSurfaceImpl_SetContainer,
856     IWineGDISurfaceImpl_SetGlTextureDesc,
857     IWineGDISurfaceImpl_GetGlDesc,
858     IWineD3DSurfaceImpl_GetData,
859     IWineD3DBaseSurfaceImpl_SetFormat,
860     IWineGDISurfaceImpl_PrivateSetup,
861     IWineGDISurfaceImpl_ModifyLocation,
862     IWineGDISurfaceImpl_LoadLocation,
863     IWineGDISurfaceImpl_GetImplType
864 };