wined3d: Move fake context code over to WGL.
[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::PreLoad, GDI version
133  *
134  * This call is unsupported on GDI surfaces, if it's called something went
135  * wrong in the parent library. Write an informative warning
136  *
137  *****************************************************************************/
138 static void WINAPI
139 IWineGDISurfaceImpl_PreLoad(IWineD3DSurface *iface)
140 {
141     ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface);
142     ERR("(%p): Most likely the parent library did something wrong.\n", iface);
143     ERR("(%p): Please report to wine-devel\n", iface);
144 }
145
146 /*****************************************************************************
147  * IWineD3DSurface::LockRect, GDI version
148  *
149  * Locks the surface and returns a pointer to the surface memory
150  *
151  * Params:
152  *  pLockedRect: Address to return the locking info at
153  *  pRect: Rectangle to lock
154  *  Flags: Some flags
155  *
156  * Returns:
157  *  WINED3D_OK on success
158  *  WINED3DERR_INVALIDCALL on errors
159  *
160  *****************************************************************************/
161 static HRESULT WINAPI
162 IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface,
163                              WINED3DLOCKED_RECT* pLockedRect,
164                              CONST RECT* pRect,
165                              DWORD Flags)
166 {
167     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
168
169     /* Already locked? */
170     if(This->Flags & SFLAG_LOCKED)
171     {
172         ERR("(%p) Surface already locked\n", This);
173         /* What should I return here? */
174         return WINED3DERR_INVALIDCALL;
175     }
176
177     if (!(This->Flags & SFLAG_LOCKABLE))
178     {
179         /* This is some GL specific thing, see the OpenGL version of
180          * this method, but check for the flag and write a trace
181          */
182         TRACE("Warning: trying to lock unlockable surf@%p\n", This);
183     }
184
185     TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n",
186           This, pRect, Flags, pLockedRect, This->resource.allocatedMemory);
187
188     if(!This->resource.allocatedMemory) {
189         HDC hdc;
190         HRESULT hr;
191         /* This happens on gdi surfaces if the application set a user pointer and resets it.
192          * Recreate the DIB section
193          */
194         hr = IWineD3DSurface_GetDC(iface, &hdc);  /* will recursively call lockrect, do not set the LOCKED flag to this line */
195         if(hr != WINED3D_OK) return hr;
196         hr = IWineD3DSurface_ReleaseDC(iface, hdc);
197         if(hr != WINED3D_OK) return hr;
198     }
199
200     pLockedRect->Pitch = IWineD3DSurface_GetPitch(iface);
201
202     if (NULL == pRect)
203     {
204         pLockedRect->pBits = This->resource.allocatedMemory;
205         This->lockedRect.left   = 0;
206         This->lockedRect.top    = 0;
207         This->lockedRect.right  = This->currentDesc.Width;
208         This->lockedRect.bottom = This->currentDesc.Height;
209
210         TRACE("Locked Rect (%p) = l %d, t %d, r %d, b %d\n",
211         &This->lockedRect, This->lockedRect.left, This->lockedRect.top,
212         This->lockedRect.right, This->lockedRect.bottom);
213     }
214     else
215     {
216         TRACE("Lock Rect (%p) = l %d, t %d, r %d, b %d\n",
217               pRect, pRect->left, pRect->top, pRect->right, pRect->bottom);
218
219         if (This->resource.format == WINED3DFMT_DXT1)
220         {
221             /* DXT1 is half byte per pixel */
222             pLockedRect->pBits = This->resource.allocatedMemory +
223                                   (pLockedRect->Pitch * pRect->top) +
224                                   ((pRect->left * This->bytesPerPixel / 2));
225         }
226         else
227         {
228             pLockedRect->pBits = This->resource.allocatedMemory +
229                                  (pLockedRect->Pitch * pRect->top) +
230                                  (pRect->left * This->bytesPerPixel);
231         }
232         This->lockedRect.left   = pRect->left;
233         This->lockedRect.top    = pRect->top;
234         This->lockedRect.right  = pRect->right;
235         This->lockedRect.bottom = pRect->bottom;
236     }
237
238     /* No dirtifying is needed for this surface implementation */
239     TRACE("returning memory@%p, pitch(%d)\n", pLockedRect->pBits, pLockedRect->Pitch);
240
241     This->Flags |= SFLAG_LOCKED;
242     return WINED3D_OK;
243 }
244
245 /*****************************************************************************
246  * IWineD3DSurface::UnlockRect, GDI version
247  *
248  * Unlocks a surface. This implementation doesn't do much, except updating
249  * the window if the front buffer is unlocked
250  *
251  * Returns:
252  *  WINED3D_OK on success
253  *  WINED3DERR_INVALIDCALL on failure
254  *
255  *****************************************************************************/
256 static HRESULT WINAPI
257 IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface *iface)
258 {
259     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
260     IWineD3DDeviceImpl *dev = (IWineD3DDeviceImpl *) This->resource.wineD3DDevice;
261     TRACE("(%p)\n", This);
262
263     if (!(This->Flags & SFLAG_LOCKED))
264     {
265         WARN("trying to Unlock an unlocked surf@%p\n", This);
266         return WINED3DERR_INVALIDCALL;
267     }
268
269     /* Can be useful for debugging */
270 #if 0
271         {
272             static unsigned int gen = 0;
273             char buffer[4096];
274             ++gen;
275             if ((gen % 10) == 0) {
276                 snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
277                 IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
278             }
279             /*
280              * debugging crash code
281             if (gen == 250) {
282               void** test = NULL;
283               *test = 0;
284             }
285             */
286         }
287 #endif
288
289     /* Update the screen */
290     if(This == (IWineD3DSurfaceImpl *) dev->ddraw_primary)
291     {
292         x11_copy_to_screen(This, &This->lockedRect);
293     }
294
295     This->Flags &= ~SFLAG_LOCKED;
296     memset(&This->lockedRect, 0, sizeof(RECT));
297     return WINED3D_OK;
298 }
299
300 /*****************************************************************************
301  * IWineD3DSurface::Flip, GDI version
302  *
303  * Flips 2 flipping enabled surfaces. Determining the 2 targets is done by
304  * the parent library. This implementation changes the data pointers of the
305  * surfaces and copies the new front buffer content to the screen
306  *
307  * Params:
308  *  override: Flipping target(e.g. back buffer)
309  *
310  * Returns:
311  *  WINED3D_OK on success
312  *
313  *****************************************************************************/
314 static HRESULT WINAPI
315 IWineGDISurfaceImpl_Flip(IWineD3DSurface *iface,
316                          IWineD3DSurface *override,
317                          DWORD Flags)
318 {
319     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
320     IWineD3DSurfaceImpl *Target = (IWineD3DSurfaceImpl *) override;
321     TRACE("(%p)->(%p,%x)\n", This, override, Flags);
322
323     TRACE("(%p) Flipping to surface %p\n", This, Target);
324
325     if(Target == NULL)
326     {
327         ERR("(%p): Can't flip without a target\n", This);
328         return WINED3DERR_INVALIDCALL;
329     }
330
331     /* Flip the DC */
332     {
333         HDC tmp;
334         tmp = This->hDC;
335         This->hDC = Target->hDC;
336         Target->hDC = tmp;
337     }
338
339     /* Flip the DIBsection */
340     {
341         HBITMAP tmp;
342         tmp = This->dib.DIBsection;
343         This->dib.DIBsection = Target->dib.DIBsection;
344         Target->dib.DIBsection = tmp;
345     }
346
347     /* Flip the surface data */
348     {
349         void* tmp;
350
351         tmp = This->dib.bitmap_data;
352         This->dib.bitmap_data = Target->dib.bitmap_data;
353         Target->dib.bitmap_data = tmp;
354
355         tmp = This->resource.allocatedMemory;
356         This->resource.allocatedMemory = Target->resource.allocatedMemory;
357         Target->resource.allocatedMemory = tmp;
358     }
359
360     /* client_memory should not be different, but just in case */
361     {
362         BOOL tmp;
363         tmp = This->dib.client_memory;
364         This->dib.client_memory = Target->dib.client_memory;
365         Target->dib.client_memory = tmp;
366     }
367
368     /* Useful for debugging */
369 #if 0
370         {
371             static unsigned int gen = 0;
372             char buffer[4096];
373             ++gen;
374             if ((gen % 10) == 0) {
375                 snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
376                 IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
377             }
378             /*
379              * debugging crash code
380             if (gen == 250) {
381               void** test = NULL;
382               *test = 0;
383             }
384             */
385         }
386 #endif
387
388     /* Update the screen */
389     x11_copy_to_screen(This, NULL);
390
391     /* FPS support */
392     if (TRACE_ON(fps))
393     {
394         static long prev_time, frames;
395
396         DWORD time = GetTickCount();
397         frames++;
398         /* every 1.5 seconds */
399         if (time - prev_time > 1500) {
400             TRACE_(fps)("@ approx %.2ffps\n", 1000.0*frames/(time - prev_time));
401             prev_time = time;
402             frames = 0;
403         }
404     }
405
406     return WINED3D_OK;
407 }
408
409 /*****************************************************************************
410  * _Blt_ColorFill
411  *
412  * Helper function that fills a memory area with a specific color
413  *
414  * Params:
415  *  buf: memory address to start filling at
416  *  width, height: Dimensions of the area to fill
417  *  bpp: Bit depth of the surface
418  *  lPitch: pitch of the surface
419  *  color: Color to fill with
420  *
421  *****************************************************************************/
422 static HRESULT
423 _Blt_ColorFill(BYTE *buf,
424                int width, int height,
425                int bpp, LONG lPitch,
426                DWORD color)
427 {
428     int x, y;
429     LPBYTE first;
430
431     /* Do first row */
432
433 #define COLORFILL_ROW(type) \
434 { \
435     type *d = (type *) buf; \
436     for (x = 0; x < width; x++) \
437         d[x] = (type) color; \
438     break; \
439 }
440     switch(bpp)
441     {
442         case 1: COLORFILL_ROW(BYTE)
443         case 2: COLORFILL_ROW(WORD)
444         case 3:
445         {
446             BYTE *d = (BYTE *) buf;
447             for (x = 0; x < width; x++,d+=3)
448             {
449                 d[0] = (color    ) & 0xFF;
450                 d[1] = (color>> 8) & 0xFF;
451                 d[2] = (color>>16) & 0xFF;
452             }
453             break;
454         }
455         case 4: COLORFILL_ROW(DWORD)
456         default:
457             FIXME("Color fill not implemented for bpp %d!\n", bpp*8);
458             return WINED3DERR_NOTAVAILABLE;
459     }
460
461 #undef COLORFILL_ROW
462
463     /* Now copy first row */
464     first = buf;
465     for (y = 1; y < height; y++)
466     {
467         buf += lPitch;
468         memcpy(buf, first, width * bpp);
469     }
470     return WINED3D_OK;
471 }
472
473 /*****************************************************************************
474  * IWineD3DSurface::Blt, GDI version
475  *
476  * Performs blits to a surface, eigher from a source of source-less blts
477  * This is the main functionality of DirectDraw
478  *
479  * Params:
480  *  DestRect: Destination rectangle to write to
481  *  SrcSurface: Source surface, can be NULL
482  *  SrcRect: Source rectangle
483  *****************************************************************************/
484 HRESULT WINAPI
485 IWineGDISurfaceImpl_Blt(IWineD3DSurface *iface,
486                         RECT *DestRect,
487                         IWineD3DSurface *SrcSurface,
488                         RECT *SrcRect,
489                         DWORD Flags,
490                         WINEDDBLTFX *DDBltFx,
491                         WINED3DTEXTUREFILTERTYPE Filter)
492 {
493     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
494     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
495     RECT                xdst,xsrc;
496     HRESULT             ret = WINED3D_OK;
497     WINED3DLOCKED_RECT  dlock, slock;
498     WINED3DFORMAT       dfmt = WINED3DFMT_UNKNOWN, sfmt = WINED3DFMT_UNKNOWN;
499     int bpp, srcheight, srcwidth, dstheight, dstwidth, width;
500     int x, y;
501     const StaticPixelFormatDesc *sEntry, *dEntry;
502     LPBYTE dbuf, sbuf;
503     TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This, DestRect, Src, SrcRect, Flags, DDBltFx);
504
505     if (TRACE_ON(d3d_surface))
506     {
507         if (DestRect) TRACE("\tdestrect :%dx%d-%dx%d\n",
508         DestRect->left, DestRect->top, DestRect->right, DestRect->bottom);
509         if (SrcRect) TRACE("\tsrcrect  :%dx%d-%dx%d\n",
510         SrcRect->left, SrcRect->top, SrcRect->right, SrcRect->bottom);
511 #if 0
512         TRACE("\tflags: ");
513         DDRAW_dump_DDBLT(Flags);
514         if (Flags & WINEDDBLT_DDFX)
515         {
516             TRACE("\tblitfx: ");
517             DDRAW_dump_DDBLTFX(DDBltFx->dwDDFX);
518         }
519 #endif
520     }
521
522     if ( (This->Flags & SFLAG_LOCKED) || ((Src != NULL) && (Src->Flags & SFLAG_LOCKED)))
523     {
524         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
525         return WINEDDERR_SURFACEBUSY;
526     }
527
528     if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) {
529         /* Can happen when d3d9 apps do a StretchRect call which isn't handled in gl */
530         FIXME("Filters not supported in software blit\n");
531     }
532
533     if (Src == This)
534     {
535         IWineD3DSurface_LockRect(iface, &dlock, NULL, 0);
536         dfmt = This->resource.format;
537         slock = dlock;
538         sfmt = dfmt;
539         sEntry = getFormatDescEntry(sfmt, NULL, NULL);
540         dEntry = sEntry;
541     }
542     else
543     {
544         if (Src)
545         {
546             IWineD3DSurface_LockRect(SrcSurface, &slock, NULL, WINED3DLOCK_READONLY);
547             sfmt = Src->resource.format;
548         }
549         sEntry = getFormatDescEntry(sfmt, NULL, NULL);
550         dfmt = This->resource.format;
551         dEntry = getFormatDescEntry(dfmt, NULL, NULL);
552         IWineD3DSurface_LockRect(iface, &dlock,NULL,0);
553     }
554
555     if (!DDBltFx || !(DDBltFx->dwDDFX)) Flags &= ~WINEDDBLT_DDFX;
556
557     if (sEntry->isFourcc && dEntry->isFourcc)
558     {
559         if (sfmt != dfmt)
560         {
561             FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
562             ret = WINED3DERR_WRONGTEXTUREFORMAT;
563             goto release;
564         }
565         memcpy(dlock.pBits, slock.pBits, This->resource.size);
566         goto release;
567     }
568
569     if (sEntry->isFourcc && !dEntry->isFourcc)
570     {
571         FIXME("DXTC decompression not supported right now\n");
572         goto release;
573     }
574
575     if (DestRect)
576     {
577         memcpy(&xdst,DestRect,sizeof(xdst));
578     }
579     else
580     {
581         xdst.top        = 0;
582         xdst.bottom     = This->currentDesc.Height;
583         xdst.left       = 0;
584         xdst.right      = This->currentDesc.Width;
585     }
586
587     if (SrcRect)
588     {
589         memcpy(&xsrc,SrcRect,sizeof(xsrc));
590     }
591     else
592     {
593         if (Src)
594         {
595             xsrc.top    = 0;
596             xsrc.bottom = Src->currentDesc.Height;
597             xsrc.left   = 0;
598             xsrc.right  = Src->currentDesc.Width;
599         }
600         else
601         {
602             memset(&xsrc,0,sizeof(xsrc));
603         }
604     }
605
606     /* First check for the validity of source / destination rectangles. This was
607       verified using a test application + by MSDN.
608     */
609     if ((Src != NULL) &&
610         ((xsrc.bottom > Src->currentDesc.Height) || (xsrc.bottom < 0) ||
611         (xsrc.top     > Src->currentDesc.Height) || (xsrc.top    < 0) ||
612         (xsrc.left    > Src->currentDesc.Width)  || (xsrc.left   < 0) ||
613         (xsrc.right   > Src->currentDesc.Width)  || (xsrc.right  < 0) ||
614         (xsrc.right   < xsrc.left)               || (xsrc.bottom < xsrc.top)))
615     {
616         WARN("Application gave us bad source rectangle for Blt.\n");
617         ret = WINEDDERR_INVALIDRECT;
618         goto release;
619     }
620     /* For the Destination rect, it can be out of bounds on the condition that a clipper
621       is set for the given surface.
622     */
623     if ((/*This->clipper == NULL*/ TRUE) &&
624         ((xdst.bottom  > This->currentDesc.Height) || (xdst.bottom < 0) ||
625         (xdst.top      > This->currentDesc.Height) || (xdst.top    < 0) ||
626         (xdst.left     > This->currentDesc.Width)  || (xdst.left   < 0) ||
627         (xdst.right    > This->currentDesc.Width)  || (xdst.right  < 0) ||
628         (xdst.right    < xdst.left)                || (xdst.bottom < xdst.top)))
629     {
630         WARN("Application gave us bad destination rectangle for Blt without a clipper set.\n");
631         ret = WINEDDERR_INVALIDRECT;
632         goto release;
633     }
634
635     /* Now handle negative values in the rectangles. Warning: only supported for now
636       in the 'simple' cases (ie not in any stretching / rotation cases).
637
638       First, the case where nothing is to be done.
639     */
640     if (((xdst.bottom <= 0) || (xdst.right <= 0)         ||
641          (xdst.top    >= (int) This->currentDesc.Height) ||
642          (xdst.left   >= (int) This->currentDesc.Width)) ||
643         ((Src != NULL) &&
644         ((xsrc.bottom <= 0) || (xsrc.right <= 0)     ||
645          (xsrc.top >= (int) Src->currentDesc.Height) ||
646          (xsrc.left >= (int) Src->currentDesc.Width))  ))
647     {
648         TRACE("Nothing to be done !\n");
649         goto release;
650     }
651
652     /* The easy case : the source-less blits.... */
653     if (Src == NULL)
654     {
655         RECT full_rect;
656         RECT temp_rect; /* No idea if intersect rect can be the same as one of the source rect */
657
658         full_rect.left   = 0;
659         full_rect.top    = 0;
660         full_rect.right  = This->currentDesc.Width;
661         full_rect.bottom = This->currentDesc.Height;
662         IntersectRect(&temp_rect, &full_rect, &xdst);
663         xdst = temp_rect;
664     }
665     else
666     {
667         /* Only handle clipping on the destination rectangle */
668         int clip_horiz = (xdst.left < 0) || (xdst.right  > (int) This->currentDesc.Width );
669         int clip_vert  = (xdst.top  < 0) || (xdst.bottom > (int) This->currentDesc.Height);
670         if (clip_vert || clip_horiz)
671         {
672             /* Now check if this is a special case or not... */
673             if ((((xdst.bottom - xdst.top ) != (xsrc.bottom - xsrc.top )) && clip_vert ) ||
674                 (((xdst.right  - xdst.left) != (xsrc.right  - xsrc.left)) && clip_horiz) ||
675                 (Flags & WINEDDBLT_DDFX))
676             {
677                 WARN("Out of screen rectangle in special case. Not handled right now.\n");
678                 goto release;
679             }
680
681             if (clip_horiz)
682             {
683                 if (xdst.left < 0) { xsrc.left -= xdst.left; xdst.left = 0; }
684                 if (xdst.right > This->currentDesc.Width)
685                 {
686                     xsrc.right -= (xdst.right - (int) This->currentDesc.Width);
687                     xdst.right = (int) This->currentDesc.Width;
688                 }
689             }
690             if (clip_vert)
691             {
692                 if (xdst.top < 0)
693                 {
694                     xsrc.top -= xdst.top;
695                     xdst.top = 0;
696                 }
697                 if (xdst.bottom > This->currentDesc.Height)
698                 {
699                     xsrc.bottom -= (xdst.bottom - (int) This->currentDesc.Height);
700                     xdst.bottom = (int) This->currentDesc.Height;
701                 }
702             }
703             /* And check if after clipping something is still to be done... */
704             if ((xdst.bottom <= 0)   || (xdst.right <= 0)       ||
705                 (xdst.top   >= (int) This->currentDesc.Height)  ||
706                 (xdst.left  >= (int) This->currentDesc.Width)   ||
707                 (xsrc.bottom <= 0)   || (xsrc.right <= 0)       ||
708                 (xsrc.top >= (int) Src->currentDesc.Height)     ||
709                 (xsrc.left >= (int) Src->currentDesc.Width))
710             {
711                 TRACE("Nothing to be done after clipping !\n");
712                 goto release;
713             }
714         }
715     }
716
717     bpp = This->bytesPerPixel;
718     srcheight = xsrc.bottom - xsrc.top;
719     srcwidth = xsrc.right - xsrc.left;
720     dstheight = xdst.bottom - xdst.top;
721     dstwidth = xdst.right - xdst.left;
722     width = (xdst.right - xdst.left) * bpp;
723
724     assert(width <= dlock.Pitch);
725
726     dbuf = (BYTE*)dlock.pBits+(xdst.top*dlock.Pitch)+(xdst.left*bpp);
727
728     if (Flags & WINEDDBLT_WAIT)
729     {
730         Flags &= ~WINEDDBLT_WAIT;
731     }
732     if (Flags & WINEDDBLT_ASYNC)
733     {
734         static BOOL displayed = FALSE;
735         if (!displayed)
736             FIXME("Can't handle WINEDDBLT_ASYNC flag right now.\n");
737         displayed = TRUE;
738         Flags &= ~WINEDDBLT_ASYNC;
739     }
740     if (Flags & WINEDDBLT_DONOTWAIT)
741     {
742         /* WINEDDBLT_DONOTWAIT appeared in DX7 */
743         static BOOL displayed = FALSE;
744         if (!displayed)
745             FIXME("Can't handle WINEDDBLT_DONOTWAIT flag right now.\n");
746         displayed = TRUE;
747         Flags &= ~WINEDDBLT_DONOTWAIT;
748     }
749
750     /* First, all the 'source-less' blits */
751     if (Flags & WINEDDBLT_COLORFILL)
752     {
753         ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp,
754                             dlock.Pitch, DDBltFx->u5.dwFillColor);
755         Flags &= ~WINEDDBLT_COLORFILL;
756     }
757
758     if (Flags & WINEDDBLT_DEPTHFILL)
759     {
760         FIXME("DDBLT_DEPTHFILL needs to be implemented!\n");
761     }
762     if (Flags & WINEDDBLT_ROP)
763     {
764         /* Catch some degenerate cases here */
765         switch(DDBltFx->dwROP)
766         {
767             case BLACKNESS:
768                 ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,dlock.Pitch,0);
769                 break;
770             case 0xAA0029: /* No-op */
771                 break;
772             case WHITENESS:
773                 ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,dlock.Pitch,~0);
774                 break;
775             case SRCCOPY: /* well, we do that below ? */
776                 break;
777             default:
778                 FIXME("Unsupported raster op: %08x  Pattern: %p\n", DDBltFx->dwROP, DDBltFx->u5.lpDDSPattern);
779                 goto error;
780         }
781         Flags &= ~WINEDDBLT_ROP;
782     }
783     if (Flags & WINEDDBLT_DDROPS)
784     {
785         FIXME("\tDdraw Raster Ops: %08x  Pattern: %p\n", DDBltFx->dwDDROP, DDBltFx->u5.lpDDSPattern);
786     }
787     /* Now the 'with source' blits */
788     if (Src)
789     {
790         LPBYTE sbase;
791         int sx, xinc, sy, yinc;
792
793         if (!dstwidth || !dstheight) /* hmm... stupid program ? */
794             goto release;
795         sbase = (BYTE*)slock.pBits+(xsrc.top*slock.Pitch)+xsrc.left*bpp;
796         xinc = (srcwidth << 16) / dstwidth;
797         yinc = (srcheight << 16) / dstheight;
798
799         if (!Flags)
800         {
801             /* No effects, we can cheat here */
802             if (dstwidth == srcwidth)
803             {
804                 if (dstheight == srcheight)
805                 {
806                     /* No stretching in either direction. This needs to be as
807                     * fast as possible */
808                     sbuf = sbase;
809
810                     /* check for overlapping surfaces */
811                     if (SrcSurface != iface || xdst.top < xsrc.top ||
812                         xdst.right <= xsrc.left || xsrc.right <= xdst.left)
813                     {
814                         /* no overlap, or dst above src, so copy from top downwards */
815                         for (y = 0; y < dstheight; y++)
816                         {
817                             memcpy(dbuf, sbuf, width);
818                             sbuf += slock.Pitch;
819                             dbuf += dlock.Pitch;
820                         }
821                     }
822                     else if (xdst.top > xsrc.top)  /* copy from bottom upwards */
823                     {
824                         sbuf += (slock.Pitch*dstheight);
825                         dbuf += (dlock.Pitch*dstheight);
826                         for (y = 0; y < dstheight; y++)
827                         {
828                             sbuf -= slock.Pitch;
829                             dbuf -= dlock.Pitch;
830                             memcpy(dbuf, sbuf, width);
831                         }
832                     }
833                     else /* src and dst overlapping on the same line, use memmove */
834                     {
835                         for (y = 0; y < dstheight; y++)
836                         {
837                             memmove(dbuf, sbuf, width);
838                             sbuf += slock.Pitch;
839                             dbuf += dlock.Pitch;
840                         }
841                     }
842                 } else {
843                     /* Stretching in Y direction only */
844                     for (y = sy = 0; y < dstheight; y++, sy += yinc) {
845                         sbuf = sbase + (sy >> 16) * slock.Pitch;
846                         memcpy(dbuf, sbuf, width);
847                         dbuf += dlock.Pitch;
848                     }
849                 }
850             }
851             else
852             {
853                 /* Stretching in X direction */
854                 int last_sy = -1;
855                 for (y = sy = 0; y < dstheight; y++, sy += yinc)
856                 {
857                     sbuf = sbase + (sy >> 16) * slock.Pitch;
858
859                     if ((sy >> 16) == (last_sy >> 16))
860                     {
861                         /* this sourcerow is the same as last sourcerow -
862                          * copy already stretched row
863                          */
864                         memcpy(dbuf, dbuf - dlock.Pitch, width);
865                     }
866                     else
867                     {
868 #define STRETCH_ROW(type) { \
869                     type *s = (type *) sbuf, *d = (type *) dbuf; \
870                     for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
871                     d[x] = s[sx >> 16]; \
872                     break; }
873
874                     switch(bpp)
875                     {
876                         case 1: STRETCH_ROW(BYTE)
877                         case 2: STRETCH_ROW(WORD)
878                         case 4: STRETCH_ROW(DWORD)
879                         case 3:
880                         {
881                             LPBYTE s,d = dbuf;
882                             for (x = sx = 0; x < dstwidth; x++, sx+= xinc)
883                             {
884                                 DWORD pixel;
885
886                                 s = sbuf+3*(sx>>16);
887                                 pixel = s[0]|(s[1]<<8)|(s[2]<<16);
888                                 d[0] = (pixel    )&0xff;
889                                 d[1] = (pixel>> 8)&0xff;
890                                 d[2] = (pixel>>16)&0xff;
891                                 d+=3;
892                             }
893                             break;
894                     }
895                     default:
896                         FIXME("Stretched blit not implemented for bpp %d!\n", bpp*8);
897                         ret = WINED3DERR_NOTAVAILABLE;
898                         goto error;
899                     }
900 #undef STRETCH_ROW
901                     }
902                     dbuf += dlock.Pitch;
903                     last_sy = sy;
904                 }
905             }
906         }
907         else
908         {
909           LONG dstyinc = dlock.Pitch, dstxinc = bpp;
910           DWORD keylow = 0xFFFFFFFF, keyhigh = 0, keymask = 0xFFFFFFFF;
911           DWORD destkeylow = 0x0, destkeyhigh = 0xFFFFFFFF, destkeymask = 0xFFFFFFFF;
912           if (Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYDEST | WINEDDBLT_KEYSRCOVERRIDE | WINEDDBLT_KEYDESTOVERRIDE))
913           {
914               /* The color keying flags are checked for correctness in ddraw */
915               if (Flags & WINEDDBLT_KEYSRC)
916               {
917                 keylow  = Src->SrcBltCKey.dwColorSpaceLowValue;
918                 keyhigh = Src->SrcBltCKey.dwColorSpaceHighValue;
919               }
920               else  if (Flags & WINEDDBLT_KEYSRCOVERRIDE)
921               {
922                 keylow  = DDBltFx->ddckSrcColorkey.dwColorSpaceLowValue;
923                 keyhigh = DDBltFx->ddckSrcColorkey.dwColorSpaceHighValue;
924               }
925
926               if (Flags & WINEDDBLT_KEYDEST)
927               {
928                 /* Destination color keys are taken from the source surface ! */
929                 destkeylow  = Src->DestBltCKey.dwColorSpaceLowValue;
930                 destkeyhigh = Src->DestBltCKey.dwColorSpaceHighValue;
931               }
932               else if (Flags & WINEDDBLT_KEYDESTOVERRIDE)
933               {
934                 destkeylow  = DDBltFx->ddckDestColorkey.dwColorSpaceLowValue;
935                 destkeyhigh = DDBltFx->ddckDestColorkey.dwColorSpaceHighValue;
936               }
937
938               if(bpp == 1)
939               {
940                   keymask = 0xff;
941               }
942               else
943               {
944                   keymask = sEntry->redMask   |
945                             sEntry->greenMask |
946                             sEntry->blueMask;
947               }
948               Flags &= ~(WINEDDBLT_KEYSRC | WINEDDBLT_KEYDEST | WINEDDBLT_KEYSRCOVERRIDE | WINEDDBLT_KEYDESTOVERRIDE);
949           }
950
951           if (Flags & WINEDDBLT_DDFX)
952           {
953               LPBYTE dTopLeft, dTopRight, dBottomLeft, dBottomRight, tmp;
954               LONG tmpxy;
955               dTopLeft     = dbuf;
956               dTopRight    = dbuf+((dstwidth-1)*bpp);
957               dBottomLeft  = dTopLeft+((dstheight-1)*dlock.Pitch);
958               dBottomRight = dBottomLeft+((dstwidth-1)*bpp);
959
960               if (DDBltFx->dwDDFX & WINEDDBLTFX_ARITHSTRETCHY)
961               {
962                 /* I don't think we need to do anything about this flag */
963                 WARN("Flags=DDBLT_DDFX nothing done for WINEDDBLTFX_ARITHSTRETCHY\n");
964               }
965               if (DDBltFx->dwDDFX & WINEDDBLTFX_MIRRORLEFTRIGHT)
966               {
967                 tmp          = dTopRight;
968                 dTopRight    = dTopLeft;
969                 dTopLeft     = tmp;
970                 tmp          = dBottomRight;
971                 dBottomRight = dBottomLeft;
972                 dBottomLeft  = tmp;
973                 dstxinc = dstxinc *-1;
974               }
975               if (DDBltFx->dwDDFX & WINEDDBLTFX_MIRRORUPDOWN)
976               {
977                 tmp          = dTopLeft;
978                 dTopLeft     = dBottomLeft;
979                 dBottomLeft  = tmp;
980                 tmp          = dTopRight;
981                 dTopRight    = dBottomRight;
982                 dBottomRight = tmp;
983                 dstyinc = dstyinc *-1;
984               }
985               if (DDBltFx->dwDDFX & WINEDDBLTFX_NOTEARING)
986               {
987                 /* I don't think we need to do anything about this flag */
988                 WARN("Flags=DDBLT_DDFX nothing done for WINEDDBLTFX_NOTEARING\n");
989               }
990               if (DDBltFx->dwDDFX & WINEDDBLTFX_ROTATE180)
991               {
992                 tmp          = dBottomRight;
993                 dBottomRight = dTopLeft;
994                 dTopLeft     = tmp;
995                 tmp          = dBottomLeft;
996                 dBottomLeft  = dTopRight;
997                 dTopRight    = tmp;
998                 dstxinc = dstxinc * -1;
999                 dstyinc = dstyinc * -1;
1000               }
1001               if (DDBltFx->dwDDFX & WINEDDBLTFX_ROTATE270)
1002               {
1003                 tmp          = dTopLeft;
1004                 dTopLeft     = dBottomLeft;
1005                 dBottomLeft  = dBottomRight;
1006                 dBottomRight = dTopRight;
1007                 dTopRight    = tmp;
1008                 tmpxy   = dstxinc;
1009                 dstxinc = dstyinc;
1010                 dstyinc = tmpxy;
1011                 dstxinc = dstxinc * -1;
1012               }
1013               if (DDBltFx->dwDDFX & WINEDDBLTFX_ROTATE90)
1014               {
1015                 tmp          = dTopLeft;
1016                 dTopLeft     = dTopRight;
1017                 dTopRight    = dBottomRight;
1018                 dBottomRight = dBottomLeft;
1019                 dBottomLeft  = tmp;
1020                 tmpxy   = dstxinc;
1021                 dstxinc = dstyinc;
1022                 dstyinc = tmpxy;
1023                 dstyinc = dstyinc * -1;
1024               }
1025               if (DDBltFx->dwDDFX & WINEDDBLTFX_ZBUFFERBASEDEST)
1026               {
1027                 /* I don't think we need to do anything about this flag */
1028                 WARN("Flags=WINEDDBLT_DDFX nothing done for WINEDDBLTFX_ZBUFFERBASEDEST\n");
1029               }
1030               dbuf = dTopLeft;
1031               Flags &= ~(WINEDDBLT_DDFX);
1032           }
1033
1034 #define COPY_COLORKEY_FX(type) { \
1035             type *s, *d = (type *) dbuf, *dx, tmp; \
1036             for (y = sy = 0; y < dstheight; y++, sy += yinc) { \
1037               s = (type*)(sbase + (sy >> 16) * slock.Pitch); \
1038               dx = d; \
1039               for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
1040                   tmp = s[sx >> 16]; \
1041                   if (((tmp & keymask) < keylow || (tmp & keymask) > keyhigh) && \
1042                       ((dx[0] & destkeymask) >= destkeylow && (dx[0] & destkeymask) <= destkeyhigh)) { \
1043                        dx[0] = tmp; \
1044                      } \
1045                   dx = (type*)(((LPBYTE)dx)+dstxinc); \
1046               } \
1047               d = (type*)(((LPBYTE)d)+dstyinc); \
1048             } \
1049             break; }
1050
1051             switch (bpp) {
1052             case 1: COPY_COLORKEY_FX(BYTE)
1053             case 2: COPY_COLORKEY_FX(WORD)
1054             case 4: COPY_COLORKEY_FX(DWORD)
1055             case 3:
1056             {
1057                 LPBYTE s,d = dbuf, dx;
1058                 for (y = sy = 0; y < dstheight; y++, sy += yinc)
1059                 {
1060                     sbuf = sbase + (sy >> 16) * slock.Pitch;
1061                     dx = d;
1062                     for (x = sx = 0; x < dstwidth; x++, sx+= xinc)
1063                     {
1064                         DWORD pixel, dpixel = 0;
1065                         s = sbuf+3*(sx>>16);
1066                         pixel = s[0]|(s[1]<<8)|(s[2]<<16);
1067                         dpixel = dx[0]|(dx[1]<<8)|(dx[2]<<16);
1068                         if (((pixel & keymask) < keylow || (pixel & keymask) > keyhigh) &&
1069                             ((dpixel & keymask) >= destkeylow || (dpixel & keymask) <= keyhigh))
1070                         {
1071                             dx[0] = (pixel    )&0xff;
1072                             dx[1] = (pixel>> 8)&0xff;
1073                             dx[2] = (pixel>>16)&0xff;
1074                         }
1075                         dx+= dstxinc;
1076                     }
1077                     d += dstyinc;
1078                 }
1079                 break;
1080             }
1081             default:
1082               FIXME("%s color-keyed blit not implemented for bpp %d!\n",
1083                   (Flags & WINEDDBLT_KEYSRC) ? "Source" : "Destination", bpp*8);
1084                   ret = WINED3DERR_NOTAVAILABLE;
1085                   goto error;
1086 #undef COPY_COLORKEY_FX
1087             }
1088         }
1089     }
1090
1091 error:
1092     if (Flags && FIXME_ON(d3d_surface))
1093     {
1094         FIXME("\tUnsupported flags: %08x\n", Flags);
1095     }
1096
1097 release:
1098     IWineD3DSurface_UnlockRect(iface);
1099     if (SrcSurface && SrcSurface != iface) IWineD3DSurface_UnlockRect(SrcSurface);
1100     return ret;
1101 }
1102
1103 /*****************************************************************************
1104  * IWineD3DSurface::BltFast, GDI version
1105  *
1106  * This is the software implementation of BltFast, as used by GDI surfaces
1107  * and as a fallback for OpenGL surfaces. This code is taken from the old
1108  * DirectDraw code, and was originally written by TransGaming.
1109  *
1110  * Params:
1111  *  dstx:
1112  *  dsty:
1113  *  Source: Source surface to copy from
1114  *  rsrc: Source rectangle
1115  *  trans: Some Flags
1116  *
1117  * Returns:
1118  *  WINED3D_OK on success
1119  *
1120  *****************************************************************************/
1121 HRESULT WINAPI
1122 IWineGDISurfaceImpl_BltFast(IWineD3DSurface *iface,
1123                             DWORD dstx,
1124                             DWORD dsty,
1125                             IWineD3DSurface *Source,
1126                             RECT *rsrc,
1127                             DWORD trans)
1128 {
1129     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
1130     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) Source;
1131
1132     int                 bpp, w, h, x, y;
1133     WINED3DLOCKED_RECT  dlock,slock;
1134     HRESULT             ret = WINED3D_OK;
1135     RECT                rsrc2;
1136     RECT                lock_src, lock_dst, lock_union;
1137     BYTE                *sbuf, *dbuf;
1138     const StaticPixelFormatDesc *sEntry, *dEntry;
1139
1140     if (TRACE_ON(d3d_surface))
1141     {
1142         TRACE("(%p)->(%d,%d,%p,%p,%08x)\n", This,dstx,dsty,Src,rsrc,trans);
1143
1144         if (rsrc)
1145         {
1146             TRACE("\tsrcrect: %dx%d-%dx%d\n",rsrc->left,rsrc->top,
1147                   rsrc->right,rsrc->bottom);
1148         }
1149         else
1150         {
1151             TRACE(" srcrect: NULL\n");
1152         }
1153     }
1154
1155     if ((This->Flags & SFLAG_LOCKED) ||
1156         ((Src != NULL) && (Src->Flags & SFLAG_LOCKED)))
1157     {
1158         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
1159         return WINEDDERR_SURFACEBUSY;
1160     }
1161
1162     if (!rsrc)
1163     {
1164         WARN("rsrc is NULL!\n");
1165         rsrc = &rsrc2;
1166         rsrc->left = 0;
1167         rsrc->top = 0;
1168         rsrc->right = Src->currentDesc.Width;
1169         rsrc->bottom = Src->currentDesc.Height;
1170     }
1171
1172     /* Check source rect for validity. Copied from normal Blt. Fixes Baldur's Gate.*/
1173     if ((rsrc->bottom > Src->currentDesc.Height) || (rsrc->bottom < 0) ||
1174         (rsrc->top    > Src->currentDesc.Height) || (rsrc->top    < 0) ||
1175         (rsrc->left   > Src->currentDesc.Width)  || (rsrc->left   < 0) ||
1176         (rsrc->right  > Src->currentDesc.Width)  || (rsrc->right  < 0) ||
1177         (rsrc->right  < rsrc->left)              || (rsrc->bottom < rsrc->top))
1178     {
1179         WARN("Application gave us bad source rectangle for BltFast.\n");
1180         return WINEDDERR_INVALIDRECT;
1181     }
1182
1183     h = rsrc->bottom - rsrc->top;
1184     if (h > This->currentDesc.Height-dsty) h = This->currentDesc.Height-dsty;
1185     if (h > Src->currentDesc.Height-rsrc->top) h=Src->currentDesc.Height-rsrc->top;
1186     if (h <= 0) return WINEDDERR_INVALIDRECT;
1187
1188     w = rsrc->right - rsrc->left;
1189     if (w > This->currentDesc.Width-dstx) w = This->currentDesc.Width-dstx;
1190     if (w > Src->currentDesc.Width-rsrc->left) w = Src->currentDesc.Width-rsrc->left;
1191     if (w <= 0) return WINEDDERR_INVALIDRECT;
1192
1193     /* Now compute the locking rectangle... */
1194     lock_src.left = rsrc->left;
1195     lock_src.top = rsrc->top;
1196     lock_src.right = lock_src.left + w;
1197     lock_src.bottom = lock_src.top + h;
1198
1199     lock_dst.left = dstx;
1200     lock_dst.top = dsty;
1201     lock_dst.right = dstx + w;
1202     lock_dst.bottom = dsty + h;
1203
1204     bpp = This->bytesPerPixel;
1205
1206     /* We need to lock the surfaces, or we won't get refreshes when done. */
1207     if (Src == This)
1208     {
1209         int pitch;
1210
1211         UnionRect(&lock_union, &lock_src, &lock_dst);
1212
1213         /* Lock the union of the two rectangles */
1214         ret = IWineD3DSurface_LockRect(iface, &dlock, &lock_union, 0);
1215         if(ret != WINED3D_OK) goto error;
1216
1217         pitch = dlock.Pitch;
1218         slock.Pitch = dlock.Pitch;
1219
1220         /* Since slock was originally copied from this surface's description, we can just reuse it */
1221         assert(This->resource.allocatedMemory != NULL);
1222         sbuf = (BYTE *)This->resource.allocatedMemory + lock_src.top * pitch + lock_src.left * bpp;
1223         dbuf = (BYTE *)This->resource.allocatedMemory + lock_dst.top * pitch + lock_dst.left * bpp;
1224         sEntry = getFormatDescEntry(Src->resource.format, NULL, NULL);
1225         dEntry = sEntry;
1226     }
1227     else
1228     {
1229         ret = IWineD3DSurface_LockRect(Source, &slock, &lock_src, WINED3DLOCK_READONLY);
1230         if(ret != WINED3D_OK) goto error;
1231         ret = IWineD3DSurface_LockRect(iface, &dlock, &lock_dst, 0);
1232         if(ret != WINED3D_OK) goto error;
1233
1234         sbuf = slock.pBits;
1235         dbuf = dlock.pBits;
1236         TRACE("Dst is at %p, Src is at %p\n", dbuf, sbuf);
1237
1238         sEntry = getFormatDescEntry(Src->resource.format, NULL, NULL);
1239         dEntry = getFormatDescEntry(This->resource.format, NULL, NULL);
1240     }
1241
1242     /* Handle first the FOURCC surfaces... */
1243     if (sEntry->isFourcc && dEntry->isFourcc)
1244     {
1245         TRACE("Fourcc -> Fourcc copy\n");
1246         if (trans)
1247             FIXME("trans arg not supported when a FOURCC surface is involved\n");
1248         if (dstx || dsty)
1249             FIXME("offset for destination surface is not supported\n");
1250         if (Src->resource.format != This->resource.format)
1251         {
1252             FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
1253             ret = WINED3DERR_WRONGTEXTUREFORMAT;
1254             goto error;
1255         }
1256         /* FIXME: Watch out that the size is correct for FOURCC surfaces */
1257         memcpy(dbuf, sbuf, This->resource.size);
1258         goto error;
1259     }
1260     if (sEntry->isFourcc && !dEntry->isFourcc)
1261     {
1262         /* TODO: Use the libtxc_dxtn.so shared library to do
1263          * software decompression
1264          */
1265         ERR("DXTC decompression not supported by now\n");
1266         goto error;
1267     }
1268
1269     if (trans & (WINEDDBLTFAST_SRCCOLORKEY | WINEDDBLTFAST_DESTCOLORKEY))
1270     {
1271         DWORD keylow, keyhigh;
1272         TRACE("Color keyed copy\n");
1273         if (trans & WINEDDBLTFAST_SRCCOLORKEY)
1274         {
1275             keylow  = Src->SrcBltCKey.dwColorSpaceLowValue;
1276             keyhigh = Src->SrcBltCKey.dwColorSpaceHighValue;
1277         }
1278         else
1279         {
1280             /* I'm not sure if this is correct */
1281             FIXME("WINEDDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
1282             keylow  = This->DestBltCKey.dwColorSpaceLowValue;
1283             keyhigh = This->DestBltCKey.dwColorSpaceHighValue;
1284         }
1285
1286 #define COPYBOX_COLORKEY(type) { \
1287             type *d, *s, tmp; \
1288             s = (type *) sbuf; \
1289             d = (type *) dbuf; \
1290             for (y = 0; y < h; y++) { \
1291                 for (x = 0; x < w; x++) { \
1292                     tmp = s[x]; \
1293                     if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1294                 } \
1295                 s = (type *)((BYTE *)s + slock.Pitch); \
1296                 d = (type *)((BYTE *)d + dlock.Pitch); \
1297             } \
1298             break; \
1299         }
1300
1301         switch (bpp) {
1302             case 1: COPYBOX_COLORKEY(BYTE)
1303             case 2: COPYBOX_COLORKEY(WORD)
1304             case 4: COPYBOX_COLORKEY(DWORD)
1305             case 3:
1306             {
1307                 BYTE *d, *s;
1308                 DWORD tmp;
1309                 s = (BYTE *) sbuf;
1310                 d = (BYTE *) dbuf;
1311                 for (y = 0; y < h; y++)
1312                 {
1313                     for (x = 0; x < w * 3; x += 3)
1314                     {
1315                         tmp = (DWORD)s[x] + ((DWORD)s[x + 1] << 8) + ((DWORD)s[x + 2] << 16);
1316                         if (tmp < keylow || tmp > keyhigh)
1317                         {
1318                             d[x + 0] = s[x + 0];
1319                             d[x + 1] = s[x + 1];
1320                             d[x + 2] = s[x + 2];
1321                         }
1322                     }
1323                     s += slock.Pitch;
1324                     d += dlock.Pitch;
1325                 }
1326                 break;
1327             }
1328             default:
1329                 FIXME("Source color key blitting not supported for bpp %d\n",bpp*8);
1330                 ret = WINED3DERR_NOTAVAILABLE;
1331                 goto error;
1332         }
1333 #undef COPYBOX_COLORKEY
1334         TRACE("Copy Done\n");
1335     }
1336     else
1337     {
1338         int width = w * bpp;
1339         TRACE("NO color key copy\n");
1340         for (y = 0; y < h; y++)
1341         {
1342             /* This is pretty easy, a line for line memcpy */
1343             memcpy(dbuf, sbuf, width);
1344             sbuf += slock.Pitch;
1345             dbuf += dlock.Pitch;
1346         }
1347         TRACE("Copy done\n");
1348     }
1349
1350 error:
1351     if (Src == This)
1352     {
1353         IWineD3DSurface_UnlockRect(iface);
1354     }
1355     else
1356     {
1357         IWineD3DSurface_UnlockRect(iface);
1358         IWineD3DSurface_UnlockRect(Source);
1359     }
1360
1361     return ret;
1362 }
1363
1364 /*****************************************************************************
1365  * IWineD3DSurface::LoadTexture, GDI version
1366  *
1367  * This is mutually unsupported by GDI surfaces
1368  *
1369  * Returns:
1370  *  D3DERR_INVALIDCALL
1371  *
1372  *****************************************************************************/
1373 HRESULT WINAPI
1374 IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode)
1375 {
1376     ERR("Unsupported on X11 surfaces\n");
1377     return WINED3DERR_INVALIDCALL;
1378 }
1379
1380 /*****************************************************************************
1381  * IWineD3DSurface::SaveSnapshot, GDI version
1382  *
1383  * This method writes the surface's contents to the in tga format to the
1384  * file specified in filename.
1385  *
1386  * Params:
1387  *  filename: File to write to
1388  *
1389  * Returns:
1390  *  WINED3DERR_INVALIDCALL if the file couldn't be opened
1391  *  WINED3D_OK on success
1392  *
1393  *****************************************************************************/
1394 static int get_shift(DWORD color_mask) {
1395     int shift = 0;
1396     while (color_mask > 0xFF) {
1397         color_mask >>= 1;
1398         shift += 1;
1399     }
1400     while ((color_mask & 0x80) == 0) {
1401         color_mask <<= 1;
1402         shift -= 1;
1403     }
1404     return shift;
1405 }
1406
1407
1408 HRESULT WINAPI
1409 IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface *iface,
1410 const char* filename)
1411 {
1412     FILE* f = NULL;
1413     UINT y = 0, x = 0;
1414     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1415     static char *output = NULL;
1416     static int size = 0;
1417     const StaticPixelFormatDesc *formatEntry = getFormatDescEntry(This->resource.format, NULL, NULL);
1418
1419     if (This->pow2Width > size) {
1420         output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pow2Width * 3);
1421         size = This->pow2Width;
1422     }
1423
1424
1425     f = fopen(filename, "w+");
1426     if (NULL == f) {
1427         ERR("opening of %s failed with\n", filename);
1428         return WINED3DERR_INVALIDCALL;
1429     }
1430     fprintf(f, "P6\n%d %d\n255\n", This->pow2Width, This->pow2Height);
1431
1432     if (This->resource.format == WINED3DFMT_P8) {
1433         unsigned char table[256][3];
1434         int i;
1435
1436         if (This->palette == NULL) {
1437             fclose(f);
1438             return WINED3DERR_INVALIDCALL;
1439         }
1440         for (i = 0; i < 256; i++) {
1441             table[i][0] = This->palette->palents[i].peRed;
1442             table[i][1] = This->palette->palents[i].peGreen;
1443             table[i][2] = This->palette->palents[i].peBlue;
1444         }
1445         for (y = 0; y < This->pow2Height; y++) {
1446             unsigned char *src = (unsigned char *) This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
1447             for (x = 0; x < This->pow2Width; x++) {
1448                 unsigned char color = *src;
1449                 src += 1;
1450
1451                 output[3 * x + 0] = table[color][0];
1452                 output[3 * x + 1] = table[color][1];
1453                 output[3 * x + 2] = table[color][2];
1454             }
1455             fwrite(output, 3 * This->pow2Width, 1, f);
1456         }
1457     } else {
1458         int red_shift, green_shift, blue_shift, pix_width;
1459
1460         pix_width = This->bytesPerPixel;
1461
1462         red_shift = get_shift(formatEntry->redMask);
1463         green_shift = get_shift(formatEntry->greenMask);
1464         blue_shift = get_shift(formatEntry->blueMask);
1465
1466         for (y = 0; y < This->pow2Height; y++) {
1467             unsigned char *src = (unsigned char *) This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
1468             for (x = 0; x < This->pow2Width; x++) {         
1469                 unsigned int color;
1470                 unsigned int comp;
1471                 int i;
1472
1473                 color = 0;
1474                 for (i = 0; i < pix_width; i++) {
1475                     color |= src[i] << (8 * i);
1476                 }
1477                 src += 1 * pix_width;
1478
1479                 comp = color & formatEntry->redMask;
1480                 output[3 * x + 0] = red_shift > 0 ? comp >> red_shift : comp << -red_shift;
1481                 comp = color & formatEntry->greenMask;
1482                 output[3 * x + 1] = green_shift > 0 ? comp >> green_shift : comp << -green_shift;
1483                 comp = color & formatEntry->blueMask;
1484                 output[3 * x + 2] = blue_shift > 0 ? comp >> blue_shift : comp << -blue_shift;
1485             }
1486             fwrite(output, 3 * This->pow2Width, 1, f);
1487         }
1488     }
1489     fclose(f);
1490     return WINED3D_OK;
1491 }
1492
1493 /*****************************************************************************
1494  * IWineD3DSurface::PrivateSetup, GDI version
1495  *
1496  * Initializes the GDI surface, aka creates the DIB section we render to
1497  * The DIB section creation is done by calling GetDC, which will create the
1498  * section and releasing the dc to allow the app to use it. The dib section
1499  * will stay until the surface is released
1500  *
1501  * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
1502  * are set to the real sizes to save memory. The NONPOW2 flag is unset to
1503  * avoid confusion in the shared surface code.
1504  *
1505  * Returns:
1506  *  WINED3D_OK on success
1507  *  The return values of called methods on failure
1508  *
1509  *****************************************************************************/
1510 HRESULT WINAPI
1511 IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface *iface)
1512 {
1513     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
1514     HRESULT hr;
1515     HDC hdc;
1516
1517     if(This->resource.usage & WINED3DUSAGE_OVERLAY)
1518     {
1519         ERR("(%p) Overlays not yet supported by GDI surfaces\n", This);
1520         return WINED3DERR_INVALIDCALL;
1521     }
1522     /* Sysmem textures have memory already allocated -
1523      * release it, this avoids an unnecessary memcpy
1524      */
1525     HeapFree(GetProcessHeap(), 0, This->resource.allocatedMemory);
1526     This->resource.allocatedMemory = NULL;
1527
1528     /* We don't mind the nonpow2 stuff in GDI */
1529     This->pow2Width = This->currentDesc.Width;
1530     This->pow2Height = This->currentDesc.Height;
1531
1532     /* Call GetDC to create a DIB section. We will use that
1533      * DIB section for rendering
1534      *
1535      * Release the DC afterwards to allow the app to use it
1536      */
1537     hr = IWineD3DSurface_GetDC(iface, &hdc);
1538     if(FAILED(hr))
1539     {
1540         ERR("(%p) IWineD3DSurface::GetDC failed with hr %08x\n", This, hr);
1541         return hr;
1542     }
1543     hr = IWineD3DSurface_ReleaseDC(iface, hdc);
1544     if(FAILED(hr))
1545     {
1546         ERR("(%p) IWineD3DSurface::ReleaseDC failed with hr %08x\n", This, hr);
1547         return hr;
1548     }
1549
1550     return WINED3D_OK;
1551 }
1552
1553 const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
1554 {
1555     /* IUnknown */
1556     IWineD3DSurfaceImpl_QueryInterface,
1557     IWineD3DSurfaceImpl_AddRef,
1558     IWineD3DSurfaceImpl_Release,
1559     /* IWineD3DResource */
1560     IWineD3DSurfaceImpl_GetParent,
1561     IWineD3DSurfaceImpl_GetDevice,
1562     IWineD3DSurfaceImpl_SetPrivateData,
1563     IWineD3DSurfaceImpl_GetPrivateData,
1564     IWineD3DSurfaceImpl_FreePrivateData,
1565     IWineD3DSurfaceImpl_SetPriority,
1566     IWineD3DSurfaceImpl_GetPriority,
1567     IWineGDISurfaceImpl_PreLoad,
1568     IWineD3DSurfaceImpl_GetType,
1569     /* IWineD3DSurface */
1570     IWineD3DSurfaceImpl_GetContainer,
1571     IWineD3DSurfaceImpl_GetDesc,
1572     IWineGDISurfaceImpl_LockRect,
1573     IWineGDISurfaceImpl_UnlockRect,
1574     IWineD3DSurfaceImpl_GetDC,
1575     IWineD3DSurfaceImpl_ReleaseDC,
1576     IWineGDISurfaceImpl_Flip,
1577     IWineGDISurfaceImpl_Blt,
1578     IWineD3DSurfaceImpl_GetBltStatus,
1579     IWineD3DSurfaceImpl_GetFlipStatus,
1580     IWineD3DSurfaceImpl_IsLost,
1581     IWineD3DSurfaceImpl_Restore,
1582     IWineGDISurfaceImpl_BltFast,
1583     IWineD3DSurfaceImpl_GetPalette,
1584     IWineD3DSurfaceImpl_SetPalette,
1585     IWineD3DSurfaceImpl_RealizePalette,
1586     IWineD3DSurfaceImpl_SetColorKey,
1587     IWineD3DSurfaceImpl_GetPitch,
1588     IWineD3DSurfaceImpl_SetMem,
1589     IWineD3DSurfaceImpl_SetOverlayPosition,
1590     IWineD3DSurfaceImpl_GetOverlayPosition,
1591     IWineD3DSurfaceImpl_UpdateOverlayZOrder,
1592     IWineD3DSurfaceImpl_UpdateOverlay,
1593     IWineD3DSurfaceImpl_SetClipper,
1594     IWineD3DSurfaceImpl_GetClipper,
1595     /* Internal use: */
1596     IWineD3DSurfaceImpl_AddDirtyRect,
1597     IWineGDISurfaceImpl_LoadTexture,
1598     IWineGDISurfaceImpl_SaveSnapshot,
1599     IWineD3DSurfaceImpl_SetContainer,
1600     IWineD3DSurfaceImpl_SetGlTextureDesc,
1601     IWineD3DSurfaceImpl_GetGlDesc,
1602     IWineD3DSurfaceImpl_GetData,
1603     IWineD3DSurfaceImpl_SetFormat,
1604     IWineGDISurfaceImpl_PrivateSetup
1605 };