1 /* DIBSection DirectDrawSurface driver
3 * Copyright 1997-2000 Marcus Meissner
4 * Copyright 1998-2000 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
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.
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.
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
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
32 #include "wine/debug.h"
33 #include "ddraw_private.h"
34 #include "dsurface/main.h"
35 #include "dsurface/dib.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(ddraw
);
39 static ICOM_VTABLE(IDirectDrawSurface7
) DIB_IDirectDrawSurface7_VTable
;
41 /* Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned. */
42 inline static int get_dib_width_bytes( int width
, int depth
)
48 case 1: words
= (width
+ 31) / 32; break;
49 case 4: words
= (width
+ 7) / 8; break;
50 case 8: words
= (width
+ 3) / 4; break;
52 case 16: words
= (width
+ 1) / 2; break;
53 case 24: words
= (width
* 3 + 3)/4; break;
55 WARN("(%d): Unsupported depth\n", depth
);
57 case 32: words
= width
; break;
63 static HRESULT
create_dib(IDirectDrawSurfaceImpl
* This
)
68 DIB_DirectDrawSurfaceImpl
* priv
= This
->private;
70 assert(This
->surface_desc
.lpSurface
!= NULL
);
72 switch (This
->surface_desc
.u4
.ddpfPixelFormat
.u1
.dwRGBBitCount
)
76 /* Allocate extra space to store the RGB bit masks. */
77 b_info
= (BITMAPINFO
*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
78 sizeof(BITMAPINFOHEADER
)
83 b_info
= (BITMAPINFO
*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
84 sizeof(BITMAPINFOHEADER
));
88 /* Allocate extra space for a palette. */
89 b_info
= (BITMAPINFO
*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
90 sizeof(BITMAPINFOHEADER
)
92 * (1 << This
->surface_desc
.u4
.ddpfPixelFormat
.u1
.dwRGBBitCount
));
96 b_info
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
97 b_info
->bmiHeader
.biWidth
= This
->surface_desc
.dwWidth
;
98 b_info
->bmiHeader
.biHeight
= -This
->surface_desc
.dwHeight
;
99 b_info
->bmiHeader
.biPlanes
= 1;
100 b_info
->bmiHeader
.biBitCount
= This
->surface_desc
.u4
.ddpfPixelFormat
.u1
.dwRGBBitCount
;
102 if ((This
->surface_desc
.u4
.ddpfPixelFormat
.u1
.dwRGBBitCount
!= 16)
103 && (This
->surface_desc
.u4
.ddpfPixelFormat
.u1
.dwRGBBitCount
!= 32))
104 b_info
->bmiHeader
.biCompression
= BI_RGB
;
106 b_info
->bmiHeader
.biCompression
= BI_BITFIELDS
;
108 b_info
->bmiHeader
.biSizeImage
109 = (This
->surface_desc
.u4
.ddpfPixelFormat
.u1
.dwRGBBitCount
/ 8)
110 * This
->surface_desc
.dwWidth
* This
->surface_desc
.dwHeight
;
112 b_info
->bmiHeader
.biXPelsPerMeter
= 0;
113 b_info
->bmiHeader
.biYPelsPerMeter
= 0;
114 b_info
->bmiHeader
.biClrUsed
= 0;
115 b_info
->bmiHeader
.biClrImportant
= 0;
117 switch (This
->surface_desc
.u4
.ddpfPixelFormat
.u1
.dwRGBBitCount
)
122 DWORD
*masks
= (DWORD
*) &(b_info
->bmiColors
);
125 masks
[0] = This
->surface_desc
.u4
.ddpfPixelFormat
.u2
.dwRBitMask
;
126 masks
[1] = This
->surface_desc
.u4
.ddpfPixelFormat
.u3
.dwGBitMask
;
127 masks
[2] = This
->surface_desc
.u4
.ddpfPixelFormat
.u4
.dwBBitMask
;
133 usage
= DIB_RGB_COLORS
;
137 /* Don't know palette */
142 ddc
= CreateDCA("DISPLAY", NULL
, NULL
, NULL
);
145 HeapFree(GetProcessHeap(), 0, b_info
);
146 return HRESULT_FROM_WIN32(GetLastError());
150 = DIB_CreateDIBSection(ddc
, b_info
, usage
, &(priv
->dib
.bitmap_data
), 0,
151 (DWORD
)This
->surface_desc
.lpSurface
,
152 This
->surface_desc
.u1
.lPitch
);
154 if (!priv
->dib
.DIBsection
) {
155 ERR("CreateDIBSection failed!\n");
156 HeapFree(GetProcessHeap(), 0, b_info
);
157 return HRESULT_FROM_WIN32(GetLastError());
160 TRACE("DIBSection at : %p\n", priv
->dib
.bitmap_data
);
161 if (!This
->surface_desc
.u1
.lPitch
) {
162 /* This can't happen, right? */
163 /* or use GDI_GetObj to get it from the created DIB? */
164 This
->surface_desc
.u1
.lPitch
= get_dib_width_bytes(b_info
->bmiHeader
.biWidth
, b_info
->bmiHeader
.biBitCount
);
165 This
->surface_desc
.dwFlags
|= DDSD_PITCH
;
168 if (!This
->surface_desc
.lpSurface
) {
169 This
->surface_desc
.lpSurface
= priv
->dib
.bitmap_data
;
170 This
->surface_desc
.dwFlags
|= DDSD_LPSURFACE
;
173 HeapFree(GetProcessHeap(), 0, b_info
);
175 /* I don't think it's worth checking for this. */
176 if (priv
->dib
.bitmap_data
!= This
->surface_desc
.lpSurface
)
177 ERR("unexpected error creating DirectDrawSurface DIB section\n");
179 /* this seems like a good place to put the handle for HAL driver use */
180 This
->global_more
.hKernelSurface
= (ULONG_PTR
)priv
->dib
.DIBsection
;
185 void DIB_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl
* This
)
187 DIB_DirectDrawSurfaceImpl
* priv
= This
->private;
189 DeleteObject(priv
->dib
.DIBsection
);
191 if (!priv
->dib
.client_memory
)
192 VirtualFree(This
->surface_desc
.lpSurface
, 0, MEM_RELEASE
);
194 Main_DirectDrawSurface_final_release(This
);
197 HRESULT
DIB_DirectDrawSurface_duplicate_surface(IDirectDrawSurfaceImpl
* This
,
198 LPDIRECTDRAWSURFACE7
* ppDup
)
200 return DIB_DirectDrawSurface_Create(This
->ddraw_owner
,
201 &This
->surface_desc
, ppDup
, NULL
);
204 HRESULT
DIB_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl
*This
,
205 IDirectDrawImpl
*pDD
,
206 const DDSURFACEDESC2
*pDDSD
)
209 DIB_DirectDrawSurfaceImpl
* priv
= This
->private;
211 TRACE("(%p)->(%p,%p)\n",This
,pDD
,pDDSD
);
212 hr
= Main_DirectDrawSurface_Construct(This
, pDD
, pDDSD
);
213 if (FAILED(hr
)) return hr
;
215 ICOM_INIT_INTERFACE(This
, IDirectDrawSurface7
,
216 DIB_IDirectDrawSurface7_VTable
);
218 This
->final_release
= DIB_DirectDrawSurface_final_release
;
219 This
->duplicate_surface
= DIB_DirectDrawSurface_duplicate_surface
;
220 This
->flip_data
= DIB_DirectDrawSurface_flip_data
;
222 This
->get_dc
= DIB_DirectDrawSurface_get_dc
;
223 This
->release_dc
= DIB_DirectDrawSurface_release_dc
;
226 This
->set_palette
= DIB_DirectDrawSurface_set_palette
;
227 This
->update_palette
= DIB_DirectDrawSurface_update_palette
;
229 TRACE("(%ldx%ld, pitch=%ld)\n",
230 This
->surface_desc
.dwWidth
, This
->surface_desc
.dwHeight
,
231 This
->surface_desc
.u1
.lPitch
);
232 /* XXX load dwWidth and dwHeight from pDD if they are not specified? */
234 if (This
->surface_desc
.dwFlags
& DDSD_LPSURFACE
)
236 /* "Client memory": it is managed by the application. */
237 /* XXX What if lPitch is not set? Use dwWidth or fail? */
239 priv
->dib
.client_memory
= TRUE
;
243 if (!(This
->surface_desc
.dwFlags
& DDSD_PITCH
))
245 int pitch
= This
->surface_desc
.u1
.lPitch
;
247 pitch
+= 8 - (pitch
% 8);
249 /* XXX else: how should lPitch be verified? */
251 This
->surface_desc
.dwFlags
|= DDSD_PITCH
|DDSD_LPSURFACE
;
253 This
->surface_desc
.lpSurface
254 = VirtualAlloc(NULL
, This
->surface_desc
.u1
.lPitch
255 * This
->surface_desc
.dwHeight
+ 4, /* The + 4 here is for dumb games reading after the end of the surface
256 when reading the last byte / half using word access */
257 MEM_RESERVE
| MEM_COMMIT
, PAGE_READWRITE
);
259 if (This
->surface_desc
.lpSurface
== NULL
)
261 Main_DirectDrawSurface_final_release(This
);
262 return HRESULT_FROM_WIN32(GetLastError());
265 priv
->dib
.client_memory
= FALSE
;
268 hr
= create_dib(This
);
271 if (!priv
->dib
.client_memory
)
272 VirtualFree(This
->surface_desc
.lpSurface
, 0, MEM_RELEASE
);
274 Main_DirectDrawSurface_final_release(This
);
283 HRESULT
DIB_DirectDrawSurface_Create(IDirectDrawImpl
*pDD
,
284 const DDSURFACEDESC2
*pDDSD
,
285 LPDIRECTDRAWSURFACE7
*ppSurf
,
288 IDirectDrawSurfaceImpl
* This
;
290 assert(pUnkOuter
== NULL
);
292 This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
293 sizeof(*This
) + sizeof(DIB_DirectDrawSurfaceImpl
));
294 if (This
== NULL
) return E_OUTOFMEMORY
;
296 This
->private = (DIB_DirectDrawSurfaceImpl
*)(This
+1);
298 hr
= DIB_DirectDrawSurface_Construct(This
, pDD
, pDDSD
);
300 HeapFree(GetProcessHeap(), 0, This
);
302 *ppSurf
= ICOM_INTERFACE(This
, IDirectDrawSurface7
);
308 /* AddAttachedSurface: generic */
309 /* AddOverlayDirtyRect: generic, unimplemented */
311 static HRESULT
_Blt_ColorFill(
312 LPBYTE buf
, int width
, int height
, int bpp
, LONG lPitch
, DWORD color
319 #define COLORFILL_ROW(type) { \
320 type *d = (type *) buf; \
321 for (x = 0; x < width; x++) \
322 d[x] = (type) color; \
327 case 1: COLORFILL_ROW(BYTE
)
328 case 2: COLORFILL_ROW(WORD
)
329 case 4: COLORFILL_ROW(DWORD
)
331 FIXME("Color fill not implemented for bpp %d!\n", bpp
*8);
332 return DDERR_UNSUPPORTED
;
337 /* Now copy first row */
339 for (y
= 1; y
< height
; y
++) {
341 memcpy(buf
, first
, width
* bpp
);
347 DIB_DirectDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface
, LPRECT rdst
,
348 LPDIRECTDRAWSURFACE7 src
, LPRECT rsrc
,
349 DWORD dwFlags
, LPDDBLTFX lpbltfx
)
351 ICOM_THIS(IDirectDrawSurfaceImpl
,iface
);
353 DDSURFACEDESC2 ddesc
,sdesc
;
355 int bpp
, srcheight
, srcwidth
, dstheight
, dstwidth
, width
;
359 TRACE("(%p)->(%p,%p,%p,%08lx,%p)\n", This
,rdst
,src
,rsrc
,dwFlags
,lpbltfx
);
361 if (TRACE_ON(ddraw
)) {
362 if (rdst
) TRACE("\tdestrect :%ldx%ld-%ldx%ld\n",rdst
->left
,rdst
->top
,rdst
->right
,rdst
->bottom
);
363 if (rsrc
) TRACE("\tsrcrect :%ldx%ld-%ldx%ld\n",rsrc
->left
,rsrc
->top
,rsrc
->right
,rsrc
->bottom
);
365 DDRAW_dump_DDBLT(dwFlags
);
366 if (dwFlags
& DDBLT_DDFX
) {
368 DDRAW_dump_DDBLTFX(lpbltfx
->dwDDFX
);
372 /* First, check if the possible override function handles this case */
373 if (This
->aux_blt
!= NULL
) {
374 if (This
->aux_blt(This
, rdst
, src
, rsrc
, dwFlags
, lpbltfx
) == DD_OK
) return DD_OK
;
377 DD_STRUCT_INIT(&ddesc
);
378 DD_STRUCT_INIT(&sdesc
);
380 sdesc
.dwSize
= sizeof(sdesc
);
381 if (src
) IDirectDrawSurface7_Lock(src
, NULL
, &sdesc
, DDLOCK_READONLY
, 0);
382 ddesc
.dwSize
= sizeof(ddesc
);
383 IDirectDrawSurface7_Lock(iface
,NULL
,&ddesc
,DDLOCK_WRITEONLY
,0);
386 memcpy(&xdst
,rdst
,sizeof(xdst
));
389 xdst
.bottom
= ddesc
.dwHeight
;
391 xdst
.right
= ddesc
.dwWidth
;
395 memcpy(&xsrc
,rsrc
,sizeof(xsrc
));
399 xsrc
.bottom
= sdesc
.dwHeight
;
401 xsrc
.right
= sdesc
.dwWidth
;
403 memset(&xsrc
,0,sizeof(xsrc
));
407 /* First check for the validity of source / destination rectangles. This was
408 verified using a test application + by MSDN.
411 ((xsrc
.bottom
> sdesc
.dwHeight
) || (xsrc
.bottom
< 0) ||
412 (xsrc
.top
> sdesc
.dwHeight
) || (xsrc
.top
< 0) ||
413 (xsrc
.left
> sdesc
.dwWidth
) || (xsrc
.left
< 0) ||
414 (xsrc
.right
> sdesc
.dwWidth
) || (xsrc
.right
< 0) ||
415 (xsrc
.right
< xsrc
.left
) || (xsrc
.bottom
< xsrc
.top
))) {
416 WARN("Application gave us bad source rectangle for Blt.\n");
417 return DDERR_INVALIDRECT
;
419 /* For the Destination rect, it can be out of bounds on the condition that a clipper
420 is set for the given surface.
422 if ((This
->clipper
== NULL
) &&
423 ((xdst
.bottom
> ddesc
.dwHeight
) || (xdst
.bottom
< 0) ||
424 (xdst
.top
> ddesc
.dwHeight
) || (xdst
.top
< 0) ||
425 (xdst
.left
> ddesc
.dwWidth
) || (xdst
.left
< 0) ||
426 (xdst
.right
> ddesc
.dwWidth
) || (xdst
.right
< 0) ||
427 (xdst
.right
< xdst
.left
) || (xdst
.bottom
< xdst
.top
))) {
428 WARN("Application gave us bad destination rectangle for Blt without a clipper set.\n");
429 return DDERR_INVALIDRECT
;
432 /* Now handle negative values in the rectangles. Warning: only supported for now
433 in the 'simple' cases (ie not in any stretching / rotation cases).
435 First, the case where nothing is to be done.
437 if (((xdst
.bottom
<= 0) || (xdst
.right
<= 0) || (xdst
.top
>= (int) ddesc
.dwHeight
) || (xdst
.left
>= (int) ddesc
.dwWidth
)) ||
439 ((xsrc
.bottom
<= 0) || (xsrc
.right
<= 0) || (xsrc
.top
>= (int) sdesc
.dwHeight
) || (xsrc
.left
>= (int) sdesc
.dwWidth
))))
441 TRACE("Nothing to be done !\n");
445 /* The easy case : the source-less blits.... */
448 RECT temp_rect
; /* No idea if intersect rect can be the same as one of the source rect */
452 full_rect
.right
= ddesc
.dwWidth
;
453 full_rect
.bottom
= ddesc
.dwHeight
;
454 IntersectRect(&temp_rect
, &full_rect
, &xdst
);
457 /* Only handle clipping on the destination rectangle */
458 int clip_horiz
= (xdst
.left
< 0) || (xdst
.right
> (int) ddesc
.dwWidth
);
459 int clip_vert
= (xdst
.top
< 0) || (xdst
.bottom
> (int) ddesc
.dwHeight
);
460 if (clip_vert
|| clip_horiz
) {
461 /* Now check if this is a special case or not... */
462 if ((((xdst
.bottom
- xdst
.top
) != (xsrc
.bottom
- xsrc
.top
)) && clip_vert
) ||
463 (((xdst
.right
- xdst
.left
) != (xsrc
.right
- xsrc
.left
)) && clip_horiz
) ||
464 (dwFlags
& DDBLT_DDFX
)) {
465 WARN("Out of screen rectangle in special case. Not handled right now.\n");
470 if (xdst
.left
< 0) { xsrc
.left
-= xdst
.left
; xdst
.left
= 0; }
471 if (xdst
.right
> ddesc
.dwWidth
) { xsrc
.right
-= (xdst
.right
- (int) ddesc
.dwWidth
); xdst
.right
= (int) ddesc
.dwWidth
; }
474 if (xdst
.top
< 0) { xsrc
.top
-= xdst
.top
; xdst
.top
= 0; }
475 if (xdst
.bottom
> ddesc
.dwHeight
) { xsrc
.bottom
-= (xdst
.bottom
- (int) ddesc
.dwHeight
); xdst
.bottom
= (int) ddesc
.dwHeight
; }
477 /* And check if after clipping something is still to be done... */
478 if ((xdst
.bottom
<= 0) || (xdst
.right
<= 0) || (xdst
.top
>= (int) ddesc
.dwHeight
) || (xdst
.left
>= (int) ddesc
.dwWidth
) ||
479 (xsrc
.bottom
<= 0) || (xsrc
.right
<= 0) || (xsrc
.top
>= (int) sdesc
.dwHeight
) || (xsrc
.left
>= (int) sdesc
.dwWidth
)) {
480 TRACE("Nothing to be done after clipping !\n");
486 bpp
= GET_BPP(ddesc
);
487 srcheight
= xsrc
.bottom
- xsrc
.top
;
488 srcwidth
= xsrc
.right
- xsrc
.left
;
489 dstheight
= xdst
.bottom
- xdst
.top
;
490 dstwidth
= xdst
.right
- xdst
.left
;
491 width
= (xdst
.right
- xdst
.left
) * bpp
;
493 assert(width
<= ddesc
.u1
.lPitch
);
495 dbuf
= (BYTE
*)ddesc
.lpSurface
+(xdst
.top
*ddesc
.u1
.lPitch
)+(xdst
.left
*bpp
);
497 if (dwFlags
& (DDBLT_WAIT
|DDBLT_ASYNC
))
499 static BOOL displayed
= FALSE
;
502 FIXME("dwFlags DDBLT_WAIT and/or DDBLT_ASYNC: can't handle right now.\n");
505 dwFlags
&= ~(DDBLT_WAIT
|DDBLT_ASYNC
);
508 /* First, all the 'source-less' blits */
509 if (dwFlags
& DDBLT_COLORFILL
) {
510 ret
= _Blt_ColorFill(dbuf
, dstwidth
, dstheight
, bpp
,
511 ddesc
.u1
.lPitch
, lpbltfx
->u5
.dwFillColor
);
512 dwFlags
&= ~DDBLT_COLORFILL
;
515 if (dwFlags
& DDBLT_DEPTHFILL
)
516 FIXME("DDBLT_DEPTHFILL needs to be implemented!\n");
517 if (dwFlags
& DDBLT_ROP
) {
518 /* Catch some degenerate cases here */
519 switch(lpbltfx
->dwROP
) {
521 ret
= _Blt_ColorFill(dbuf
,dstwidth
,dstheight
,bpp
,ddesc
.u1
.lPitch
,0);
523 case 0xAA0029: /* No-op */
526 ret
= _Blt_ColorFill(dbuf
,dstwidth
,dstheight
,bpp
,ddesc
.u1
.lPitch
,~0);
528 case SRCCOPY
: /* well, we do that below ? */
531 FIXME("Unsupported raster op: %08lx Pattern: %p\n", lpbltfx
->dwROP
, lpbltfx
->u5
.lpDDSPattern
);
534 dwFlags
&= ~DDBLT_ROP
;
536 if (dwFlags
& DDBLT_DDROPS
) {
537 FIXME("\tDdraw Raster Ops: %08lx Pattern: %p\n", lpbltfx
->dwDDROP
, lpbltfx
->u5
.lpDDSPattern
);
539 /* Now the 'with source' blits */
542 int sx
, xinc
, sy
, yinc
;
544 if (!dstwidth
|| !dstheight
) /* hmm... stupid program ? */
546 sbase
= (BYTE
*)sdesc
.lpSurface
+(xsrc
.top
*sdesc
.u1
.lPitch
)+xsrc
.left
*bpp
;
547 xinc
= (srcwidth
<< 16) / dstwidth
;
548 yinc
= (srcheight
<< 16) / dstheight
;
551 /* No effects, we can cheat here */
552 if (dstwidth
== srcwidth
) {
553 if (dstheight
== srcheight
) {
554 /* No stretching in either direction. This needs to be as
555 * fast as possible */
558 /* check for overlapping surfaces */
559 if (src
!= iface
|| xdst
.top
< xsrc
.top
||
560 xdst
.right
<= xsrc
.left
|| xsrc
.right
<= xdst
.left
)
562 /* no overlap, or dst above src, so copy from top downwards */
563 for (y
= 0; y
< dstheight
; y
++)
565 memcpy(dbuf
, sbuf
, width
);
566 sbuf
+= sdesc
.u1
.lPitch
;
567 dbuf
+= ddesc
.u1
.lPitch
;
570 else if (xdst
.top
> xsrc
.top
) /* copy from bottom upwards */
572 sbuf
+= (sdesc
.u1
.lPitch
*dstheight
);
573 dbuf
+= (ddesc
.u1
.lPitch
*dstheight
);
574 for (y
= 0; y
< dstheight
; y
++)
576 sbuf
-= sdesc
.u1
.lPitch
;
577 dbuf
-= ddesc
.u1
.lPitch
;
578 memcpy(dbuf
, sbuf
, width
);
581 else /* src and dst overlapping on the same line, use memmove */
583 for (y
= 0; y
< dstheight
; y
++)
585 memmove(dbuf
, sbuf
, width
);
586 sbuf
+= sdesc
.u1
.lPitch
;
587 dbuf
+= ddesc
.u1
.lPitch
;
591 /* Stretching in Y direction only */
592 for (y
= sy
= 0; y
< dstheight
; y
++, sy
+= yinc
) {
593 sbuf
= sbase
+ (sy
>> 16) * sdesc
.u1
.lPitch
;
594 memcpy(dbuf
, sbuf
, width
);
595 dbuf
+= ddesc
.u1
.lPitch
;
599 /* Stretching in X direction */
601 for (y
= sy
= 0; y
< dstheight
; y
++, sy
+= yinc
) {
602 sbuf
= sbase
+ (sy
>> 16) * sdesc
.u1
.lPitch
;
604 if ((sy
>> 16) == (last_sy
>> 16)) {
605 /* this sourcerow is the same as last sourcerow -
606 * copy already stretched row
608 memcpy(dbuf
, dbuf
- ddesc
.u1
.lPitch
, width
);
610 #define STRETCH_ROW(type) { \
611 type *s = (type *) sbuf, *d = (type *) dbuf; \
612 for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
613 d[x] = s[sx >> 16]; \
617 case 1: STRETCH_ROW(BYTE
)
618 case 2: STRETCH_ROW(WORD
)
619 case 4: STRETCH_ROW(DWORD
)
622 for (x
= sx
= 0; x
< dstwidth
; x
++, sx
+= xinc
) {
626 pixel
= (s
[0]<<16)|(s
[1]<<8)|s
[2];
627 d
[0] = (pixel
>>16)&0xff;
628 d
[1] = (pixel
>> 8)&0xff;
629 d
[2] = (pixel
)&0xff;
635 FIXME("Stretched blit not implemented for bpp %d!\n", bpp
*8);
636 ret
= DDERR_UNSUPPORTED
;
641 dbuf
+= ddesc
.u1
.lPitch
;
646 LONG dstyinc
= ddesc
.u1
.lPitch
, dstxinc
= bpp
;
647 DWORD keylow
= 0, keyhigh
= 0;
648 if (dwFlags
& (DDBLT_KEYSRC
| DDBLT_KEYDEST
| DDBLT_KEYSRCOVERRIDE
| DDBLT_KEYDESTOVERRIDE
)) {
650 if (dwFlags
& DDBLT_KEYSRC
) {
651 keylow
= sdesc
.ddckCKSrcBlt
.dwColorSpaceLowValue
;
652 keyhigh
= sdesc
.ddckCKSrcBlt
.dwColorSpaceHighValue
;
653 } else if (dwFlags
& DDBLT_KEYDEST
){
654 keylow
= ddesc
.ddckCKDestBlt
.dwColorSpaceLowValue
;
655 keyhigh
= ddesc
.ddckCKDestBlt
.dwColorSpaceHighValue
;
656 } else if (dwFlags
& DDBLT_KEYSRCOVERRIDE
) {
657 keylow
= lpbltfx
->ddckSrcColorkey
.dwColorSpaceLowValue
;
658 keyhigh
= lpbltfx
->ddckSrcColorkey
.dwColorSpaceHighValue
;
660 keylow
= lpbltfx
->ddckDestColorkey
.dwColorSpaceLowValue
;
661 keyhigh
= lpbltfx
->ddckDestColorkey
.dwColorSpaceHighValue
;
663 dwFlags
&= ~(DDBLT_KEYSRC
| DDBLT_KEYDEST
| DDBLT_KEYSRCOVERRIDE
| DDBLT_KEYDESTOVERRIDE
);
666 if (dwFlags
& DDBLT_DDFX
) {
667 LPBYTE dTopLeft
, dTopRight
, dBottomLeft
, dBottomRight
, tmp
;
670 dTopRight
= dbuf
+((dstwidth
-1)*bpp
);
671 dBottomLeft
= dTopLeft
+((dstheight
-1)*ddesc
.u1
.lPitch
);
672 dBottomRight
= dBottomLeft
+((dstwidth
-1)*bpp
);
674 if (lpbltfx
->dwDDFX
& DDBLTFX_ARITHSTRETCHY
){
675 /* I don't think we need to do anything about this flag */
676 WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ARITHSTRETCHY\n");
678 if (lpbltfx
->dwDDFX
& DDBLTFX_MIRRORLEFTRIGHT
) {
680 dTopRight
= dTopLeft
;
683 dBottomRight
= dBottomLeft
;
685 dstxinc
= dstxinc
*-1;
687 if (lpbltfx
->dwDDFX
& DDBLTFX_MIRRORUPDOWN
) {
689 dTopLeft
= dBottomLeft
;
692 dTopRight
= dBottomRight
;
694 dstyinc
= dstyinc
*-1;
696 if (lpbltfx
->dwDDFX
& DDBLTFX_NOTEARING
) {
697 /* I don't think we need to do anything about this flag */
698 WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_NOTEARING\n");
700 if (lpbltfx
->dwDDFX
& DDBLTFX_ROTATE180
) {
702 dBottomRight
= dTopLeft
;
705 dBottomLeft
= dTopRight
;
707 dstxinc
= dstxinc
* -1;
708 dstyinc
= dstyinc
* -1;
710 if (lpbltfx
->dwDDFX
& DDBLTFX_ROTATE270
) {
712 dTopLeft
= dBottomLeft
;
713 dBottomLeft
= dBottomRight
;
714 dBottomRight
= dTopRight
;
719 dstxinc
= dstxinc
* -1;
721 if (lpbltfx
->dwDDFX
& DDBLTFX_ROTATE90
) {
723 dTopLeft
= dTopRight
;
724 dTopRight
= dBottomRight
;
725 dBottomRight
= dBottomLeft
;
730 dstyinc
= dstyinc
* -1;
732 if (lpbltfx
->dwDDFX
& DDBLTFX_ZBUFFERBASEDEST
) {
733 /* I don't think we need to do anything about this flag */
734 WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ZBUFFERBASEDEST\n");
737 dwFlags
&= ~(DDBLT_DDFX
);
740 #define COPY_COLORKEY_FX(type) { \
741 type *s = (type *) sbuf, *d = (type *) dbuf, *dx, tmp; \
742 for (y = sy = 0; y < dstheight; y++, sy += yinc) { \
743 (LPBYTE)s = sbase + (sy >> 16) * sdesc.u1.lPitch; \
745 for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
747 if (tmp < keylow || tmp > keyhigh) dx[0] = tmp; \
748 (LPBYTE)dx += dstxinc; \
750 (LPBYTE)d += dstyinc; \
755 case 1: COPY_COLORKEY_FX(BYTE
)
756 case 2: COPY_COLORKEY_FX(WORD
)
757 case 4: COPY_COLORKEY_FX(DWORD
)
758 case 3: {LPBYTE s
,d
= dbuf
, dx
;
759 for (y
= sy
= 0; y
< dstheight
; y
++, sy
+= yinc
) {
760 sbuf
= sbase
+ (sy
>> 16) * sdesc
.u1
.lPitch
;
762 for (x
= sx
= 0; x
< dstwidth
; x
++, sx
+= xinc
) {
765 pixel
= (s
[0]<<16)|(s
[1]<<8)|s
[2];
766 if (pixel
< keylow
|| pixel
> keyhigh
){
767 dx
[0] = (pixel
>>16)&0xff;
768 dx
[1] = (pixel
>> 8)&0xff;
769 dx
[2] = (pixel
)&0xff;
777 FIXME("%s color-keyed blit not implemented for bpp %d!\n",
778 (dwFlags
& DDBLT_KEYSRC
) ? "Source" : "Destination", bpp
*8);
779 ret
= DDERR_UNSUPPORTED
;
781 #undef COPY_COLORKEY_FX
787 if (dwFlags
&& FIXME_ON(ddraw
)) {
788 FIXME("\tUnsupported flags: ");
789 DDRAW_dump_DDBLT(dwFlags
);
793 IDirectDrawSurface7_Unlock(iface
,NULL
);
794 if (src
) IDirectDrawSurface7_Unlock(src
,NULL
);
798 /* BltBatch: generic, unimplemented */
801 DIB_DirectDrawSurface_BltFast(LPDIRECTDRAWSURFACE7 iface
, DWORD dstx
,
802 DWORD dsty
, LPDIRECTDRAWSURFACE7 src
,
803 LPRECT rsrc
, DWORD trans
)
805 ICOM_THIS(IDirectDrawSurfaceImpl
,iface
);
807 DDSURFACEDESC2 ddesc
,sdesc
;
813 if (TRACE_ON(ddraw
)) {
814 FIXME("(%p)->(%ld,%ld,%p,%p,%08lx)\n",
815 This
,dstx
,dsty
,src
,rsrc
,trans
819 DDRAW_dump_DDBLTFAST(trans
);
821 FIXME("\tsrcrect: %ldx%ld-%ldx%ld\n",rsrc
->left
,rsrc
->top
,rsrc
->right
,rsrc
->bottom
);
823 FIXME(" srcrect: NULL\n");
826 /* First, check if the possible override function handles this case */
827 if (This
->aux_bltfast
!= NULL
) {
828 if (This
->aux_bltfast(This
, dstx
, dsty
, src
, rsrc
, trans
) == DD_OK
) return DD_OK
;
831 /* We need to lock the surfaces, or we won't get refreshes when done. */
832 sdesc
.dwSize
= sizeof(sdesc
);
833 IDirectDrawSurface7_Lock(src
, NULL
,&sdesc
,DDLOCK_READONLY
, 0);
834 ddesc
.dwSize
= sizeof(ddesc
);
835 IDirectDrawSurface7_Lock(iface
,NULL
,&ddesc
,DDLOCK_WRITEONLY
,0);
838 WARN("rsrc is NULL!\n");
840 rsrc
->left
= rsrc
->top
= 0;
841 rsrc
->right
= sdesc
.dwWidth
;
842 rsrc
->bottom
= sdesc
.dwHeight
;
845 bpp
= GET_BPP(This
->surface_desc
);
846 sbuf
= (BYTE
*)sdesc
.lpSurface
+(rsrc
->top
*sdesc
.u1
.lPitch
)+rsrc
->left
*bpp
;
847 dbuf
= (BYTE
*)ddesc
.lpSurface
+(dsty
*ddesc
.u1
.lPitch
)+dstx
* bpp
;
850 h
=rsrc
->bottom
-rsrc
->top
;
851 if (h
>ddesc
.dwHeight
-dsty
) h
=ddesc
.dwHeight
-dsty
;
852 if (h
>sdesc
.dwHeight
-rsrc
->top
) h
=sdesc
.dwHeight
-rsrc
->top
;
855 w
=rsrc
->right
-rsrc
->left
;
856 if (w
>ddesc
.dwWidth
-dstx
) w
=ddesc
.dwWidth
-dstx
;
857 if (w
>sdesc
.dwWidth
-rsrc
->left
) w
=sdesc
.dwWidth
-rsrc
->left
;
860 if (trans
& (DDBLTFAST_SRCCOLORKEY
| DDBLTFAST_DESTCOLORKEY
)) {
861 DWORD keylow
, keyhigh
;
862 if (trans
& DDBLTFAST_SRCCOLORKEY
) {
863 keylow
= sdesc
.ddckCKSrcBlt
.dwColorSpaceLowValue
;
864 keyhigh
= sdesc
.ddckCKSrcBlt
.dwColorSpaceHighValue
;
866 /* I'm not sure if this is correct */
867 FIXME("DDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
868 keylow
= ddesc
.ddckCKDestBlt
.dwColorSpaceLowValue
;
869 keyhigh
= ddesc
.ddckCKDestBlt
.dwColorSpaceHighValue
;
872 #define COPYBOX_COLORKEY(type) { \
873 type *d = (type *)dbuf, *s = (type *)sbuf, tmp; \
874 s = (type *) ((BYTE *) sdesc.lpSurface + (rsrc->top * sdesc.u1.lPitch) + rsrc->left * bpp); \
875 d = (type *) ((BYTE *) ddesc.lpSurface + (dsty * ddesc.u1.lPitch) + dstx * bpp); \
876 for (y = 0; y < h; y++) { \
877 for (x = 0; x < w; x++) { \
879 if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
881 (LPBYTE)s += sdesc.u1.lPitch; \
882 (LPBYTE)d += ddesc.u1.lPitch; \
888 case 1: COPYBOX_COLORKEY(BYTE
)
889 case 2: COPYBOX_COLORKEY(WORD
)
890 case 4: COPYBOX_COLORKEY(DWORD
)
892 FIXME("Source color key blitting not supported for bpp %d\n",bpp
*8);
893 ret
= DDERR_UNSUPPORTED
;
896 #undef COPYBOX_COLORKEY
900 for (y
= 0; y
< h
; y
++) {
901 memcpy(dbuf
, sbuf
, width
);
902 sbuf
+= sdesc
.u1
.lPitch
;
903 dbuf
+= ddesc
.u1
.lPitch
;
907 IDirectDrawSurface7_Unlock(iface
, NULL
);
908 IDirectDrawSurface7_Unlock(src
, NULL
);
912 /* ChangeUniquenessValue: generic */
913 /* DeleteAttachedSurface: generic */
914 /* EnumAttachedSurfaces: generic */
915 /* EnumOverlayZOrders: generic, unimplemented */
917 BOOL
DIB_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl
* front
,
918 IDirectDrawSurfaceImpl
* back
,
921 DIB_DirectDrawSurfaceImpl
* front_priv
= front
->private;
922 DIB_DirectDrawSurfaceImpl
* back_priv
= back
->private;
924 TRACE("(%p,%p)\n",front
,back
);
928 tmp
= front_priv
->dib
.DIBsection
;
929 front_priv
->dib
.DIBsection
= back_priv
->dib
.DIBsection
;
930 back_priv
->dib
.DIBsection
= tmp
;
935 tmp
= front_priv
->dib
.bitmap_data
;
936 front_priv
->dib
.bitmap_data
= back_priv
->dib
.bitmap_data
;
937 back_priv
->dib
.bitmap_data
= tmp
;
939 tmp
= front
->surface_desc
.lpSurface
;
940 front
->surface_desc
.lpSurface
= back
->surface_desc
.lpSurface
;
941 back
->surface_desc
.lpSurface
= tmp
;
944 /* client_memory should not be different, but just in case */
947 tmp
= front_priv
->dib
.client_memory
;
948 front_priv
->dib
.client_memory
= back_priv
->dib
.client_memory
;
949 back_priv
->dib
.client_memory
= tmp
;
952 return Main_DirectDrawSurface_flip_data(front
, back
, dwFlags
);
956 /* FreePrivateData: generic */
957 /* GetAttachedSurface: generic */
958 /* GetBltStatus: generic */
959 /* GetCaps: generic (Returns the caps from This->surface_desc.) */
960 /* GetClipper: generic */
961 /* GetColorKey: generic */
963 HRESULT
DIB_DirectDrawSurface_alloc_dc(IDirectDrawSurfaceImpl
* This
, HDC
* phDC
)
965 DIB_PRIV_VAR(priv
, This
);
968 TRACE("Grabbing a DC for surface: %p\n", This
);
970 hDC
= CreateCompatibleDC(0);
971 priv
->dib
.holdbitmap
= SelectObject(hDC
, priv
->dib
.DIBsection
);
973 SelectPalette(hDC
, This
->palette
->hpal
, FALSE
);
980 HRESULT
DIB_DirectDrawSurface_free_dc(IDirectDrawSurfaceImpl
* This
, HDC hDC
)
982 DIB_PRIV_VAR(priv
, This
);
984 TRACE("Releasing DC for surface: %p\n", This
);
986 SelectObject(hDC
, priv
->dib
.holdbitmap
);
992 HRESULT
DIB_DirectDrawSurface_get_dc(IDirectDrawSurfaceImpl
* This
, HDC
* phDC
)
994 return DIB_DirectDrawSurface_alloc_dc(This
, phDC
);
997 HRESULT
DIB_DirectDrawSurface_release_dc(IDirectDrawSurfaceImpl
* This
, HDC hDC
)
999 return DIB_DirectDrawSurface_free_dc(This
, hDC
);
1002 /* GetDDInterface: generic */
1003 /* GetFlipStatus: generic */
1004 /* GetLOD: generic */
1005 /* GetOverlayPosition: generic */
1006 /* GetPalette: generic */
1007 /* GetPixelFormat: generic */
1008 /* GetPriority: generic */
1009 /* GetPrivateData: generic */
1010 /* GetSurfaceDesc: generic */
1011 /* GetUniquenessValue: generic */
1012 /* Initialize: generic */
1013 /* IsLost: generic */
1014 /* Lock: generic with callback? */
1015 /* PageLock: generic */
1016 /* PageUnlock: generic */
1019 DIB_DirectDrawSurface_Restore(LPDIRECTDRAWSURFACE7 iface
)
1021 TRACE("(%p)\n",iface
);
1022 return DD_OK
; /* ??? */
1025 /* SetClipper: generic */
1026 /* SetColorKey: generic */
1027 /* SetLOD: generic */
1028 /* SetOverlayPosition: generic */
1030 void DIB_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl
* This
,
1031 IDirectDrawPaletteImpl
* pal
)
1034 if (This
->surface_desc
.ddsCaps
.dwCaps
& DDSCAPS_PRIMARYSURFACE
)
1035 This
->update_palette(This
, pal
,
1036 0, pal
->palNumEntries
,
1040 void DIB_DirectDrawSurface_update_palette(IDirectDrawSurfaceImpl
* This
,
1041 IDirectDrawPaletteImpl
* pal
,
1042 DWORD dwStart
, DWORD dwCount
,
1043 LPPALETTEENTRY palent
)
1049 TRACE("updating primary palette\n");
1050 for (n
=0; n
<dwCount
; n
++) {
1051 col
[n
].rgbRed
= palent
[n
].peRed
;
1052 col
[n
].rgbGreen
= palent
[n
].peGreen
;
1053 col
[n
].rgbBlue
= palent
[n
].peBlue
;
1054 col
[n
].rgbReserved
= 0;
1056 This
->get_dc(This
, &dc
);
1057 SetDIBColorTable(dc
, dwStart
, dwCount
, col
);
1058 This
->release_dc(This
, dc
);
1060 /* Propagate change to backbuffers if there are any */
1061 /* Basically this is a modification of the Flip code to find the backbuffer */
1062 /* and duplicate the palette update there as well */
1063 if ((This
->surface_desc
.ddsCaps
.dwCaps
&(DDSCAPS_FLIP
|DDSCAPS_FRONTBUFFER
))
1064 == (DDSCAPS_FLIP
|DDSCAPS_FRONTBUFFER
))
1066 static DDSCAPS2 back_caps
= { DDSCAPS_BACKBUFFER
};
1067 LPDIRECTDRAWSURFACE7 tgt
;
1069 HRESULT hr
= IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(This
,IDirectDrawSurface7
),
1073 IDirectDrawSurfaceImpl
* target
= ICOM_OBJECT(IDirectDrawSurfaceImpl
,
1074 IDirectDrawSurface7
,tgt
);
1075 IDirectDrawSurface7_Release(tgt
);
1076 target
->get_dc(target
, &dc
);
1077 SetDIBColorTable(dc
, dwStart
, dwCount
, col
);
1078 target
->release_dc(target
, dc
);
1083 /* SetPalette: generic */
1084 /* SetPriority: generic */
1085 /* SetPrivateData: generic */
1088 DIB_DirectDrawSurface_SetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface
,
1089 LPDDSURFACEDESC2 pDDSD
, DWORD dwFlags
)
1091 ICOM_THIS(IDirectDrawSurfaceImpl
,iface
);
1092 DIB_PRIV_VAR(priv
, This
);
1094 DWORD flags
= pDDSD
->dwFlags
;
1096 if (TRACE_ON(ddraw
)) {
1097 TRACE("(%p)->(%p,%08lx)\n",iface
,pDDSD
,dwFlags
);
1098 DDRAW_dump_surface_desc(pDDSD
);
1101 if (pDDSD
->dwFlags
& DDSD_PIXELFORMAT
) {
1102 flags
&= ~DDSD_PIXELFORMAT
;
1103 if (flags
& DDSD_LPSURFACE
) {
1104 This
->surface_desc
.u4
.ddpfPixelFormat
= pDDSD
->u4
.ddpfPixelFormat
;
1106 FIXME("Change of pixel format without surface re-allocation is not supported !\n");
1109 if (pDDSD
->dwFlags
& DDSD_LPSURFACE
) {
1110 HBITMAP oldbmp
= priv
->dib
.DIBsection
;
1111 LPVOID oldsurf
= This
->surface_desc
.lpSurface
;
1112 BOOL oldc
= priv
->dib
.client_memory
;
1114 flags
&= ~DDSD_LPSURFACE
;
1116 TRACE("new lpSurface=%p\n",pDDSD
->lpSurface
);
1117 This
->surface_desc
.lpSurface
= pDDSD
->lpSurface
;
1118 priv
->dib
.client_memory
= TRUE
;
1120 hr
= create_dib(This
);
1123 priv
->dib
.DIBsection
= oldbmp
;
1124 This
->surface_desc
.lpSurface
= oldsurf
;
1125 priv
->dib
.client_memory
= oldc
;
1129 DeleteObject(oldbmp
);
1132 VirtualFree(oldsurf
, 0, MEM_RELEASE
);
1135 WARN("Unhandled flags : %08lx\n", flags
);
1140 /* Unlock: ???, need callback */
1141 /* UpdateOverlay: generic */
1142 /* UpdateOverlayDisplay: generic */
1143 /* UpdateOverlayZOrder: generic */
1145 static ICOM_VTABLE(IDirectDrawSurface7
) DIB_IDirectDrawSurface7_VTable
=
1147 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1148 Main_DirectDrawSurface_QueryInterface
,
1149 Main_DirectDrawSurface_AddRef
,
1150 Main_DirectDrawSurface_Release
,
1151 Main_DirectDrawSurface_AddAttachedSurface
,
1152 Main_DirectDrawSurface_AddOverlayDirtyRect
,
1153 DIB_DirectDrawSurface_Blt
,
1154 Main_DirectDrawSurface_BltBatch
,
1155 DIB_DirectDrawSurface_BltFast
,
1156 Main_DirectDrawSurface_DeleteAttachedSurface
,
1157 Main_DirectDrawSurface_EnumAttachedSurfaces
,
1158 Main_DirectDrawSurface_EnumOverlayZOrders
,
1159 Main_DirectDrawSurface_Flip
,
1160 Main_DirectDrawSurface_GetAttachedSurface
,
1161 Main_DirectDrawSurface_GetBltStatus
,
1162 Main_DirectDrawSurface_GetCaps
,
1163 Main_DirectDrawSurface_GetClipper
,
1164 Main_DirectDrawSurface_GetColorKey
,
1165 Main_DirectDrawSurface_GetDC
,
1166 Main_DirectDrawSurface_GetFlipStatus
,
1167 Main_DirectDrawSurface_GetOverlayPosition
,
1168 Main_DirectDrawSurface_GetPalette
,
1169 Main_DirectDrawSurface_GetPixelFormat
,
1170 Main_DirectDrawSurface_GetSurfaceDesc
,
1171 Main_DirectDrawSurface_Initialize
,
1172 Main_DirectDrawSurface_IsLost
,
1173 Main_DirectDrawSurface_Lock
,
1174 Main_DirectDrawSurface_ReleaseDC
,
1175 DIB_DirectDrawSurface_Restore
,
1176 Main_DirectDrawSurface_SetClipper
,
1177 Main_DirectDrawSurface_SetColorKey
,
1178 Main_DirectDrawSurface_SetOverlayPosition
,
1179 Main_DirectDrawSurface_SetPalette
,
1180 Main_DirectDrawSurface_Unlock
,
1181 Main_DirectDrawSurface_UpdateOverlay
,
1182 Main_DirectDrawSurface_UpdateOverlayDisplay
,
1183 Main_DirectDrawSurface_UpdateOverlayZOrder
,
1184 Main_DirectDrawSurface_GetDDInterface
,
1185 Main_DirectDrawSurface_PageLock
,
1186 Main_DirectDrawSurface_PageUnlock
,
1187 DIB_DirectDrawSurface_SetSurfaceDesc
,
1188 Main_DirectDrawSurface_SetPrivateData
,
1189 Main_DirectDrawSurface_GetPrivateData
,
1190 Main_DirectDrawSurface_FreePrivateData
,
1191 Main_DirectDrawSurface_GetUniquenessValue
,
1192 Main_DirectDrawSurface_ChangeUniquenessValue
,
1193 Main_DirectDrawSurface_SetPriority
,
1194 Main_DirectDrawSurface_GetPriority
,
1195 Main_DirectDrawSurface_SetLOD
,
1196 Main_DirectDrawSurface_GetLOD