Assorted spelling fixes.
[wine] / dlls / ddraw / surface_dib.c
1 /*              DIBSection DirectDrawSurface driver
2  *
3  * Copyright 1997-2000 Marcus Meissner
4  * Copyright 1998-2000 Lionel Ulmer
5  * Copyright 2000-2001 TransGaming Technologies Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include "config.h"
23
24 #include <assert.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
30
31 #define CONST_VTABLE
32
33 #include "winerror.h"
34 #include "wine/debug.h"
35 #include "ddraw_private.h"
36 #include "d3d_private.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
39
40 /* FIXME */
41 extern HBITMAP DIB_CreateDIBSection( HDC hdc, const BITMAPINFO *bmi, UINT usage, VOID **bits,
42                                      HANDLE section, DWORD offset, DWORD ovr_pitch );
43
44 static const IDirectDrawSurface7Vtbl DIB_IDirectDrawSurface7_VTable;
45
46 /* Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned. */
47 inline static int get_dib_width_bytes( int width, int depth )
48 {
49     int words;
50
51     switch(depth)
52     {
53     case 1:  words = (width + 31) / 32; break;
54     case 4:  words = (width + 7) / 8; break;
55     case 8:  words = (width + 3) / 4; break;
56     case 15:
57     case 16: words = (width + 1) / 2; break;
58     case 24: words = (width * 3 + 3)/4; break;
59     default:
60         WARN("(%d): Unsupported depth\n", depth );
61         /* fall through */
62     case 32: words = width; break;
63     }
64     return 4 * words;
65 }
66
67
68 static HRESULT create_dib(IDirectDrawSurfaceImpl* This)
69 {
70     BITMAPINFO* b_info;
71     UINT usage;
72     HDC ddc;
73     DIB_DirectDrawSurfaceImpl* priv = This->private;
74
75     assert(This->surface_desc.lpSurface != NULL);
76
77     switch (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount)
78     {
79     case 16:
80     case 32:
81         /* Allocate extra space to store the RGB bit masks. */
82         b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
83                            sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD));
84         break;
85
86     case 24:
87         b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
88                            sizeof(BITMAPINFOHEADER));
89         break;
90
91     default:
92         /* Allocate extra space for a palette. */
93         b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
94                            sizeof(BITMAPINFOHEADER)
95                            + sizeof(RGBQUAD)
96                            * (1 << This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount));
97         break;
98     }
99
100     b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
101     b_info->bmiHeader.biWidth = This->surface_desc.dwWidth;
102     b_info->bmiHeader.biHeight = -This->surface_desc.dwHeight;
103     b_info->bmiHeader.biPlanes = 1;
104     b_info->bmiHeader.biBitCount = This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount;
105
106     if ((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount != 16)
107         && (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount != 32))
108         b_info->bmiHeader.biCompression = BI_RGB;
109     else
110         b_info->bmiHeader.biCompression = BI_BITFIELDS;
111
112     b_info->bmiHeader.biSizeImage
113         = (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8)
114         * This->surface_desc.dwWidth * This->surface_desc.dwHeight;
115
116     b_info->bmiHeader.biXPelsPerMeter = 0;
117     b_info->bmiHeader.biYPelsPerMeter = 0;
118     b_info->bmiHeader.biClrUsed = 0;
119     b_info->bmiHeader.biClrImportant = 0;
120
121     if (!This->surface_desc.u1.lPitch) {
122         /* This can't happen, right? */
123         /* or use GDI_GetObj to get it from the created DIB? */
124         This->surface_desc.u1.lPitch = get_dib_width_bytes(b_info->bmiHeader.biWidth, b_info->bmiHeader.biBitCount);
125         This->surface_desc.dwFlags |= DDSD_PITCH;
126     }
127     
128     switch (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount)
129     {
130     case 16:
131     case 32:
132     {
133         DWORD *masks = (DWORD *) &(b_info->bmiColors);
134
135         usage = 0;
136         masks[0] = This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask;
137         masks[1] = This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask;
138         masks[2] = This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask;
139     }
140     break;
141
142     case 24:
143         /* Nothing to do */
144         usage = DIB_RGB_COLORS;
145         break;
146
147     default:
148         /* Don't know palette */
149         usage = 0;
150         break;
151     }
152
153     ddc = CreateDCA("DISPLAY", NULL, NULL, NULL);
154     if (ddc == 0)
155     {
156         HeapFree(GetProcessHeap(), 0, b_info);
157         return HRESULT_FROM_WIN32(GetLastError());
158     }
159
160     priv->dib.DIBsection
161         = DIB_CreateDIBSection(ddc, b_info, usage, &(priv->dib.bitmap_data), 0,
162                                (DWORD)This->surface_desc.lpSurface,
163                                This->surface_desc.u1.lPitch);
164     DeleteDC(ddc);
165     if (!priv->dib.DIBsection) {
166         ERR("CreateDIBSection failed!\n");
167         HeapFree(GetProcessHeap(), 0, b_info);
168         return HRESULT_FROM_WIN32(GetLastError());
169     }
170
171     TRACE("DIBSection at : %p\n", priv->dib.bitmap_data);
172
173     if (!This->surface_desc.lpSurface) {
174         This->surface_desc.lpSurface = priv->dib.bitmap_data;
175         This->surface_desc.dwFlags |= DDSD_LPSURFACE;
176     }
177
178     HeapFree(GetProcessHeap(), 0, b_info);
179
180     /* I don't think it's worth checking for this. */
181     if (priv->dib.bitmap_data != This->surface_desc.lpSurface)
182         ERR("unexpected error creating DirectDrawSurface DIB section\n");
183
184     /* this seems like a good place to put the handle for HAL driver use */
185     This->global_more.hKernelSurface = (ULONG_PTR)priv->dib.DIBsection;
186
187     return S_OK;
188 }
189
190 void DIB_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl* This)
191 {
192     DIB_DirectDrawSurfaceImpl* priv = This->private;
193
194     DeleteObject(priv->dib.DIBsection);
195
196     if (!priv->dib.client_memory)
197         VirtualFree(This->surface_desc.lpSurface, 0, MEM_RELEASE);
198
199     Main_DirectDrawSurface_final_release(This);
200 }
201
202 HRESULT DIB_DirectDrawSurface_duplicate_surface(IDirectDrawSurfaceImpl* This,
203                                                 LPDIRECTDRAWSURFACE7* ppDup)
204 {
205     return DIB_DirectDrawSurface_Create(This->ddraw_owner,
206                                         &This->surface_desc, ppDup, NULL);
207 }
208
209 HRESULT DIB_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl *This,
210                                         IDirectDrawImpl *pDD,
211                                         const DDSURFACEDESC2 *pDDSD)
212 {
213     HRESULT hr;
214     DIB_DirectDrawSurfaceImpl* priv = This->private;
215
216     TRACE("(%p)->(%p,%p)\n",This,pDD,pDDSD);
217     hr = Main_DirectDrawSurface_Construct(This, pDD, pDDSD);
218     if (FAILED(hr)) return hr;
219
220     ICOM_INIT_INTERFACE(This, IDirectDrawSurface7,
221                         DIB_IDirectDrawSurface7_VTable);
222
223     This->final_release = DIB_DirectDrawSurface_final_release;
224     This->duplicate_surface = DIB_DirectDrawSurface_duplicate_surface;
225     This->flip_data = DIB_DirectDrawSurface_flip_data;
226
227     This->get_dc     = DIB_DirectDrawSurface_get_dc;
228     This->release_dc = DIB_DirectDrawSurface_release_dc;
229     This->hDC = NULL;
230
231     This->set_palette    = DIB_DirectDrawSurface_set_palette;
232     This->update_palette = DIB_DirectDrawSurface_update_palette;
233
234     TRACE("(%ldx%ld, pitch=%ld)\n",
235           This->surface_desc.dwWidth, This->surface_desc.dwHeight,
236           This->surface_desc.u1.lPitch);
237     /* XXX load dwWidth and dwHeight from pDD if they are not specified? */
238
239     if (This->surface_desc.dwFlags & DDSD_LPSURFACE)
240     {
241         /* "Client memory": it is managed by the application. */
242         /* XXX What if lPitch is not set? Use dwWidth or fail? */
243
244         priv->dib.client_memory = TRUE;
245     }
246     else
247     {
248         if (!(This->surface_desc.dwFlags & DDSD_PITCH))
249         {
250             int pitch = This->surface_desc.u1.lPitch;
251             if (pitch % 8 != 0)
252                 pitch += 8 - (pitch % 8);
253         }
254         /* XXX else: how should lPitch be verified? */
255
256         This->surface_desc.dwFlags |= DDSD_LPSURFACE;
257
258         /* Ensure that DDSD_PITCH is respected for DDPF_FOURCC surfaces too */
259         if (This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC && !(This->surface_desc.dwFlags & DDSD_PITCH)) {
260             This->surface_desc.lpSurface
261                 = VirtualAlloc(NULL, This->surface_desc.u1.dwLinearSize, MEM_COMMIT, PAGE_READWRITE);
262             This->surface_desc.dwFlags |= DDSD_LINEARSIZE;
263         } else {
264             This->surface_desc.lpSurface
265                 = VirtualAlloc(NULL, This->surface_desc.u1.lPitch
266                            * This->surface_desc.dwHeight + 4, /* The + 4 here is for dumb games reading after the end of the surface
267                                                                  when reading the last byte / half using word access */
268                            MEM_COMMIT, PAGE_READWRITE);
269             This->surface_desc.dwFlags |= DDSD_PITCH;
270         }
271
272         if (This->surface_desc.lpSurface == NULL)
273         {
274             Main_DirectDrawSurface_final_release(This);
275             return HRESULT_FROM_WIN32(GetLastError());
276         }
277
278         priv->dib.client_memory = FALSE;
279     }
280
281     hr = create_dib(This);
282     if (FAILED(hr))
283     {
284         if (!priv->dib.client_memory)
285             VirtualFree(This->surface_desc.lpSurface, 0, MEM_RELEASE);
286
287         Main_DirectDrawSurface_final_release(This);
288
289         return hr;
290     }
291
292     return DD_OK;
293 }
294
295 /* Not an API */
296 HRESULT DIB_DirectDrawSurface_Create(IDirectDrawImpl *pDD,
297                                      const DDSURFACEDESC2 *pDDSD,
298                                      LPDIRECTDRAWSURFACE7 *ppSurf,
299                                      IUnknown *pUnkOuter)
300 {
301     IDirectDrawSurfaceImpl* This;
302     HRESULT hr;
303     assert(pUnkOuter == NULL);
304
305     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
306                      sizeof(*This) + sizeof(DIB_DirectDrawSurfaceImpl));
307     if (This == NULL) return E_OUTOFMEMORY;
308
309     This->private = (DIB_DirectDrawSurfaceImpl*)(This+1);
310
311     hr = DIB_DirectDrawSurface_Construct(This, pDD, pDDSD);
312     if (FAILED(hr))
313         HeapFree(GetProcessHeap(), 0, This);
314     else
315         *ppSurf = ICOM_INTERFACE(This, IDirectDrawSurface7);
316
317     return hr;
318
319 }
320
321 /* AddAttachedSurface: generic */
322 /* AddOverlayDirtyRect: generic, unimplemented */
323
324 static HRESULT _Blt_ColorFill(
325     LPBYTE buf, int width, int height, int bpp, LONG lPitch, DWORD color
326 ) {
327     int x, y;
328     LPBYTE first;
329
330     /* Do first row */
331
332 #define COLORFILL_ROW(type) { \
333     type *d = (type *) buf; \
334     for (x = 0; x < width; x++) \
335         d[x] = (type) color; \
336     break; \
337 }
338
339     switch(bpp) {
340     case 1: COLORFILL_ROW(BYTE)
341     case 2: COLORFILL_ROW(WORD)
342     case 3: { BYTE *d = (BYTE *) buf;
343               for (x = 0; x < width; x++,d+=3) {
344                 d[0] = (color    ) & 0xFF;
345                 d[1] = (color>> 8) & 0xFF;
346                 d[2] = (color>>16) & 0xFF;
347               }
348               break;}
349     case 4: COLORFILL_ROW(DWORD)
350     default:
351         FIXME("Color fill not implemented for bpp %d!\n", bpp*8);
352         return DDERR_UNSUPPORTED;
353     }
354
355 #undef COLORFILL_ROW
356
357     /* Now copy first row */
358     first = buf;
359     for (y = 1; y < height; y++) {
360         buf += lPitch;
361         memcpy(buf, first, width * bpp);
362     }
363     return DD_OK;
364 }
365
366 static void ComputeShifts(DWORD mask, DWORD* lshift, DWORD* rshift)
367 {
368     int pos = 0;
369     int bits = 0;
370     *lshift = 0;
371     *rshift = 0;
372     
373     if (!mask)
374         return;
375     
376     while(!(mask & (1 << pos)))
377         pos++; 
378     
379     while(mask & (1 << (pos+bits)))
380         bits++;
381     
382     *lshift = pos;
383     *rshift = 8 - bits;
384 }
385
386 /* This is used to factorize the decompression between the Blt and BltFast code */
387 static void DoDXTCDecompression(const DDSURFACEDESC2 *sdesc, const DDSURFACEDESC2 *ddesc)
388 {
389     DWORD rs,rb,rm;
390     DWORD gs,gb,gm;
391     DWORD bs,bb,bm;
392     DWORD as,ab,am;
393
394     if (!s3tc_initialized) {
395         /* FIXME: We may fake this by rendering the texture into the framebuffer using OpenGL functions and reading back
396          *        the framebuffer. This will be slow and somewhat ugly. */ 
397         FIXME("Manual S3TC decompression is not supported in native mode\n");
398         return;
399     }
400     
401     rm = ddesc->u4.ddpfPixelFormat.u2.dwRBitMask;
402     ComputeShifts(rm, &rs, &rb);
403     gm = ddesc->u4.ddpfPixelFormat.u3.dwGBitMask;
404     ComputeShifts(gm, &gs, &gb);
405     bm = ddesc->u4.ddpfPixelFormat.u4.dwBBitMask;
406     ComputeShifts(bm, &bs, &bb);
407     am = ddesc->u4.ddpfPixelFormat.u5.dwRGBAlphaBitMask;
408     ComputeShifts(am, &as, &ab);
409     if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','1')) {
410         int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
411         int pitch = ddesc->u1.lPitch;
412         int width = ddesc->dwWidth;
413         int height = ddesc->dwHeight;
414         int x,y;
415         char* dst = (char*) ddesc->lpSurface;
416         char* src = (char*) sdesc->lpSurface;
417         for (x = 0; x < width; x++)
418             for (y =0; y < height; y++) {
419                 DWORD pixel = 0;
420                 BYTE data[4];
421                 (*fetch_2d_texel_rgba_dxt1)(width, src, x, y, data);
422                 pixel = 0;
423                 pixel |= ((data[0] >> rb) << rs) & rm;
424                 pixel |= ((data[1] >> gb) << gs) & gm;
425                 pixel |= ((data[2] >> bb) << bs) & bm;
426                 pixel |= ((data[3] >> ab) << as) & am;
427                 if (is16)
428                     *((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
429                 else
430                     *((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
431             }
432     } else if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','3')) {
433         int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
434         int pitch = ddesc->u1.lPitch;
435         int width = ddesc->dwWidth;
436         int height = ddesc->dwHeight;
437         int x,y;
438         char* dst = (char*) ddesc->lpSurface;
439         char* src = (char*) sdesc->lpSurface;
440         for (x = 0; x < width; x++)
441             for (y =0; y < height; y++) {
442                 DWORD pixel = 0;
443                 BYTE data[4];
444                 (*fetch_2d_texel_rgba_dxt3)(width, src, x, y, data);
445                 pixel = 0;
446                 pixel |= ((data[0] >> rb) << rs) & rm;
447                 pixel |= ((data[1] >> gb) << gs) & gm;
448                 pixel |= ((data[2] >> bb) << bs) & bm;
449                 pixel |= ((data[3] >> ab) << as) & am;
450                 if (is16)
451                     *((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
452                 else
453                     *((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
454             }
455     } else if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','5')) {
456         int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
457         int pitch = ddesc->u1.lPitch;
458         int width = ddesc->dwWidth;
459         int height = ddesc->dwHeight;
460         int x,y;
461         char* dst = (char*) ddesc->lpSurface;
462         char* src = (char*) sdesc->lpSurface;
463         for (x = 0; x < width; x++)
464             for (y =0; y < height; y++) {
465                 DWORD pixel = 0;
466                 BYTE data[4];
467                 (*fetch_2d_texel_rgba_dxt5)(width, src, x, y, data);
468                 pixel = 0;
469                 pixel |= ((data[0] >> rb) << rs) & rm;
470                 pixel |= ((data[1] >> gb) << gs) & gm;
471                 pixel |= ((data[2] >> bb) << bs) & bm;
472                 pixel |= ((data[3] >> ab) << as) & am;
473                 if (is16)
474                     *((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
475                 else
476                     *((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
477             }
478     }
479 #if 0 /* Useful for debugging */
480     {
481         static int idx;
482         char texname[255];
483         FILE* f;
484         sprintf(texname, "dxt_%d.pnm", idx++);
485         f = fopen(texname,"w");
486         DDRAW_dump_surface_to_disk(This, f, 1);
487         fclose(f);
488     }
489 #endif
490 }
491
492 HRESULT WINAPI
493 DIB_DirectDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
494                           LPDIRECTDRAWSURFACE7 src, LPRECT rsrc,
495                           DWORD dwFlags, LPDDBLTFX lpbltfx)
496 {
497     IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
498     RECT                xdst,xsrc;
499     DDSURFACEDESC2      ddesc,sdesc;
500     HRESULT             ret = DD_OK;
501     int bpp, srcheight, srcwidth, dstheight, dstwidth, width;
502     int x, y;
503     LPBYTE dbuf, sbuf;
504     
505     TRACE("(%p)->(%p,%p,%p,%08lx,%p)\n", This,rdst,src,rsrc,dwFlags,lpbltfx);
506
507     if (TRACE_ON(ddraw)) {
508         if (rdst) TRACE("\tdestrect :%ldx%ld-%ldx%ld\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
509         if (rsrc) TRACE("\tsrcrect  :%ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
510         TRACE("\tflags: ");
511         DDRAW_dump_DDBLT(dwFlags);
512         if (dwFlags & DDBLT_DDFX) {
513             TRACE("\tblitfx: ");
514             DDRAW_dump_DDBLTFX(lpbltfx->dwDDFX);
515         }
516     }
517
518     if ((This->locked) || ((src != NULL) && (((IDirectDrawSurfaceImpl *)src)->locked))) {
519         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
520         return DDERR_SURFACEBUSY;
521     }
522
523     /* First, check if the possible override function handles this case */
524     if (This->aux_blt != NULL) {
525         if (This->aux_blt(This, rdst, src, rsrc, dwFlags, lpbltfx) == DD_OK) return DD_OK;
526     }
527
528     DD_STRUCT_INIT(&ddesc);
529     DD_STRUCT_INIT(&sdesc);
530
531     sdesc.dwSize = sizeof(sdesc);
532     ddesc.dwSize = sizeof(ddesc);
533
534     if (src == iface) {
535         IDirectDrawSurface7_Lock(iface, NULL, &ddesc, 0, 0);
536         DD_STRUCT_COPY_BYSIZE(&sdesc, &ddesc);
537     } else {
538         if (src) IDirectDrawSurface7_Lock(src, NULL, &sdesc, DDLOCK_READONLY, 0);
539         IDirectDrawSurface7_Lock(iface,NULL,&ddesc,DDLOCK_WRITEONLY,0);
540     }
541
542     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
543         (ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)) {
544         if (sdesc.u4.ddpfPixelFormat.dwFourCC != sdesc.u4.ddpfPixelFormat.dwFourCC) {
545             FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
546             ret = DDERR_INVALIDPIXELFORMAT;
547             goto release;
548         }
549         memcpy(ddesc.lpSurface, sdesc.lpSurface, ddesc.u1.dwLinearSize);
550         goto release;
551     }
552
553     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
554         (!(ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC))) {
555         DoDXTCDecompression(&sdesc, &ddesc);
556         goto release;
557     }
558     
559     if (rdst) {
560         memcpy(&xdst,rdst,sizeof(xdst));
561     } else {
562         xdst.top        = 0;
563         xdst.bottom     = ddesc.dwHeight;
564         xdst.left       = 0;
565         xdst.right      = ddesc.dwWidth;
566     }
567
568     if (rsrc) {
569         memcpy(&xsrc,rsrc,sizeof(xsrc));
570     } else {
571         if (src) {
572             xsrc.top    = 0;
573             xsrc.bottom = sdesc.dwHeight;
574             xsrc.left   = 0;
575             xsrc.right  = sdesc.dwWidth;
576         } else {
577             memset(&xsrc,0,sizeof(xsrc));
578         }
579     }
580
581     /* First check for the validity of source / destination rectangles. This was
582        verified using a test application + by MSDN.
583     */
584     if ((src != NULL) &&
585         ((xsrc.bottom > sdesc.dwHeight) || (xsrc.bottom < 0) ||
586          (xsrc.top > sdesc.dwHeight) || (xsrc.top < 0) ||
587          (xsrc.left > sdesc.dwWidth) || (xsrc.left < 0) ||
588          (xsrc.right > sdesc.dwWidth) || (xsrc.right < 0) ||
589          (xsrc.right < xsrc.left) || (xsrc.bottom < xsrc.top))) {
590         WARN("Application gave us bad source rectangle for Blt.\n");
591         ret = DDERR_INVALIDRECT;
592         goto release;
593     }
594     /* For the Destination rect, it can be out of bounds on the condition that a clipper
595        is set for the given surface.
596     */
597     if ((This->clipper == NULL) &&
598         ((xdst.bottom > ddesc.dwHeight) || (xdst.bottom < 0) ||
599          (xdst.top > ddesc.dwHeight) || (xdst.top < 0) ||
600          (xdst.left > ddesc.dwWidth) || (xdst.left < 0) ||
601          (xdst.right > ddesc.dwWidth) || (xdst.right < 0) ||
602          (xdst.right < xdst.left) || (xdst.bottom < xdst.top))) {
603         WARN("Application gave us bad destination rectangle for Blt without a clipper set.\n");
604         ret = DDERR_INVALIDRECT;
605         goto release;
606     }
607     
608     /* Now handle negative values in the rectangles. Warning: only supported for now
609        in the 'simple' cases (ie not in any stretching / rotation cases).
610
611        First, the case where nothing is to be done.
612     */
613     if (((xdst.bottom <= 0) || (xdst.right <= 0) || (xdst.top >= (int) ddesc.dwHeight) || (xdst.left >= (int) ddesc.dwWidth)) ||
614         ((src != NULL) &&
615          ((xsrc.bottom <= 0) || (xsrc.right <= 0) || (xsrc.top >= (int) sdesc.dwHeight) || (xsrc.left >= (int) sdesc.dwWidth))))
616     {
617         TRACE("Nothing to be done !\n");
618         goto release;
619     }
620
621     /* The easy case : the source-less blits.... */
622     if (src == NULL) {
623         RECT full_rect;
624         RECT temp_rect; /* No idea if intersect rect can be the same as one of the source rect */
625
626         full_rect.left   = 0;
627         full_rect.top    = 0;
628         full_rect.right  = ddesc.dwWidth;
629         full_rect.bottom = ddesc.dwHeight;
630         IntersectRect(&temp_rect, &full_rect, &xdst);
631         xdst = temp_rect;
632     } else {
633         /* Only handle clipping on the destination rectangle */
634         int clip_horiz = (xdst.left < 0) || (xdst.right  > (int) ddesc.dwWidth );
635         int clip_vert  = (xdst.top  < 0) || (xdst.bottom > (int) ddesc.dwHeight);
636         if (clip_vert || clip_horiz) {
637             /* Now check if this is a special case or not... */
638             if ((((xdst.bottom - xdst.top ) != (xsrc.bottom - xsrc.top )) && clip_vert ) ||
639                 (((xdst.right  - xdst.left) != (xsrc.right  - xsrc.left)) && clip_horiz) ||
640                 (dwFlags & DDBLT_DDFX)) {
641                 WARN("Out of screen rectangle in special case. Not handled right now.\n");
642                 goto release;
643             }
644
645             if (clip_horiz) {
646               if (xdst.left < 0) { xsrc.left -= xdst.left; xdst.left = 0; }
647               if (xdst.right > ddesc.dwWidth) { xsrc.right -= (xdst.right - (int) ddesc.dwWidth); xdst.right = (int) ddesc.dwWidth; }
648             }
649             if (clip_vert) {
650                 if (xdst.top < 0) { xsrc.top -= xdst.top; xdst.top = 0; }
651                 if (xdst.bottom > ddesc.dwHeight) { xsrc.bottom -= (xdst.bottom - (int) ddesc.dwHeight); xdst.bottom = (int) ddesc.dwHeight; }
652             }
653             /* And check if after clipping something is still to be done... */
654             if ((xdst.bottom <= 0) || (xdst.right <= 0) || (xdst.top >= (int) ddesc.dwHeight) || (xdst.left >= (int) ddesc.dwWidth) ||
655                 (xsrc.bottom <= 0) || (xsrc.right <= 0) || (xsrc.top >= (int) sdesc.dwHeight) || (xsrc.left >= (int) sdesc.dwWidth)) {
656                 TRACE("Nothing to be done after clipping !\n");
657                 goto release;
658             }
659         }
660     }
661
662     bpp = GET_BPP(ddesc);
663     srcheight = xsrc.bottom - xsrc.top;
664     srcwidth = xsrc.right - xsrc.left;
665     dstheight = xdst.bottom - xdst.top;
666     dstwidth = xdst.right - xdst.left;
667     width = (xdst.right - xdst.left) * bpp;
668
669     assert(width <= ddesc.u1.lPitch);
670
671     dbuf = (BYTE*)ddesc.lpSurface+(xdst.top*ddesc.u1.lPitch)+(xdst.left*bpp);
672
673     if (dwFlags & (DDBLT_WAIT|DDBLT_ASYNC))
674     {
675         static BOOL displayed = FALSE;
676         if (!displayed)
677         {
678             FIXME("dwFlags DDBLT_WAIT and/or DDBLT_ASYNC: can't handle right now.\n");
679             displayed = TRUE;
680         }
681         dwFlags &= ~(DDBLT_WAIT|DDBLT_ASYNC);
682     }
683
684     /* First, all the 'source-less' blits */
685     if (dwFlags & DDBLT_COLORFILL) {
686         ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp,
687                              ddesc.u1.lPitch, lpbltfx->u5.dwFillColor);
688         dwFlags &= ~DDBLT_COLORFILL;
689     }
690
691     if (dwFlags & DDBLT_DEPTHFILL)
692         FIXME("DDBLT_DEPTHFILL needs to be implemented!\n");
693     if (dwFlags & DDBLT_ROP) {
694         /* Catch some degenerate cases here */
695         switch(lpbltfx->dwROP) {
696         case BLACKNESS:
697             ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,ddesc.u1.lPitch,0);
698             break;
699         case 0xAA0029: /* No-op */
700             break;
701         case WHITENESS:
702             ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,ddesc.u1.lPitch,~0);
703             break;
704         case SRCCOPY: /* well, we do that below ? */
705             break;
706         default:
707             FIXME("Unsupported raster op: %08lx  Pattern: %p\n", lpbltfx->dwROP, lpbltfx->u5.lpDDSPattern);
708             goto error;
709         }
710         dwFlags &= ~DDBLT_ROP;
711     }
712     if (dwFlags & DDBLT_DDROPS) {
713         FIXME("\tDdraw Raster Ops: %08lx  Pattern: %p\n", lpbltfx->dwDDROP, lpbltfx->u5.lpDDSPattern);
714     }
715     /* Now the 'with source' blits */
716     if (src) {
717         LPBYTE sbase;
718         int sx, xinc, sy, yinc;
719
720         if (!dstwidth || !dstheight) /* hmm... stupid program ? */
721             goto release;
722         sbase = (BYTE*)sdesc.lpSurface+(xsrc.top*sdesc.u1.lPitch)+xsrc.left*bpp;
723         xinc = (srcwidth << 16) / dstwidth;
724         yinc = (srcheight << 16) / dstheight;
725
726         if (!dwFlags) {
727             /* No effects, we can cheat here */
728             if (dstwidth == srcwidth) {
729                 if (dstheight == srcheight) {
730                     /* No stretching in either direction. This needs to be as
731                      * fast as possible */
732                     sbuf = sbase;
733
734                     /* check for overlapping surfaces */
735                     if (src != iface || xdst.top < xsrc.top ||
736                         xdst.right <= xsrc.left || xsrc.right <= xdst.left)
737                     {
738                         /* no overlap, or dst above src, so copy from top downwards */
739                         for (y = 0; y < dstheight; y++)
740                         {
741                             memcpy(dbuf, sbuf, width);
742                             sbuf += sdesc.u1.lPitch;
743                             dbuf += ddesc.u1.lPitch;
744                         }
745                     }
746                     else if (xdst.top > xsrc.top)  /* copy from bottom upwards */
747                     {
748                         sbuf += (sdesc.u1.lPitch*dstheight);
749                         dbuf += (ddesc.u1.lPitch*dstheight);
750                         for (y = 0; y < dstheight; y++)
751                         {
752                             sbuf -= sdesc.u1.lPitch;
753                             dbuf -= ddesc.u1.lPitch;
754                             memcpy(dbuf, sbuf, width);
755                         }
756                     }
757                     else /* src and dst overlapping on the same line, use memmove */
758                     {
759                         for (y = 0; y < dstheight; y++)
760                         {
761                             memmove(dbuf, sbuf, width);
762                             sbuf += sdesc.u1.lPitch;
763                             dbuf += ddesc.u1.lPitch;
764                         }
765                     }
766                 } else {
767                     /* Stretching in Y direction only */
768                     for (y = sy = 0; y < dstheight; y++, sy += yinc) {
769                         sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
770                         memcpy(dbuf, sbuf, width);
771                         dbuf += ddesc.u1.lPitch;
772                     }
773                 }
774             } else {
775                 /* Stretching in X direction */
776                 int last_sy = -1;
777                 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
778                     sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
779
780                     if ((sy >> 16) == (last_sy >> 16)) {
781                         /* this sourcerow is the same as last sourcerow -
782                          * copy already stretched row
783                          */
784                         memcpy(dbuf, dbuf - ddesc.u1.lPitch, width);
785                     } else {
786 #define STRETCH_ROW(type) { \
787                     type *s = (type *) sbuf, *d = (type *) dbuf; \
788                     for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
789                     d[x] = s[sx >> 16]; \
790                     break; }
791
792                     switch(bpp) {
793                     case 1: STRETCH_ROW(BYTE)
794                     case 2: STRETCH_ROW(WORD)
795                     case 4: STRETCH_ROW(DWORD)
796                     case 3: {
797                         LPBYTE s,d = dbuf;
798                         for (x = sx = 0; x < dstwidth; x++, sx+= xinc) {
799                             DWORD pixel;
800
801                             s = sbuf+3*(sx>>16);
802                             pixel = s[0]|(s[1]<<8)|(s[2]<<16);
803                             d[0] = (pixel    )&0xff;
804                             d[1] = (pixel>> 8)&0xff;
805                             d[2] = (pixel>>16)&0xff;
806                             d+=3;
807                         }
808                         break;
809                     }
810                     default:
811                         FIXME("Stretched blit not implemented for bpp %d!\n", bpp*8);
812                         ret = DDERR_UNSUPPORTED;
813                         goto error;
814                     }
815 #undef STRETCH_ROW
816                     }
817                     dbuf += ddesc.u1.lPitch;
818                     last_sy = sy;
819                 }
820             }
821         } else {
822            LONG dstyinc = ddesc.u1.lPitch, dstxinc = bpp;
823            DWORD keylow = 0, keyhigh = 0;
824            if (dwFlags & (DDBLT_KEYSRC | DDBLT_KEYDEST | DDBLT_KEYSRCOVERRIDE | DDBLT_KEYDESTOVERRIDE)) {
825
826               if (dwFlags & DDBLT_KEYSRC) {
827                  keylow  = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
828                  keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
829               } else if (dwFlags & DDBLT_KEYDEST){
830                  keylow  = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
831                  keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
832               } else if (dwFlags & DDBLT_KEYSRCOVERRIDE) {
833                  keylow  = lpbltfx->ddckSrcColorkey.dwColorSpaceLowValue;
834                  keyhigh = lpbltfx->ddckSrcColorkey.dwColorSpaceHighValue;
835               } else {
836                  keylow  = lpbltfx->ddckDestColorkey.dwColorSpaceLowValue;
837                  keyhigh = lpbltfx->ddckDestColorkey.dwColorSpaceHighValue;
838               }
839               dwFlags &= ~(DDBLT_KEYSRC | DDBLT_KEYDEST | DDBLT_KEYSRCOVERRIDE | DDBLT_KEYDESTOVERRIDE);
840            }
841
842            if (dwFlags & DDBLT_DDFX)  {
843               LPBYTE dTopLeft, dTopRight, dBottomLeft, dBottomRight, tmp;
844               LONG tmpxy;
845               dTopLeft     = dbuf;
846               dTopRight    = dbuf+((dstwidth-1)*bpp);
847               dBottomLeft  = dTopLeft+((dstheight-1)*ddesc.u1.lPitch);
848               dBottomRight = dBottomLeft+((dstwidth-1)*bpp);
849
850               if (lpbltfx->dwDDFX & DDBLTFX_ARITHSTRETCHY){
851                  /* I don't think we need to do anything about this flag */
852                  WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ARITHSTRETCHY\n");
853               }
854               if (lpbltfx->dwDDFX & DDBLTFX_MIRRORLEFTRIGHT) {
855                  tmp          = dTopRight;
856                  dTopRight    = dTopLeft;
857                  dTopLeft     = tmp;
858                  tmp          = dBottomRight;
859                  dBottomRight = dBottomLeft;
860                  dBottomLeft  = tmp;
861                  dstxinc = dstxinc *-1;
862               }
863               if (lpbltfx->dwDDFX & DDBLTFX_MIRRORUPDOWN) {
864                  tmp          = dTopLeft;
865                  dTopLeft     = dBottomLeft;
866                  dBottomLeft  = tmp;
867                  tmp          = dTopRight;
868                  dTopRight    = dBottomRight;
869                  dBottomRight = tmp;
870                  dstyinc = dstyinc *-1;
871               }
872               if (lpbltfx->dwDDFX & DDBLTFX_NOTEARING) {
873                  /* I don't think we need to do anything about this flag */
874                  WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_NOTEARING\n");
875               }
876               if (lpbltfx->dwDDFX & DDBLTFX_ROTATE180) {
877                  tmp          = dBottomRight;
878                  dBottomRight = dTopLeft;
879                  dTopLeft     = tmp;
880                  tmp          = dBottomLeft;
881                  dBottomLeft  = dTopRight;
882                  dTopRight    = tmp;
883                  dstxinc = dstxinc * -1;
884                  dstyinc = dstyinc * -1;
885               }
886               if (lpbltfx->dwDDFX & DDBLTFX_ROTATE270) {
887                  tmp          = dTopLeft;
888                  dTopLeft     = dBottomLeft;
889                  dBottomLeft  = dBottomRight;
890                  dBottomRight = dTopRight;
891                  dTopRight    = tmp;
892                  tmpxy   = dstxinc;
893                  dstxinc = dstyinc;
894                  dstyinc = tmpxy;
895                  dstxinc = dstxinc * -1;
896               }
897               if (lpbltfx->dwDDFX & DDBLTFX_ROTATE90) {
898                  tmp          = dTopLeft;
899                  dTopLeft     = dTopRight;
900                  dTopRight    = dBottomRight;
901                  dBottomRight = dBottomLeft;
902                  dBottomLeft  = tmp;
903                  tmpxy   = dstxinc;
904                  dstxinc = dstyinc;
905                  dstyinc = tmpxy;
906                  dstyinc = dstyinc * -1;
907               }
908               if (lpbltfx->dwDDFX & DDBLTFX_ZBUFFERBASEDEST) {
909                  /* I don't think we need to do anything about this flag */
910                  WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ZBUFFERBASEDEST\n");
911               }
912               dbuf = dTopLeft;
913               dwFlags &= ~(DDBLT_DDFX);
914            }
915
916 #define COPY_COLORKEY_FX(type) { \
917             type *s, *d = (type *) dbuf, *dx, tmp; \
918             for (y = sy = 0; y < dstheight; y++, sy += yinc) { \
919                s = (type*)(sbase + (sy >> 16) * sdesc.u1.lPitch); \
920                dx = d; \
921                for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
922                   tmp = s[sx >> 16]; \
923                   if (tmp < keylow || tmp > keyhigh) dx[0] = tmp; \
924                   dx = (type*)(((LPBYTE)dx)+dstxinc); \
925                } \
926                d = (type*)(((LPBYTE)d)+dstyinc); \
927             } \
928             break; }
929
930             switch (bpp) {
931             case 1: COPY_COLORKEY_FX(BYTE)
932             case 2: COPY_COLORKEY_FX(WORD)
933             case 4: COPY_COLORKEY_FX(DWORD)
934             case 3: {LPBYTE s,d = dbuf, dx;
935                 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
936                     sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
937                     dx = d;
938                     for (x = sx = 0; x < dstwidth; x++, sx+= xinc) {
939                         DWORD pixel;
940                         s = sbuf+3*(sx>>16);
941                         pixel = s[0]|(s[1]<<8)|(s[2]<<16);
942                         if (pixel < keylow || pixel > keyhigh){
943                             dx[0] = (pixel    )&0xff;
944                             dx[1] = (pixel>> 8)&0xff;
945                             dx[2] = (pixel>>16)&0xff;
946                         }
947                         dx+= dstxinc;
948                     }
949                     d += dstyinc;
950                 }
951                 break;}
952             default:
953                FIXME("%s color-keyed blit not implemented for bpp %d!\n",
954                   (dwFlags & DDBLT_KEYSRC) ? "Source" : "Destination", bpp*8);
955                   ret = DDERR_UNSUPPORTED;
956                   goto error;
957 #undef COPY_COLORKEY_FX
958             }
959         }
960     }
961
962 error:
963     if (dwFlags && FIXME_ON(ddraw)) {
964         FIXME("\tUnsupported flags: ");
965         DDRAW_dump_DDBLT(dwFlags);
966     }
967
968 release:
969     IDirectDrawSurface7_Unlock(iface,NULL);
970     if (src && src != iface) IDirectDrawSurface7_Unlock(src,NULL);
971     return ret;
972 }
973
974 /* BltBatch: generic, unimplemented */
975
976 HRESULT WINAPI
977 DIB_DirectDrawSurface_BltFast(LPDIRECTDRAWSURFACE7 iface, DWORD dstx,
978                               DWORD dsty, LPDIRECTDRAWSURFACE7 src,
979                               LPRECT rsrc, DWORD trans)
980 {
981     IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
982     int                 bpp, w, h, x, y;
983     DDSURFACEDESC2      ddesc,sdesc;
984     HRESULT             ret = DD_OK;
985     LPBYTE              sbuf, dbuf;
986     RECT                rsrc2;
987     RECT                lock_src, lock_dst, lock_union;
988
989     if (TRACE_ON(ddraw)) {
990         TRACE("(%p)->(%ld,%ld,%p,%p,%08lx)\n",
991                 This,dstx,dsty,src,rsrc,trans
992         );
993         TRACE("\ttrans:");
994         if (FIXME_ON(ddraw))
995           DDRAW_dump_DDBLTFAST(trans);
996         if (rsrc)
997           TRACE("\tsrcrect: %ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
998         else
999           TRACE(" srcrect: NULL\n");
1000     }
1001
1002     if ((This->locked) || ((src != NULL) && (((IDirectDrawSurfaceImpl *)src)->locked))) {
1003         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
1004         return DDERR_SURFACEBUSY;
1005     }
1006
1007     /* First, check if the possible override function handles this case */
1008     if (This->aux_bltfast != NULL) {
1009         if (This->aux_bltfast(This, dstx, dsty, src, rsrc, trans) == DD_OK) return DD_OK;
1010     }
1011
1012     /* Get the surface description without locking to first compute the width / height */
1013     ddesc = This->surface_desc;
1014     sdesc = (ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, src))->surface_desc;
1015
1016     if (!rsrc) {
1017         WARN("rsrc is NULL!\n");
1018         rsrc = &rsrc2;
1019         rsrc->left = rsrc->top = 0;
1020         rsrc->right = sdesc.dwWidth;
1021         rsrc->bottom = sdesc.dwHeight;
1022     }
1023
1024     /* Check source rect for validity. Copied from normal Blt. Fixes Baldur's Gate.*/
1025     if ((rsrc->bottom > sdesc.dwHeight) || (rsrc->bottom < 0) ||
1026         (rsrc->top > sdesc.dwHeight) || (rsrc->top < 0) ||
1027         (rsrc->left > sdesc.dwWidth) || (rsrc->left < 0) ||
1028         (rsrc->right > sdesc.dwWidth) || (rsrc->right < 0) ||
1029         (rsrc->right < rsrc->left) || (rsrc->bottom < rsrc->top)) {
1030         WARN("Application gave us bad source rectangle for BltFast.\n");
1031         return DDERR_INVALIDRECT;
1032     }
1033  
1034     h=rsrc->bottom-rsrc->top;
1035     if (h>ddesc.dwHeight-dsty) h=ddesc.dwHeight-dsty;
1036     if (h>sdesc.dwHeight-rsrc->top) h=sdesc.dwHeight-rsrc->top;
1037     if (h<=0) return DDERR_INVALIDRECT;
1038
1039     w=rsrc->right-rsrc->left;
1040     if (w>ddesc.dwWidth-dstx) w=ddesc.dwWidth-dstx;
1041     if (w>sdesc.dwWidth-rsrc->left) w=sdesc.dwWidth-rsrc->left;
1042     if (w<=0) return DDERR_INVALIDRECT;
1043
1044     /* Now compute the locking rectangle... */
1045     lock_src.left = rsrc->left;
1046     lock_src.top = rsrc->top;
1047     lock_src.right = lock_src.left + w;
1048     lock_src.bottom = lock_src.top + h;
1049
1050     lock_dst.left = dstx;
1051     lock_dst.top = dsty;
1052     lock_dst.right = dstx + w;
1053     lock_dst.bottom = dsty + h;
1054     
1055     bpp = GET_BPP(This->surface_desc);
1056
1057     /* We need to lock the surfaces, or we won't get refreshes when done. */
1058     if (src == iface) {
1059         int pitch;
1060
1061         UnionRect(&lock_union, &lock_src, &lock_dst);
1062
1063         /* Lock the union of the two rectangles */
1064         IDirectDrawSurface7_Lock(iface, &lock_union, &ddesc, 0, 0);
1065
1066         pitch = This->surface_desc.u1.lPitch;
1067
1068         /* Since sdesc was originally copied from this surface's description, we can just reuse it */
1069         sdesc.lpSurface = (BYTE *)This->surface_desc.lpSurface + lock_src.top * pitch + lock_src.left * bpp; 
1070         ddesc.lpSurface = (BYTE *)This->surface_desc.lpSurface + lock_dst.top * pitch + lock_dst.left * bpp; 
1071     } else {
1072         sdesc.dwSize = sizeof(sdesc);
1073         IDirectDrawSurface7_Lock(src, &lock_src, &sdesc, DDLOCK_READONLY, 0);
1074         ddesc.dwSize = sizeof(ddesc);
1075         IDirectDrawSurface7_Lock(iface, &lock_dst, &ddesc, DDLOCK_WRITEONLY, 0);
1076     }
1077
1078     /* Handle first the FOURCC surfaces... */
1079     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) && (ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)) {
1080         if (trans)
1081             FIXME("trans arg not supported when a FOURCC surface is involved\n");
1082         if (dstx || dsty)
1083             FIXME("offset for destination surface is not supported\n");
1084         if (sdesc.u4.ddpfPixelFormat.dwFourCC != sdesc.u4.ddpfPixelFormat.dwFourCC) {
1085             FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
1086             ret = DDERR_INVALIDPIXELFORMAT;
1087             goto error;
1088         }
1089         memcpy(ddesc.lpSurface, sdesc.lpSurface, ddesc.u1.dwLinearSize);
1090         goto error;
1091     }
1092     if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
1093         (!(ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC))) {
1094         DoDXTCDecompression(&sdesc, &ddesc);
1095         goto error;
1096     }
1097     
1098     sbuf = (BYTE *) sdesc.lpSurface;
1099     dbuf = (BYTE *) ddesc.lpSurface;
1100     
1101     if (trans & (DDBLTFAST_SRCCOLORKEY | DDBLTFAST_DESTCOLORKEY)) {
1102         DWORD keylow, keyhigh;
1103         if (trans & DDBLTFAST_SRCCOLORKEY) {
1104             keylow  = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
1105             keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
1106         } else {
1107             /* I'm not sure if this is correct */
1108             FIXME("DDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
1109             keylow  = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
1110             keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
1111         }
1112
1113 #define COPYBOX_COLORKEY(type) { \
1114             type *d, *s, tmp; \
1115             s = (type *) sdesc.lpSurface; \
1116             d = (type *) ddesc.lpSurface; \
1117             for (y = 0; y < h; y++) { \
1118                 for (x = 0; x < w; x++) { \
1119                     tmp = s[x]; \
1120                     if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1121                 } \
1122                 s = (type *)((BYTE *)s + sdesc.u1.lPitch); \
1123                 d = (type *)((BYTE *)d + ddesc.u1.lPitch); \
1124             } \
1125             break; \
1126         }
1127
1128         switch (bpp) {
1129             case 1: COPYBOX_COLORKEY(BYTE)
1130             case 2: COPYBOX_COLORKEY(WORD)
1131             case 4: COPYBOX_COLORKEY(DWORD)
1132             case 3:
1133             {
1134                 BYTE *d, *s;
1135                 DWORD tmp;
1136                 s = (BYTE *) sdesc.lpSurface;
1137                 d = (BYTE *) ddesc.lpSurface;
1138                 for (y = 0; y < h; y++) {
1139                     for (x = 0; x < w * 3; x += 3) {
1140                         tmp = (DWORD)s[x] + ((DWORD)s[x + 1] << 8) + ((DWORD)s[x + 2] << 16);
1141                         if (tmp < keylow || tmp > keyhigh) {
1142                             d[x + 0] = s[x + 0];
1143                             d[x + 1] = s[x + 1];
1144                             d[x + 2] = s[x + 2];
1145                         }
1146                     }
1147                     s += sdesc.u1.lPitch;
1148                     d += ddesc.u1.lPitch;
1149                 }
1150                 break;
1151             }
1152             default:
1153                 FIXME("Source color key blitting not supported for bpp %d\n",bpp*8);
1154                 ret = DDERR_UNSUPPORTED;
1155                 goto error;
1156         }
1157 #undef COPYBOX_COLORKEY
1158     } else {
1159         int width = w * bpp;
1160
1161         for (y = 0; y < h; y++) {
1162             memcpy(dbuf, sbuf, width);
1163             sbuf += sdesc.u1.lPitch;
1164             dbuf += ddesc.u1.lPitch;
1165         }
1166     }
1167     
1168 error:
1169     if (src == iface) {
1170         IDirectDrawSurface7_Unlock(iface, &lock_union);
1171     } else {
1172         IDirectDrawSurface7_Unlock(iface, &lock_dst);
1173         IDirectDrawSurface7_Unlock(src, &lock_src);
1174     }
1175
1176     return ret;
1177 }
1178
1179 /* ChangeUniquenessValue: generic */
1180 /* DeleteAttachedSurface: generic */
1181 /* EnumAttachedSurfaces: generic */
1182 /* EnumOverlayZOrders: generic, unimplemented */
1183
1184 BOOL DIB_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl* front,
1185                                      IDirectDrawSurfaceImpl* back,
1186                                      DWORD dwFlags)
1187 {
1188     DIB_DirectDrawSurfaceImpl* front_priv = front->private;
1189     DIB_DirectDrawSurfaceImpl* back_priv = back->private;
1190
1191     TRACE("(%p,%p)\n",front,back);
1192
1193     {
1194         HBITMAP tmp;
1195         tmp = front_priv->dib.DIBsection;
1196         front_priv->dib.DIBsection = back_priv->dib.DIBsection;
1197         back_priv->dib.DIBsection = tmp;
1198     }
1199
1200     {
1201         void* tmp;
1202         tmp = front_priv->dib.bitmap_data;
1203         front_priv->dib.bitmap_data = back_priv->dib.bitmap_data;
1204         back_priv->dib.bitmap_data = tmp;
1205
1206         tmp = front->surface_desc.lpSurface;
1207         front->surface_desc.lpSurface = back->surface_desc.lpSurface;
1208         back->surface_desc.lpSurface = tmp;
1209     }
1210
1211     /* client_memory should not be different, but just in case */
1212     {
1213         BOOL tmp;
1214         tmp = front_priv->dib.client_memory;
1215         front_priv->dib.client_memory = back_priv->dib.client_memory;
1216         back_priv->dib.client_memory = tmp;
1217     }
1218
1219     return Main_DirectDrawSurface_flip_data(front, back, dwFlags);
1220 }
1221
1222 /* Flip: generic */
1223 /* FreePrivateData: generic */
1224 /* GetAttachedSurface: generic */
1225 /* GetBltStatus: generic */
1226 /* GetCaps: generic (Returns the caps from This->surface_desc.) */
1227 /* GetClipper: generic */
1228 /* GetColorKey: generic */
1229
1230 HRESULT DIB_DirectDrawSurface_alloc_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
1231 {
1232     DIB_PRIV_VAR(priv, This);
1233     HDC hDC;
1234
1235     TRACE("Grabbing a DC for surface: %p\n", This);
1236
1237     hDC = CreateCompatibleDC(0);
1238     priv->dib.holdbitmap = SelectObject(hDC, priv->dib.DIBsection);
1239     if (This->palette)
1240         SelectPalette(hDC, This->palette->hpal, FALSE);
1241
1242     *phDC = hDC;
1243
1244     return S_OK;
1245 }
1246
1247 HRESULT DIB_DirectDrawSurface_free_dc(IDirectDrawSurfaceImpl* This, HDC hDC)
1248 {
1249     DIB_PRIV_VAR(priv, This);
1250
1251     TRACE("Releasing DC for surface: %p\n", This);
1252
1253     SelectObject(hDC, priv->dib.holdbitmap);
1254     DeleteDC(hDC);
1255
1256     return S_OK;
1257 }
1258
1259 HRESULT DIB_DirectDrawSurface_get_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
1260 {
1261     return DIB_DirectDrawSurface_alloc_dc(This, phDC);
1262 }
1263
1264 HRESULT DIB_DirectDrawSurface_release_dc(IDirectDrawSurfaceImpl* This, HDC hDC)
1265 {
1266     return DIB_DirectDrawSurface_free_dc(This, hDC);
1267 }
1268
1269 /* GetDDInterface: generic */
1270 /* GetFlipStatus: generic */
1271 /* GetLOD: generic */
1272 /* GetOverlayPosition: generic */
1273 /* GetPalette: generic */
1274 /* GetPixelFormat: generic */
1275 /* GetPriority: generic */
1276 /* GetPrivateData: generic */
1277 /* GetSurfaceDesc: generic */
1278 /* GetUniquenessValue: generic */
1279 /* Initialize: generic */
1280 /* IsLost: generic */
1281 /* Lock: generic with callback? */
1282 /* PageLock: generic */
1283 /* PageUnlock: generic */
1284
1285 HRESULT WINAPI
1286 DIB_DirectDrawSurface_Restore(LPDIRECTDRAWSURFACE7 iface)
1287 {
1288     TRACE("(%p)\n",iface);
1289     return DD_OK;       /* ??? */
1290 }
1291
1292 /* SetClipper: generic */
1293 /* SetColorKey: generic */
1294 /* SetLOD: generic */
1295 /* SetOverlayPosition: generic */
1296
1297 void DIB_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl* This,
1298                                        IDirectDrawPaletteImpl* pal)
1299 {
1300     if (!pal) return;
1301     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1302         This->update_palette(This, pal,
1303                              0, pal->palNumEntries,
1304                              pal->palents);
1305 }
1306
1307 void DIB_DirectDrawSurface_update_palette(IDirectDrawSurfaceImpl* This,
1308                                           IDirectDrawPaletteImpl* pal,
1309                                           DWORD dwStart, DWORD dwCount,
1310                                           LPPALETTEENTRY palent)
1311 {
1312     RGBQUAD col[256];
1313     unsigned int n;
1314     HDC dc;
1315
1316     TRACE("updating primary palette\n");
1317     for (n=0; n<dwCount; n++) {
1318       col[n].rgbRed   = palent[n].peRed;
1319       col[n].rgbGreen = palent[n].peGreen;
1320       col[n].rgbBlue  = palent[n].peBlue;
1321       col[n].rgbReserved = 0;
1322     }
1323     This->get_dc(This, &dc);
1324     SetDIBColorTable(dc, dwStart, dwCount, col);
1325     This->release_dc(This, dc);
1326
1327     /* Propagate change to backbuffers if there are any */
1328     /* Basically this is a modification of the Flip code to find the backbuffer */
1329     /* and duplicate the palette update there as well */
1330     if ((This->surface_desc.ddsCaps.dwCaps&(DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
1331         == (DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
1332     {
1333         static DDSCAPS2 back_caps = { DDSCAPS_BACKBUFFER };
1334         LPDIRECTDRAWSURFACE7 tgt;
1335
1336         HRESULT hr = IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(This,IDirectDrawSurface7),
1337                                                             &back_caps, &tgt);
1338         if (!FAILED(hr))
1339         {
1340             IDirectDrawSurfaceImpl* target = ICOM_OBJECT(IDirectDrawSurfaceImpl,
1341                                                          IDirectDrawSurface7,tgt);
1342             IDirectDrawSurface7_Release(tgt);
1343             target->get_dc(target, &dc);
1344             SetDIBColorTable(dc, dwStart, dwCount, col);
1345             target->release_dc(target, dc);
1346         }
1347     }
1348 }
1349
1350 /* SetPalette: generic */
1351 /* SetPriority: generic */
1352 /* SetPrivateData: generic */
1353
1354 HRESULT WINAPI
1355 DIB_DirectDrawSurface_SetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
1356                                      LPDDSURFACEDESC2 pDDSD, DWORD dwFlags)
1357 {
1358     IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
1359     DIB_PRIV_VAR(priv, This);
1360     HRESULT hr = DD_OK;
1361     DWORD flags = pDDSD->dwFlags;
1362
1363     if (TRACE_ON(ddraw)) {
1364         TRACE("(%p)->(%p,%08lx)\n",iface,pDDSD,dwFlags);
1365         DDRAW_dump_surface_desc(pDDSD);
1366     }
1367
1368     if (pDDSD->dwFlags & DDSD_PIXELFORMAT) {
1369         flags &= ~DDSD_PIXELFORMAT;
1370         if (flags & DDSD_LPSURFACE) {
1371             This->surface_desc.u4.ddpfPixelFormat = pDDSD->u4.ddpfPixelFormat;
1372         } else {
1373             FIXME("Change of pixel format without surface re-allocation is not supported !\n");
1374         }
1375     }
1376     if (pDDSD->dwFlags & DDSD_LPSURFACE) {
1377         HBITMAP oldbmp = priv->dib.DIBsection;
1378         LPVOID oldsurf = This->surface_desc.lpSurface;
1379         BOOL oldc = priv->dib.client_memory;
1380
1381         flags &= ~DDSD_LPSURFACE;
1382
1383         TRACE("new lpSurface=%p\n",pDDSD->lpSurface);
1384         This->surface_desc.lpSurface = pDDSD->lpSurface;
1385         priv->dib.client_memory = TRUE;
1386
1387         hr = create_dib(This);
1388         if (FAILED(hr))
1389         {
1390             priv->dib.DIBsection = oldbmp;
1391             This->surface_desc.lpSurface = oldsurf;
1392             priv->dib.client_memory = oldc;
1393             return hr;
1394         }
1395
1396         DeleteObject(oldbmp);
1397
1398         if (!oldc)
1399             VirtualFree(oldsurf, 0, MEM_RELEASE);
1400     }
1401     if (flags) {
1402         WARN("Unhandled flags : %08lx\n", flags);
1403     }
1404     return hr;
1405 }
1406
1407 /* Unlock: ???, need callback */
1408 /* UpdateOverlay: generic */
1409 /* UpdateOverlayDisplay: generic */
1410 /* UpdateOverlayZOrder: generic */
1411
1412 static const IDirectDrawSurface7Vtbl DIB_IDirectDrawSurface7_VTable =
1413 {
1414     Main_DirectDrawSurface_QueryInterface,
1415     Main_DirectDrawSurface_AddRef,
1416     Main_DirectDrawSurface_Release,
1417     Main_DirectDrawSurface_AddAttachedSurface,
1418     Main_DirectDrawSurface_AddOverlayDirtyRect,
1419     DIB_DirectDrawSurface_Blt,
1420     Main_DirectDrawSurface_BltBatch,
1421     DIB_DirectDrawSurface_BltFast,
1422     Main_DirectDrawSurface_DeleteAttachedSurface,
1423     Main_DirectDrawSurface_EnumAttachedSurfaces,
1424     Main_DirectDrawSurface_EnumOverlayZOrders,
1425     Main_DirectDrawSurface_Flip,
1426     Main_DirectDrawSurface_GetAttachedSurface,
1427     Main_DirectDrawSurface_GetBltStatus,
1428     Main_DirectDrawSurface_GetCaps,
1429     Main_DirectDrawSurface_GetClipper,
1430     Main_DirectDrawSurface_GetColorKey,
1431     Main_DirectDrawSurface_GetDC,
1432     Main_DirectDrawSurface_GetFlipStatus,
1433     Main_DirectDrawSurface_GetOverlayPosition,
1434     Main_DirectDrawSurface_GetPalette,
1435     Main_DirectDrawSurface_GetPixelFormat,
1436     Main_DirectDrawSurface_GetSurfaceDesc,
1437     Main_DirectDrawSurface_Initialize,
1438     Main_DirectDrawSurface_IsLost,
1439     Main_DirectDrawSurface_Lock,
1440     Main_DirectDrawSurface_ReleaseDC,
1441     DIB_DirectDrawSurface_Restore,
1442     Main_DirectDrawSurface_SetClipper,
1443     Main_DirectDrawSurface_SetColorKey,
1444     Main_DirectDrawSurface_SetOverlayPosition,
1445     Main_DirectDrawSurface_SetPalette,
1446     Main_DirectDrawSurface_Unlock,
1447     Main_DirectDrawSurface_UpdateOverlay,
1448     Main_DirectDrawSurface_UpdateOverlayDisplay,
1449     Main_DirectDrawSurface_UpdateOverlayZOrder,
1450     Main_DirectDrawSurface_GetDDInterface,
1451     Main_DirectDrawSurface_PageLock,
1452     Main_DirectDrawSurface_PageUnlock,
1453     DIB_DirectDrawSurface_SetSurfaceDesc,
1454     Main_DirectDrawSurface_SetPrivateData,
1455     Main_DirectDrawSurface_GetPrivateData,
1456     Main_DirectDrawSurface_FreePrivateData,
1457     Main_DirectDrawSurface_GetUniquenessValue,
1458     Main_DirectDrawSurface_ChangeUniquenessValue,
1459     Main_DirectDrawSurface_SetPriority,
1460     Main_DirectDrawSurface_GetPriority,
1461     Main_DirectDrawSurface_SetLOD,
1462     Main_DirectDrawSurface_GetLOD
1463 };