1463 lines
46 KiB
C
1463 lines
46 KiB
C
/* DIBSection DirectDrawSurface driver
|
|
*
|
|
* Copyright 1997-2000 Marcus Meissner
|
|
* Copyright 1998-2000 Lionel Ulmer
|
|
* Copyright 2000-2001 TransGaming Technologies Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#define NONAMELESSUNION
|
|
#define NONAMELESSSTRUCT
|
|
|
|
#include "winerror.h"
|
|
#include "wine/debug.h"
|
|
#include "ddraw_private.h"
|
|
#include "d3d_private.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
|
|
|
|
/* FIXME */
|
|
extern HBITMAP DIB_CreateDIBSection( HDC hdc, const BITMAPINFO *bmi, UINT usage, VOID **bits,
|
|
HANDLE section, DWORD offset, DWORD ovr_pitch );
|
|
|
|
static const IDirectDrawSurface7Vtbl DIB_IDirectDrawSurface7_VTable;
|
|
|
|
/* Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned. */
|
|
inline static int get_dib_width_bytes( int width, int depth )
|
|
{
|
|
int words;
|
|
|
|
switch(depth)
|
|
{
|
|
case 1: words = (width + 31) / 32; break;
|
|
case 4: words = (width + 7) / 8; break;
|
|
case 8: words = (width + 3) / 4; break;
|
|
case 15:
|
|
case 16: words = (width + 1) / 2; break;
|
|
case 24: words = (width * 3 + 3)/4; break;
|
|
default:
|
|
WARN("(%d): Unsupported depth\n", depth );
|
|
/* fall through */
|
|
case 32: words = width; break;
|
|
}
|
|
return 4 * words;
|
|
}
|
|
|
|
|
|
static HRESULT create_dib(IDirectDrawSurfaceImpl* This)
|
|
{
|
|
BITMAPINFO* b_info;
|
|
UINT usage;
|
|
HDC ddc;
|
|
DIB_DirectDrawSurfaceImpl* priv = This->private;
|
|
|
|
assert(This->surface_desc.lpSurface != NULL);
|
|
|
|
switch (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount)
|
|
{
|
|
case 16:
|
|
case 32:
|
|
/* Allocate extra space to store the RGB bit masks. */
|
|
b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD));
|
|
break;
|
|
|
|
case 24:
|
|
b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
sizeof(BITMAPINFOHEADER));
|
|
break;
|
|
|
|
default:
|
|
/* Allocate extra space for a palette. */
|
|
b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
sizeof(BITMAPINFOHEADER)
|
|
+ sizeof(RGBQUAD)
|
|
* (1 << This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount));
|
|
break;
|
|
}
|
|
|
|
b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
b_info->bmiHeader.biWidth = This->surface_desc.dwWidth;
|
|
b_info->bmiHeader.biHeight = -This->surface_desc.dwHeight;
|
|
b_info->bmiHeader.biPlanes = 1;
|
|
b_info->bmiHeader.biBitCount = This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount;
|
|
|
|
if ((This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount != 16)
|
|
&& (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount != 32))
|
|
b_info->bmiHeader.biCompression = BI_RGB;
|
|
else
|
|
b_info->bmiHeader.biCompression = BI_BITFIELDS;
|
|
|
|
b_info->bmiHeader.biSizeImage
|
|
= (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8)
|
|
* This->surface_desc.dwWidth * This->surface_desc.dwHeight;
|
|
|
|
b_info->bmiHeader.biXPelsPerMeter = 0;
|
|
b_info->bmiHeader.biYPelsPerMeter = 0;
|
|
b_info->bmiHeader.biClrUsed = 0;
|
|
b_info->bmiHeader.biClrImportant = 0;
|
|
|
|
if (!This->surface_desc.u1.lPitch) {
|
|
/* This can't happen, right? */
|
|
/* or use GDI_GetObj to get it from the created DIB? */
|
|
This->surface_desc.u1.lPitch = get_dib_width_bytes(b_info->bmiHeader.biWidth, b_info->bmiHeader.biBitCount);
|
|
This->surface_desc.dwFlags |= DDSD_PITCH;
|
|
}
|
|
|
|
switch (This->surface_desc.u4.ddpfPixelFormat.u1.dwRGBBitCount)
|
|
{
|
|
case 16:
|
|
case 32:
|
|
{
|
|
DWORD *masks = (DWORD *) &(b_info->bmiColors);
|
|
|
|
usage = 0;
|
|
masks[0] = This->surface_desc.u4.ddpfPixelFormat.u2.dwRBitMask;
|
|
masks[1] = This->surface_desc.u4.ddpfPixelFormat.u3.dwGBitMask;
|
|
masks[2] = This->surface_desc.u4.ddpfPixelFormat.u4.dwBBitMask;
|
|
}
|
|
break;
|
|
|
|
case 24:
|
|
/* Nothing to do */
|
|
usage = DIB_RGB_COLORS;
|
|
break;
|
|
|
|
default:
|
|
/* Don't know palette */
|
|
usage = 0;
|
|
break;
|
|
}
|
|
|
|
ddc = CreateDCA("DISPLAY", NULL, NULL, NULL);
|
|
if (ddc == 0)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, b_info);
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
priv->dib.DIBsection
|
|
= DIB_CreateDIBSection(ddc, b_info, usage, &(priv->dib.bitmap_data), 0,
|
|
(DWORD)This->surface_desc.lpSurface,
|
|
This->surface_desc.u1.lPitch);
|
|
DeleteDC(ddc);
|
|
if (!priv->dib.DIBsection) {
|
|
ERR("CreateDIBSection failed!\n");
|
|
HeapFree(GetProcessHeap(), 0, b_info);
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
TRACE("DIBSection at : %p\n", priv->dib.bitmap_data);
|
|
|
|
if (!This->surface_desc.lpSurface) {
|
|
This->surface_desc.lpSurface = priv->dib.bitmap_data;
|
|
This->surface_desc.dwFlags |= DDSD_LPSURFACE;
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, b_info);
|
|
|
|
/* I don't think it's worth checking for this. */
|
|
if (priv->dib.bitmap_data != This->surface_desc.lpSurface)
|
|
ERR("unexpected error creating DirectDrawSurface DIB section\n");
|
|
|
|
/* this seems like a good place to put the handle for HAL driver use */
|
|
This->global_more.hKernelSurface = (ULONG_PTR)priv->dib.DIBsection;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void DIB_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl* This)
|
|
{
|
|
DIB_DirectDrawSurfaceImpl* priv = This->private;
|
|
|
|
DeleteObject(priv->dib.DIBsection);
|
|
|
|
if (!priv->dib.client_memory)
|
|
VirtualFree(This->surface_desc.lpSurface, 0, MEM_RELEASE);
|
|
|
|
Main_DirectDrawSurface_final_release(This);
|
|
}
|
|
|
|
HRESULT DIB_DirectDrawSurface_duplicate_surface(IDirectDrawSurfaceImpl* This,
|
|
LPDIRECTDRAWSURFACE7* ppDup)
|
|
{
|
|
return DIB_DirectDrawSurface_Create(This->ddraw_owner,
|
|
&This->surface_desc, ppDup, NULL);
|
|
}
|
|
|
|
HRESULT DIB_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl *This,
|
|
IDirectDrawImpl *pDD,
|
|
const DDSURFACEDESC2 *pDDSD)
|
|
{
|
|
HRESULT hr;
|
|
DIB_DirectDrawSurfaceImpl* priv = This->private;
|
|
|
|
TRACE("(%p)->(%p,%p)\n",This,pDD,pDDSD);
|
|
hr = Main_DirectDrawSurface_Construct(This, pDD, pDDSD);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
ICOM_INIT_INTERFACE(This, IDirectDrawSurface7,
|
|
DIB_IDirectDrawSurface7_VTable);
|
|
|
|
This->final_release = DIB_DirectDrawSurface_final_release;
|
|
This->duplicate_surface = DIB_DirectDrawSurface_duplicate_surface;
|
|
This->flip_data = DIB_DirectDrawSurface_flip_data;
|
|
|
|
This->get_dc = DIB_DirectDrawSurface_get_dc;
|
|
This->release_dc = DIB_DirectDrawSurface_release_dc;
|
|
This->hDC = NULL;
|
|
|
|
This->set_palette = DIB_DirectDrawSurface_set_palette;
|
|
This->update_palette = DIB_DirectDrawSurface_update_palette;
|
|
|
|
TRACE("(%ldx%ld, pitch=%ld)\n",
|
|
This->surface_desc.dwWidth, This->surface_desc.dwHeight,
|
|
This->surface_desc.u1.lPitch);
|
|
/* XXX load dwWidth and dwHeight from pDD if they are not specified? */
|
|
|
|
if (This->surface_desc.dwFlags & DDSD_LPSURFACE)
|
|
{
|
|
/* "Client memory": it is managed by the application. */
|
|
/* XXX What if lPitch is not set? Use dwWidth or fail? */
|
|
|
|
priv->dib.client_memory = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (!(This->surface_desc.dwFlags & DDSD_PITCH))
|
|
{
|
|
int pitch = This->surface_desc.u1.lPitch;
|
|
if (pitch % 8 != 0)
|
|
pitch += 8 - (pitch % 8);
|
|
}
|
|
/* XXX else: how should lPitch be verified? */
|
|
|
|
This->surface_desc.dwFlags |= DDSD_LPSURFACE;
|
|
|
|
/* Ensure that DDSD_PITCH is respected for DDPF_FOURCC surfaces too */
|
|
if (This->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC && !(This->surface_desc.dwFlags & DDSD_PITCH)) {
|
|
This->surface_desc.lpSurface
|
|
= VirtualAlloc(NULL, This->surface_desc.u1.dwLinearSize, MEM_COMMIT, PAGE_READWRITE);
|
|
This->surface_desc.dwFlags |= DDSD_LINEARSIZE;
|
|
} else {
|
|
This->surface_desc.lpSurface
|
|
= VirtualAlloc(NULL, This->surface_desc.u1.lPitch
|
|
* This->surface_desc.dwHeight + 4, /* The + 4 here is for dumb games reading after the end of the surface
|
|
when reading the last byte / half using word access */
|
|
MEM_COMMIT, PAGE_READWRITE);
|
|
This->surface_desc.dwFlags |= DDSD_PITCH;
|
|
}
|
|
|
|
if (This->surface_desc.lpSurface == NULL)
|
|
{
|
|
Main_DirectDrawSurface_final_release(This);
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
priv->dib.client_memory = FALSE;
|
|
}
|
|
|
|
hr = create_dib(This);
|
|
if (FAILED(hr))
|
|
{
|
|
if (!priv->dib.client_memory)
|
|
VirtualFree(This->surface_desc.lpSurface, 0, MEM_RELEASE);
|
|
|
|
Main_DirectDrawSurface_final_release(This);
|
|
|
|
return hr;
|
|
}
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
/* Not an API */
|
|
HRESULT DIB_DirectDrawSurface_Create(IDirectDrawImpl *pDD,
|
|
const DDSURFACEDESC2 *pDDSD,
|
|
LPDIRECTDRAWSURFACE7 *ppSurf,
|
|
IUnknown *pUnkOuter)
|
|
{
|
|
IDirectDrawSurfaceImpl* This;
|
|
HRESULT hr;
|
|
assert(pUnkOuter == NULL);
|
|
|
|
This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
sizeof(*This) + sizeof(DIB_DirectDrawSurfaceImpl));
|
|
if (This == NULL) return E_OUTOFMEMORY;
|
|
|
|
This->private = (DIB_DirectDrawSurfaceImpl*)(This+1);
|
|
|
|
hr = DIB_DirectDrawSurface_Construct(This, pDD, pDDSD);
|
|
if (FAILED(hr))
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
else
|
|
*ppSurf = ICOM_INTERFACE(This, IDirectDrawSurface7);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
/* AddAttachedSurface: generic */
|
|
/* AddOverlayDirtyRect: generic, unimplemented */
|
|
|
|
static HRESULT _Blt_ColorFill(
|
|
LPBYTE buf, int width, int height, int bpp, LONG lPitch, DWORD color
|
|
) {
|
|
int x, y;
|
|
LPBYTE first;
|
|
|
|
/* Do first row */
|
|
|
|
#define COLORFILL_ROW(type) { \
|
|
type *d = (type *) buf; \
|
|
for (x = 0; x < width; x++) \
|
|
d[x] = (type) color; \
|
|
break; \
|
|
}
|
|
|
|
switch(bpp) {
|
|
case 1: COLORFILL_ROW(BYTE)
|
|
case 2: COLORFILL_ROW(WORD)
|
|
case 3: { BYTE *d = (BYTE *) buf;
|
|
for (x = 0; x < width; x++,d+=3) {
|
|
d[0] = (color ) & 0xFF;
|
|
d[1] = (color>> 8) & 0xFF;
|
|
d[2] = (color>>16) & 0xFF;
|
|
}
|
|
break;}
|
|
case 4: COLORFILL_ROW(DWORD)
|
|
default:
|
|
FIXME("Color fill not implemented for bpp %d!\n", bpp*8);
|
|
return DDERR_UNSUPPORTED;
|
|
}
|
|
|
|
#undef COLORFILL_ROW
|
|
|
|
/* Now copy first row */
|
|
first = buf;
|
|
for (y = 1; y < height; y++) {
|
|
buf += lPitch;
|
|
memcpy(buf, first, width * bpp);
|
|
}
|
|
return DD_OK;
|
|
}
|
|
|
|
static void ComputeShifts(DWORD mask, DWORD* lshift, DWORD* rshift)
|
|
{
|
|
int pos = 0;
|
|
int bits = 0;
|
|
*lshift = 0;
|
|
*rshift = 0;
|
|
|
|
if (!mask)
|
|
return;
|
|
|
|
while(!(mask & (1 << pos)))
|
|
pos++;
|
|
|
|
while(mask & (1 << (pos+bits)))
|
|
bits++;
|
|
|
|
*lshift = pos;
|
|
*rshift = 8 - bits;
|
|
}
|
|
|
|
/* This is used to factorize the decompression between the Blt and BltFast code */
|
|
static void DoDXTCDecompression(const DDSURFACEDESC2 *sdesc, const DDSURFACEDESC2 *ddesc)
|
|
{
|
|
DWORD rs,rb,rm;
|
|
DWORD gs,gb,gm;
|
|
DWORD bs,bb,bm;
|
|
DWORD as,ab,am;
|
|
|
|
if (!s3tc_initialized) {
|
|
/* FIXME: We may fake this by rendering the texture into the framebuffer using OpenGL functions and reading back
|
|
* the framebuffer. This will be slow and somewhat ugly. */
|
|
FIXME("Manual S3TC decompression is not supported in native mode\n");
|
|
return;
|
|
}
|
|
|
|
rm = ddesc->u4.ddpfPixelFormat.u2.dwRBitMask;
|
|
ComputeShifts(rm, &rs, &rb);
|
|
gm = ddesc->u4.ddpfPixelFormat.u3.dwGBitMask;
|
|
ComputeShifts(gm, &gs, &gb);
|
|
bm = ddesc->u4.ddpfPixelFormat.u4.dwBBitMask;
|
|
ComputeShifts(bm, &bs, &bb);
|
|
am = ddesc->u4.ddpfPixelFormat.u5.dwRGBAlphaBitMask;
|
|
ComputeShifts(am, &as, &ab);
|
|
if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','1')) {
|
|
int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
|
|
int pitch = ddesc->u1.lPitch;
|
|
int width = ddesc->dwWidth;
|
|
int height = ddesc->dwHeight;
|
|
int x,y;
|
|
unsigned char* dst = (unsigned char*) ddesc->lpSurface;
|
|
unsigned char* src = (unsigned char*) sdesc->lpSurface;
|
|
for (x = 0; x < width; x++)
|
|
for (y =0; y < height; y++) {
|
|
DWORD pixel = 0;
|
|
BYTE data[4];
|
|
(*fetch_2d_texel_rgba_dxt1)(width, src, x, y, data);
|
|
pixel = 0;
|
|
pixel |= ((data[0] >> rb) << rs) & rm;
|
|
pixel |= ((data[1] >> gb) << gs) & gm;
|
|
pixel |= ((data[2] >> bb) << bs) & bm;
|
|
pixel |= ((data[3] >> ab) << as) & am;
|
|
if (is16)
|
|
*((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
|
|
else
|
|
*((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
|
|
}
|
|
} else if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','3')) {
|
|
int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
|
|
int pitch = ddesc->u1.lPitch;
|
|
int width = ddesc->dwWidth;
|
|
int height = ddesc->dwHeight;
|
|
int x,y;
|
|
unsigned char* dst = (unsigned char*) ddesc->lpSurface;
|
|
unsigned char* src = (unsigned char*) sdesc->lpSurface;
|
|
for (x = 0; x < width; x++)
|
|
for (y =0; y < height; y++) {
|
|
DWORD pixel = 0;
|
|
BYTE data[4];
|
|
(*fetch_2d_texel_rgba_dxt3)(width, src, x, y, data);
|
|
pixel = 0;
|
|
pixel |= ((data[0] >> rb) << rs) & rm;
|
|
pixel |= ((data[1] >> gb) << gs) & gm;
|
|
pixel |= ((data[2] >> bb) << bs) & bm;
|
|
pixel |= ((data[3] >> ab) << as) & am;
|
|
if (is16)
|
|
*((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
|
|
else
|
|
*((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
|
|
}
|
|
} else if (sdesc->u4.ddpfPixelFormat.dwFourCC == MAKE_FOURCC('D','X','T','5')) {
|
|
int is16 = ddesc->u4.ddpfPixelFormat.u1.dwRGBBitCount == 16;
|
|
int pitch = ddesc->u1.lPitch;
|
|
int width = ddesc->dwWidth;
|
|
int height = ddesc->dwHeight;
|
|
int x,y;
|
|
unsigned char* dst = (unsigned char*) ddesc->lpSurface;
|
|
unsigned char* src = (unsigned char*) sdesc->lpSurface;
|
|
for (x = 0; x < width; x++)
|
|
for (y =0; y < height; y++) {
|
|
DWORD pixel = 0;
|
|
BYTE data[4];
|
|
(*fetch_2d_texel_rgba_dxt5)(width, src, x, y, data);
|
|
pixel = 0;
|
|
pixel |= ((data[0] >> rb) << rs) & rm;
|
|
pixel |= ((data[1] >> gb) << gs) & gm;
|
|
pixel |= ((data[2] >> bb) << bs) & bm;
|
|
pixel |= ((data[3] >> ab) << as) & am;
|
|
if (is16)
|
|
*((WORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
|
|
else
|
|
*((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
|
|
}
|
|
}
|
|
#if 0 /* Useful for debugging */
|
|
{
|
|
static int idx;
|
|
char texname[255];
|
|
FILE* f;
|
|
sprintf(texname, "dxt_%d.pnm", idx++);
|
|
f = fopen(texname,"w");
|
|
DDRAW_dump_surface_to_disk(This, f, 1);
|
|
fclose(f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
DIB_DirectDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
|
|
LPDIRECTDRAWSURFACE7 src, LPRECT rsrc,
|
|
DWORD dwFlags, LPDDBLTFX lpbltfx)
|
|
{
|
|
IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
|
|
RECT xdst,xsrc;
|
|
DDSURFACEDESC2 ddesc,sdesc;
|
|
HRESULT ret = DD_OK;
|
|
int bpp, srcheight, srcwidth, dstheight, dstwidth, width;
|
|
int x, y;
|
|
LPBYTE dbuf, sbuf;
|
|
|
|
TRACE("(%p)->(%p,%p,%p,%08lx,%p)\n", This,rdst,src,rsrc,dwFlags,lpbltfx);
|
|
|
|
if (TRACE_ON(ddraw)) {
|
|
if (rdst) TRACE("\tdestrect :%ldx%ld-%ldx%ld\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
|
|
if (rsrc) TRACE("\tsrcrect :%ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
|
|
TRACE("\tflags: ");
|
|
DDRAW_dump_DDBLT(dwFlags);
|
|
if (dwFlags & DDBLT_DDFX) {
|
|
TRACE("\tblitfx: ");
|
|
DDRAW_dump_DDBLTFX(lpbltfx->dwDDFX);
|
|
}
|
|
}
|
|
|
|
if ((This->locked) || ((src != NULL) && (((IDirectDrawSurfaceImpl *)src)->locked))) {
|
|
WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
|
|
return DDERR_SURFACEBUSY;
|
|
}
|
|
|
|
/* First, check if the possible override function handles this case */
|
|
if (This->aux_blt != NULL) {
|
|
if (This->aux_blt(This, rdst, src, rsrc, dwFlags, lpbltfx) == DD_OK) return DD_OK;
|
|
}
|
|
|
|
DD_STRUCT_INIT(&ddesc);
|
|
DD_STRUCT_INIT(&sdesc);
|
|
|
|
sdesc.dwSize = sizeof(sdesc);
|
|
ddesc.dwSize = sizeof(ddesc);
|
|
|
|
if (src == iface) {
|
|
IDirectDrawSurface7_Lock(iface, NULL, &ddesc, 0, 0);
|
|
DD_STRUCT_COPY_BYSIZE(&sdesc, &ddesc);
|
|
} else {
|
|
if (src) IDirectDrawSurface7_Lock(src, NULL, &sdesc, DDLOCK_READONLY, 0);
|
|
IDirectDrawSurface7_Lock(iface,NULL,&ddesc,DDLOCK_WRITEONLY,0);
|
|
}
|
|
|
|
if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
|
|
(ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)) {
|
|
if (sdesc.u4.ddpfPixelFormat.dwFourCC != sdesc.u4.ddpfPixelFormat.dwFourCC) {
|
|
FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
|
|
ret = DDERR_INVALIDPIXELFORMAT;
|
|
goto release;
|
|
}
|
|
memcpy(ddesc.lpSurface, sdesc.lpSurface, ddesc.u1.dwLinearSize);
|
|
goto release;
|
|
}
|
|
|
|
if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
|
|
(!(ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC))) {
|
|
DoDXTCDecompression(&sdesc, &ddesc);
|
|
goto release;
|
|
}
|
|
|
|
if (rdst) {
|
|
memcpy(&xdst,rdst,sizeof(xdst));
|
|
} else {
|
|
xdst.top = 0;
|
|
xdst.bottom = ddesc.dwHeight;
|
|
xdst.left = 0;
|
|
xdst.right = ddesc.dwWidth;
|
|
}
|
|
|
|
if (rsrc) {
|
|
memcpy(&xsrc,rsrc,sizeof(xsrc));
|
|
} else {
|
|
if (src) {
|
|
xsrc.top = 0;
|
|
xsrc.bottom = sdesc.dwHeight;
|
|
xsrc.left = 0;
|
|
xsrc.right = sdesc.dwWidth;
|
|
} else {
|
|
memset(&xsrc,0,sizeof(xsrc));
|
|
}
|
|
}
|
|
|
|
/* First check for the validity of source / destination rectangles. This was
|
|
verified using a test application + by MSDN.
|
|
*/
|
|
if ((src != NULL) &&
|
|
((xsrc.bottom > sdesc.dwHeight) || (xsrc.bottom < 0) ||
|
|
(xsrc.top > sdesc.dwHeight) || (xsrc.top < 0) ||
|
|
(xsrc.left > sdesc.dwWidth) || (xsrc.left < 0) ||
|
|
(xsrc.right > sdesc.dwWidth) || (xsrc.right < 0) ||
|
|
(xsrc.right < xsrc.left) || (xsrc.bottom < xsrc.top))) {
|
|
WARN("Application gave us bad source rectangle for Blt.\n");
|
|
ret = DDERR_INVALIDRECT;
|
|
goto release;
|
|
}
|
|
/* For the Destination rect, it can be out of bounds on the condition that a clipper
|
|
is set for the given surface.
|
|
*/
|
|
if ((This->clipper == NULL) &&
|
|
((xdst.bottom > ddesc.dwHeight) || (xdst.bottom < 0) ||
|
|
(xdst.top > ddesc.dwHeight) || (xdst.top < 0) ||
|
|
(xdst.left > ddesc.dwWidth) || (xdst.left < 0) ||
|
|
(xdst.right > ddesc.dwWidth) || (xdst.right < 0) ||
|
|
(xdst.right < xdst.left) || (xdst.bottom < xdst.top))) {
|
|
WARN("Application gave us bad destination rectangle for Blt without a clipper set.\n");
|
|
ret = DDERR_INVALIDRECT;
|
|
goto release;
|
|
}
|
|
|
|
/* Now handle negative values in the rectangles. Warning: only supported for now
|
|
in the 'simple' cases (ie not in any stretching / rotation cases).
|
|
|
|
First, the case where nothing is to be done.
|
|
*/
|
|
if (((xdst.bottom <= 0) || (xdst.right <= 0) || (xdst.top >= (int) ddesc.dwHeight) || (xdst.left >= (int) ddesc.dwWidth)) ||
|
|
((src != NULL) &&
|
|
((xsrc.bottom <= 0) || (xsrc.right <= 0) || (xsrc.top >= (int) sdesc.dwHeight) || (xsrc.left >= (int) sdesc.dwWidth))))
|
|
{
|
|
TRACE("Nothing to be done !\n");
|
|
goto release;
|
|
}
|
|
|
|
/* The easy case : the source-less blits.... */
|
|
if (src == NULL) {
|
|
RECT full_rect;
|
|
RECT temp_rect; /* No idea if intersect rect can be the same as one of the source rect */
|
|
|
|
full_rect.left = 0;
|
|
full_rect.top = 0;
|
|
full_rect.right = ddesc.dwWidth;
|
|
full_rect.bottom = ddesc.dwHeight;
|
|
IntersectRect(&temp_rect, &full_rect, &xdst);
|
|
xdst = temp_rect;
|
|
} else {
|
|
/* Only handle clipping on the destination rectangle */
|
|
int clip_horiz = (xdst.left < 0) || (xdst.right > (int) ddesc.dwWidth );
|
|
int clip_vert = (xdst.top < 0) || (xdst.bottom > (int) ddesc.dwHeight);
|
|
if (clip_vert || clip_horiz) {
|
|
/* Now check if this is a special case or not... */
|
|
if ((((xdst.bottom - xdst.top ) != (xsrc.bottom - xsrc.top )) && clip_vert ) ||
|
|
(((xdst.right - xdst.left) != (xsrc.right - xsrc.left)) && clip_horiz) ||
|
|
(dwFlags & DDBLT_DDFX)) {
|
|
WARN("Out of screen rectangle in special case. Not handled right now.\n");
|
|
goto release;
|
|
}
|
|
|
|
if (clip_horiz) {
|
|
if (xdst.left < 0) { xsrc.left -= xdst.left; xdst.left = 0; }
|
|
if (xdst.right > ddesc.dwWidth) { xsrc.right -= (xdst.right - (int) ddesc.dwWidth); xdst.right = (int) ddesc.dwWidth; }
|
|
}
|
|
if (clip_vert) {
|
|
if (xdst.top < 0) { xsrc.top -= xdst.top; xdst.top = 0; }
|
|
if (xdst.bottom > ddesc.dwHeight) { xsrc.bottom -= (xdst.bottom - (int) ddesc.dwHeight); xdst.bottom = (int) ddesc.dwHeight; }
|
|
}
|
|
/* And check if after clipping something is still to be done... */
|
|
if ((xdst.bottom <= 0) || (xdst.right <= 0) || (xdst.top >= (int) ddesc.dwHeight) || (xdst.left >= (int) ddesc.dwWidth) ||
|
|
(xsrc.bottom <= 0) || (xsrc.right <= 0) || (xsrc.top >= (int) sdesc.dwHeight) || (xsrc.left >= (int) sdesc.dwWidth)) {
|
|
TRACE("Nothing to be done after clipping !\n");
|
|
goto release;
|
|
}
|
|
}
|
|
}
|
|
|
|
bpp = GET_BPP(ddesc);
|
|
srcheight = xsrc.bottom - xsrc.top;
|
|
srcwidth = xsrc.right - xsrc.left;
|
|
dstheight = xdst.bottom - xdst.top;
|
|
dstwidth = xdst.right - xdst.left;
|
|
width = (xdst.right - xdst.left) * bpp;
|
|
|
|
assert(width <= ddesc.u1.lPitch);
|
|
|
|
dbuf = (BYTE*)ddesc.lpSurface+(xdst.top*ddesc.u1.lPitch)+(xdst.left*bpp);
|
|
|
|
if (dwFlags & (DDBLT_WAIT|DDBLT_ASYNC))
|
|
{
|
|
static BOOL displayed = FALSE;
|
|
if (!displayed)
|
|
{
|
|
FIXME("dwFlags DDBLT_WAIT and/or DDBLT_ASYNC: can't handle right now.\n");
|
|
displayed = TRUE;
|
|
}
|
|
dwFlags &= ~(DDBLT_WAIT|DDBLT_ASYNC);
|
|
}
|
|
|
|
/* First, all the 'source-less' blits */
|
|
if (dwFlags & DDBLT_COLORFILL) {
|
|
ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp,
|
|
ddesc.u1.lPitch, lpbltfx->u5.dwFillColor);
|
|
dwFlags &= ~DDBLT_COLORFILL;
|
|
}
|
|
|
|
if (dwFlags & DDBLT_DEPTHFILL)
|
|
FIXME("DDBLT_DEPTHFILL needs to be implemented!\n");
|
|
if (dwFlags & DDBLT_ROP) {
|
|
/* Catch some degenerate cases here */
|
|
switch(lpbltfx->dwROP) {
|
|
case BLACKNESS:
|
|
ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,ddesc.u1.lPitch,0);
|
|
break;
|
|
case 0xAA0029: /* No-op */
|
|
break;
|
|
case WHITENESS:
|
|
ret = _Blt_ColorFill(dbuf,dstwidth,dstheight,bpp,ddesc.u1.lPitch,~0);
|
|
break;
|
|
case SRCCOPY: /* well, we do that below ? */
|
|
break;
|
|
default:
|
|
FIXME("Unsupported raster op: %08lx Pattern: %p\n", lpbltfx->dwROP, lpbltfx->u5.lpDDSPattern);
|
|
goto error;
|
|
}
|
|
dwFlags &= ~DDBLT_ROP;
|
|
}
|
|
if (dwFlags & DDBLT_DDROPS) {
|
|
FIXME("\tDdraw Raster Ops: %08lx Pattern: %p\n", lpbltfx->dwDDROP, lpbltfx->u5.lpDDSPattern);
|
|
}
|
|
/* Now the 'with source' blits */
|
|
if (src) {
|
|
LPBYTE sbase;
|
|
int sx, xinc, sy, yinc;
|
|
|
|
if (!dstwidth || !dstheight) /* hmm... stupid program ? */
|
|
goto release;
|
|
sbase = (BYTE*)sdesc.lpSurface+(xsrc.top*sdesc.u1.lPitch)+xsrc.left*bpp;
|
|
xinc = (srcwidth << 16) / dstwidth;
|
|
yinc = (srcheight << 16) / dstheight;
|
|
|
|
if (!dwFlags) {
|
|
/* No effects, we can cheat here */
|
|
if (dstwidth == srcwidth) {
|
|
if (dstheight == srcheight) {
|
|
/* No stretching in either direction. This needs to be as
|
|
* fast as possible */
|
|
sbuf = sbase;
|
|
|
|
/* check for overlapping surfaces */
|
|
if (src != iface || xdst.top < xsrc.top ||
|
|
xdst.right <= xsrc.left || xsrc.right <= xdst.left)
|
|
{
|
|
/* no overlap, or dst above src, so copy from top downwards */
|
|
for (y = 0; y < dstheight; y++)
|
|
{
|
|
memcpy(dbuf, sbuf, width);
|
|
sbuf += sdesc.u1.lPitch;
|
|
dbuf += ddesc.u1.lPitch;
|
|
}
|
|
}
|
|
else if (xdst.top > xsrc.top) /* copy from bottom upwards */
|
|
{
|
|
sbuf += (sdesc.u1.lPitch*dstheight);
|
|
dbuf += (ddesc.u1.lPitch*dstheight);
|
|
for (y = 0; y < dstheight; y++)
|
|
{
|
|
sbuf -= sdesc.u1.lPitch;
|
|
dbuf -= ddesc.u1.lPitch;
|
|
memcpy(dbuf, sbuf, width);
|
|
}
|
|
}
|
|
else /* src and dst overlapping on the same line, use memmove */
|
|
{
|
|
for (y = 0; y < dstheight; y++)
|
|
{
|
|
memmove(dbuf, sbuf, width);
|
|
sbuf += sdesc.u1.lPitch;
|
|
dbuf += ddesc.u1.lPitch;
|
|
}
|
|
}
|
|
} else {
|
|
/* Stretching in Y direction only */
|
|
for (y = sy = 0; y < dstheight; y++, sy += yinc) {
|
|
sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
|
|
memcpy(dbuf, sbuf, width);
|
|
dbuf += ddesc.u1.lPitch;
|
|
}
|
|
}
|
|
} else {
|
|
/* Stretching in X direction */
|
|
int last_sy = -1;
|
|
for (y = sy = 0; y < dstheight; y++, sy += yinc) {
|
|
sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
|
|
|
|
if ((sy >> 16) == (last_sy >> 16)) {
|
|
/* this sourcerow is the same as last sourcerow -
|
|
* copy already stretched row
|
|
*/
|
|
memcpy(dbuf, dbuf - ddesc.u1.lPitch, width);
|
|
} else {
|
|
#define STRETCH_ROW(type) { \
|
|
type *s = (type *) sbuf, *d = (type *) dbuf; \
|
|
for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
|
|
d[x] = s[sx >> 16]; \
|
|
break; }
|
|
|
|
switch(bpp) {
|
|
case 1: STRETCH_ROW(BYTE)
|
|
case 2: STRETCH_ROW(WORD)
|
|
case 4: STRETCH_ROW(DWORD)
|
|
case 3: {
|
|
LPBYTE s,d = dbuf;
|
|
for (x = sx = 0; x < dstwidth; x++, sx+= xinc) {
|
|
DWORD pixel;
|
|
|
|
s = sbuf+3*(sx>>16);
|
|
pixel = s[0]|(s[1]<<8)|(s[2]<<16);
|
|
d[0] = (pixel )&0xff;
|
|
d[1] = (pixel>> 8)&0xff;
|
|
d[2] = (pixel>>16)&0xff;
|
|
d+=3;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
FIXME("Stretched blit not implemented for bpp %d!\n", bpp*8);
|
|
ret = DDERR_UNSUPPORTED;
|
|
goto error;
|
|
}
|
|
#undef STRETCH_ROW
|
|
}
|
|
dbuf += ddesc.u1.lPitch;
|
|
last_sy = sy;
|
|
}
|
|
}
|
|
} else {
|
|
LONG dstyinc = ddesc.u1.lPitch, dstxinc = bpp;
|
|
DWORD keylow = 0, keyhigh = 0;
|
|
if (dwFlags & (DDBLT_KEYSRC | DDBLT_KEYDEST | DDBLT_KEYSRCOVERRIDE | DDBLT_KEYDESTOVERRIDE)) {
|
|
|
|
if (dwFlags & DDBLT_KEYSRC) {
|
|
keylow = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
|
|
keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
|
|
} else if (dwFlags & DDBLT_KEYDEST){
|
|
keylow = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
|
|
keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
|
|
} else if (dwFlags & DDBLT_KEYSRCOVERRIDE) {
|
|
keylow = lpbltfx->ddckSrcColorkey.dwColorSpaceLowValue;
|
|
keyhigh = lpbltfx->ddckSrcColorkey.dwColorSpaceHighValue;
|
|
} else {
|
|
keylow = lpbltfx->ddckDestColorkey.dwColorSpaceLowValue;
|
|
keyhigh = lpbltfx->ddckDestColorkey.dwColorSpaceHighValue;
|
|
}
|
|
dwFlags &= ~(DDBLT_KEYSRC | DDBLT_KEYDEST | DDBLT_KEYSRCOVERRIDE | DDBLT_KEYDESTOVERRIDE);
|
|
}
|
|
|
|
if (dwFlags & DDBLT_DDFX) {
|
|
LPBYTE dTopLeft, dTopRight, dBottomLeft, dBottomRight, tmp;
|
|
LONG tmpxy;
|
|
dTopLeft = dbuf;
|
|
dTopRight = dbuf+((dstwidth-1)*bpp);
|
|
dBottomLeft = dTopLeft+((dstheight-1)*ddesc.u1.lPitch);
|
|
dBottomRight = dBottomLeft+((dstwidth-1)*bpp);
|
|
|
|
if (lpbltfx->dwDDFX & DDBLTFX_ARITHSTRETCHY){
|
|
/* I don't think we need to do anything about this flag */
|
|
WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ARITHSTRETCHY\n");
|
|
}
|
|
if (lpbltfx->dwDDFX & DDBLTFX_MIRRORLEFTRIGHT) {
|
|
tmp = dTopRight;
|
|
dTopRight = dTopLeft;
|
|
dTopLeft = tmp;
|
|
tmp = dBottomRight;
|
|
dBottomRight = dBottomLeft;
|
|
dBottomLeft = tmp;
|
|
dstxinc = dstxinc *-1;
|
|
}
|
|
if (lpbltfx->dwDDFX & DDBLTFX_MIRRORUPDOWN) {
|
|
tmp = dTopLeft;
|
|
dTopLeft = dBottomLeft;
|
|
dBottomLeft = tmp;
|
|
tmp = dTopRight;
|
|
dTopRight = dBottomRight;
|
|
dBottomRight = tmp;
|
|
dstyinc = dstyinc *-1;
|
|
}
|
|
if (lpbltfx->dwDDFX & DDBLTFX_NOTEARING) {
|
|
/* I don't think we need to do anything about this flag */
|
|
WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_NOTEARING\n");
|
|
}
|
|
if (lpbltfx->dwDDFX & DDBLTFX_ROTATE180) {
|
|
tmp = dBottomRight;
|
|
dBottomRight = dTopLeft;
|
|
dTopLeft = tmp;
|
|
tmp = dBottomLeft;
|
|
dBottomLeft = dTopRight;
|
|
dTopRight = tmp;
|
|
dstxinc = dstxinc * -1;
|
|
dstyinc = dstyinc * -1;
|
|
}
|
|
if (lpbltfx->dwDDFX & DDBLTFX_ROTATE270) {
|
|
tmp = dTopLeft;
|
|
dTopLeft = dBottomLeft;
|
|
dBottomLeft = dBottomRight;
|
|
dBottomRight = dTopRight;
|
|
dTopRight = tmp;
|
|
tmpxy = dstxinc;
|
|
dstxinc = dstyinc;
|
|
dstyinc = tmpxy;
|
|
dstxinc = dstxinc * -1;
|
|
}
|
|
if (lpbltfx->dwDDFX & DDBLTFX_ROTATE90) {
|
|
tmp = dTopLeft;
|
|
dTopLeft = dTopRight;
|
|
dTopRight = dBottomRight;
|
|
dBottomRight = dBottomLeft;
|
|
dBottomLeft = tmp;
|
|
tmpxy = dstxinc;
|
|
dstxinc = dstyinc;
|
|
dstyinc = tmpxy;
|
|
dstyinc = dstyinc * -1;
|
|
}
|
|
if (lpbltfx->dwDDFX & DDBLTFX_ZBUFFERBASEDEST) {
|
|
/* I don't think we need to do anything about this flag */
|
|
WARN("dwflags=DDBLT_DDFX nothing done for DDBLTFX_ZBUFFERBASEDEST\n");
|
|
}
|
|
dbuf = dTopLeft;
|
|
dwFlags &= ~(DDBLT_DDFX);
|
|
}
|
|
|
|
#define COPY_COLORKEY_FX(type) { \
|
|
type *s, *d = (type *) dbuf, *dx, tmp; \
|
|
for (y = sy = 0; y < dstheight; y++, sy += yinc) { \
|
|
s = (type*)(sbase + (sy >> 16) * sdesc.u1.lPitch); \
|
|
dx = d; \
|
|
for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
|
|
tmp = s[sx >> 16]; \
|
|
if (tmp < keylow || tmp > keyhigh) dx[0] = tmp; \
|
|
dx = (type*)(((LPBYTE)dx)+dstxinc); \
|
|
} \
|
|
d = (type*)(((LPBYTE)d)+dstyinc); \
|
|
} \
|
|
break; }
|
|
|
|
switch (bpp) {
|
|
case 1: COPY_COLORKEY_FX(BYTE)
|
|
case 2: COPY_COLORKEY_FX(WORD)
|
|
case 4: COPY_COLORKEY_FX(DWORD)
|
|
case 3: {LPBYTE s,d = dbuf, dx;
|
|
for (y = sy = 0; y < dstheight; y++, sy += yinc) {
|
|
sbuf = sbase + (sy >> 16) * sdesc.u1.lPitch;
|
|
dx = d;
|
|
for (x = sx = 0; x < dstwidth; x++, sx+= xinc) {
|
|
DWORD pixel;
|
|
s = sbuf+3*(sx>>16);
|
|
pixel = s[0]|(s[1]<<8)|(s[2]<<16);
|
|
if (pixel < keylow || pixel > keyhigh){
|
|
dx[0] = (pixel )&0xff;
|
|
dx[1] = (pixel>> 8)&0xff;
|
|
dx[2] = (pixel>>16)&0xff;
|
|
}
|
|
dx+= dstxinc;
|
|
}
|
|
d += dstyinc;
|
|
}
|
|
break;}
|
|
default:
|
|
FIXME("%s color-keyed blit not implemented for bpp %d!\n",
|
|
(dwFlags & DDBLT_KEYSRC) ? "Source" : "Destination", bpp*8);
|
|
ret = DDERR_UNSUPPORTED;
|
|
goto error;
|
|
#undef COPY_COLORKEY_FX
|
|
}
|
|
}
|
|
}
|
|
|
|
error:
|
|
if (dwFlags && FIXME_ON(ddraw)) {
|
|
FIXME("\tUnsupported flags: ");
|
|
DDRAW_dump_DDBLT(dwFlags);
|
|
}
|
|
|
|
release:
|
|
IDirectDrawSurface7_Unlock(iface,NULL);
|
|
if (src && src != iface) IDirectDrawSurface7_Unlock(src,NULL);
|
|
return ret;
|
|
}
|
|
|
|
/* BltBatch: generic, unimplemented */
|
|
|
|
HRESULT WINAPI
|
|
DIB_DirectDrawSurface_BltFast(LPDIRECTDRAWSURFACE7 iface, DWORD dstx,
|
|
DWORD dsty, LPDIRECTDRAWSURFACE7 src,
|
|
LPRECT rsrc, DWORD trans)
|
|
{
|
|
IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
|
|
int bpp, w, h, x, y;
|
|
DDSURFACEDESC2 ddesc,sdesc;
|
|
HRESULT ret = DD_OK;
|
|
LPBYTE sbuf, dbuf;
|
|
RECT rsrc2;
|
|
RECT lock_src, lock_dst, lock_union;
|
|
|
|
if (TRACE_ON(ddraw)) {
|
|
TRACE("(%p)->(%ld,%ld,%p,%p,%08lx)\n",
|
|
This,dstx,dsty,src,rsrc,trans
|
|
);
|
|
TRACE("\ttrans:");
|
|
if (FIXME_ON(ddraw))
|
|
DDRAW_dump_DDBLTFAST(trans);
|
|
if (rsrc)
|
|
TRACE("\tsrcrect: %ldx%ld-%ldx%ld\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
|
|
else
|
|
TRACE(" srcrect: NULL\n");
|
|
}
|
|
|
|
if ((This->locked) || ((src != NULL) && (((IDirectDrawSurfaceImpl *)src)->locked))) {
|
|
WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
|
|
return DDERR_SURFACEBUSY;
|
|
}
|
|
|
|
/* First, check if the possible override function handles this case */
|
|
if (This->aux_bltfast != NULL) {
|
|
if (This->aux_bltfast(This, dstx, dsty, src, rsrc, trans) == DD_OK) return DD_OK;
|
|
}
|
|
|
|
/* Get the surface description without locking to first compute the width / height */
|
|
ddesc = This->surface_desc;
|
|
sdesc = (ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, src))->surface_desc;
|
|
|
|
if (!rsrc) {
|
|
WARN("rsrc is NULL!\n");
|
|
rsrc = &rsrc2;
|
|
rsrc->left = rsrc->top = 0;
|
|
rsrc->right = sdesc.dwWidth;
|
|
rsrc->bottom = sdesc.dwHeight;
|
|
}
|
|
|
|
/* Check source rect for validity. Copied from normal Blt. Fixes Baldur's Gate.*/
|
|
if ((rsrc->bottom > sdesc.dwHeight) || (rsrc->bottom < 0) ||
|
|
(rsrc->top > sdesc.dwHeight) || (rsrc->top < 0) ||
|
|
(rsrc->left > sdesc.dwWidth) || (rsrc->left < 0) ||
|
|
(rsrc->right > sdesc.dwWidth) || (rsrc->right < 0) ||
|
|
(rsrc->right < rsrc->left) || (rsrc->bottom < rsrc->top)) {
|
|
WARN("Application gave us bad source rectangle for BltFast.\n");
|
|
return DDERR_INVALIDRECT;
|
|
}
|
|
|
|
h=rsrc->bottom-rsrc->top;
|
|
if (h>ddesc.dwHeight-dsty) h=ddesc.dwHeight-dsty;
|
|
if (h>sdesc.dwHeight-rsrc->top) h=sdesc.dwHeight-rsrc->top;
|
|
if (h<=0) return DDERR_INVALIDRECT;
|
|
|
|
w=rsrc->right-rsrc->left;
|
|
if (w>ddesc.dwWidth-dstx) w=ddesc.dwWidth-dstx;
|
|
if (w>sdesc.dwWidth-rsrc->left) w=sdesc.dwWidth-rsrc->left;
|
|
if (w<=0) return DDERR_INVALIDRECT;
|
|
|
|
/* Now compute the locking rectangle... */
|
|
lock_src.left = rsrc->left;
|
|
lock_src.top = rsrc->top;
|
|
lock_src.right = lock_src.left + w;
|
|
lock_src.bottom = lock_src.top + h;
|
|
|
|
lock_dst.left = dstx;
|
|
lock_dst.top = dsty;
|
|
lock_dst.right = dstx + w;
|
|
lock_dst.bottom = dsty + h;
|
|
|
|
bpp = GET_BPP(This->surface_desc);
|
|
|
|
/* We need to lock the surfaces, or we won't get refreshes when done. */
|
|
if (src == iface) {
|
|
int pitch;
|
|
|
|
UnionRect(&lock_union, &lock_src, &lock_dst);
|
|
|
|
/* Lock the union of the two rectangles */
|
|
IDirectDrawSurface7_Lock(iface, &lock_union, &ddesc, 0, 0);
|
|
|
|
pitch = This->surface_desc.u1.lPitch;
|
|
|
|
/* Since sdesc was originally copied from this surface's description, we can just reuse it */
|
|
sdesc.lpSurface = (BYTE *)This->surface_desc.lpSurface + lock_src.top * pitch + lock_src.left * bpp;
|
|
ddesc.lpSurface = (BYTE *)This->surface_desc.lpSurface + lock_dst.top * pitch + lock_dst.left * bpp;
|
|
} else {
|
|
sdesc.dwSize = sizeof(sdesc);
|
|
IDirectDrawSurface7_Lock(src, &lock_src, &sdesc, DDLOCK_READONLY, 0);
|
|
ddesc.dwSize = sizeof(ddesc);
|
|
IDirectDrawSurface7_Lock(iface, &lock_dst, &ddesc, DDLOCK_WRITEONLY, 0);
|
|
}
|
|
|
|
/* Handle first the FOURCC surfaces... */
|
|
if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) && (ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)) {
|
|
if (trans)
|
|
FIXME("trans arg not supported when a FOURCC surface is involved\n");
|
|
if (dstx || dsty)
|
|
FIXME("offset for destination surface is not supported\n");
|
|
if (sdesc.u4.ddpfPixelFormat.dwFourCC != sdesc.u4.ddpfPixelFormat.dwFourCC) {
|
|
FIXME("FOURCC->FOURCC copy only supported for the same type of surface\n");
|
|
ret = DDERR_INVALIDPIXELFORMAT;
|
|
goto error;
|
|
}
|
|
memcpy(ddesc.lpSurface, sdesc.lpSurface, ddesc.u1.dwLinearSize);
|
|
goto error;
|
|
}
|
|
if ((sdesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
|
|
(!(ddesc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC))) {
|
|
DoDXTCDecompression(&sdesc, &ddesc);
|
|
goto error;
|
|
}
|
|
|
|
sbuf = (BYTE *) sdesc.lpSurface;
|
|
dbuf = (BYTE *) ddesc.lpSurface;
|
|
|
|
if (trans & (DDBLTFAST_SRCCOLORKEY | DDBLTFAST_DESTCOLORKEY)) {
|
|
DWORD keylow, keyhigh;
|
|
if (trans & DDBLTFAST_SRCCOLORKEY) {
|
|
keylow = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
|
|
keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
|
|
} else {
|
|
/* I'm not sure if this is correct */
|
|
FIXME("DDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
|
|
keylow = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
|
|
keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
|
|
}
|
|
|
|
#define COPYBOX_COLORKEY(type) { \
|
|
type *d, *s, tmp; \
|
|
s = (type *) sdesc.lpSurface; \
|
|
d = (type *) ddesc.lpSurface; \
|
|
for (y = 0; y < h; y++) { \
|
|
for (x = 0; x < w; x++) { \
|
|
tmp = s[x]; \
|
|
if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
|
|
} \
|
|
s = (type *)((BYTE *)s + sdesc.u1.lPitch); \
|
|
d = (type *)((BYTE *)d + ddesc.u1.lPitch); \
|
|
} \
|
|
break; \
|
|
}
|
|
|
|
switch (bpp) {
|
|
case 1: COPYBOX_COLORKEY(BYTE)
|
|
case 2: COPYBOX_COLORKEY(WORD)
|
|
case 4: COPYBOX_COLORKEY(DWORD)
|
|
case 3:
|
|
{
|
|
BYTE *d, *s;
|
|
DWORD tmp;
|
|
s = (BYTE *) sdesc.lpSurface;
|
|
d = (BYTE *) ddesc.lpSurface;
|
|
for (y = 0; y < h; y++) {
|
|
for (x = 0; x < w * 3; x += 3) {
|
|
tmp = (DWORD)s[x] + ((DWORD)s[x + 1] << 8) + ((DWORD)s[x + 2] << 16);
|
|
if (tmp < keylow || tmp > keyhigh) {
|
|
d[x + 0] = s[x + 0];
|
|
d[x + 1] = s[x + 1];
|
|
d[x + 2] = s[x + 2];
|
|
}
|
|
}
|
|
s += sdesc.u1.lPitch;
|
|
d += ddesc.u1.lPitch;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
FIXME("Source color key blitting not supported for bpp %d\n",bpp*8);
|
|
ret = DDERR_UNSUPPORTED;
|
|
goto error;
|
|
}
|
|
#undef COPYBOX_COLORKEY
|
|
} else {
|
|
int width = w * bpp;
|
|
|
|
for (y = 0; y < h; y++) {
|
|
memcpy(dbuf, sbuf, width);
|
|
sbuf += sdesc.u1.lPitch;
|
|
dbuf += ddesc.u1.lPitch;
|
|
}
|
|
}
|
|
|
|
error:
|
|
if (src == iface) {
|
|
IDirectDrawSurface7_Unlock(iface, &lock_union);
|
|
} else {
|
|
IDirectDrawSurface7_Unlock(iface, &lock_dst);
|
|
IDirectDrawSurface7_Unlock(src, &lock_src);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* ChangeUniquenessValue: generic */
|
|
/* DeleteAttachedSurface: generic */
|
|
/* EnumAttachedSurfaces: generic */
|
|
/* EnumOverlayZOrders: generic, unimplemented */
|
|
|
|
BOOL DIB_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl* front,
|
|
IDirectDrawSurfaceImpl* back,
|
|
DWORD dwFlags)
|
|
{
|
|
DIB_DirectDrawSurfaceImpl* front_priv = front->private;
|
|
DIB_DirectDrawSurfaceImpl* back_priv = back->private;
|
|
|
|
TRACE("(%p,%p)\n",front,back);
|
|
|
|
{
|
|
HBITMAP tmp;
|
|
tmp = front_priv->dib.DIBsection;
|
|
front_priv->dib.DIBsection = back_priv->dib.DIBsection;
|
|
back_priv->dib.DIBsection = tmp;
|
|
}
|
|
|
|
{
|
|
void* tmp;
|
|
tmp = front_priv->dib.bitmap_data;
|
|
front_priv->dib.bitmap_data = back_priv->dib.bitmap_data;
|
|
back_priv->dib.bitmap_data = tmp;
|
|
|
|
tmp = front->surface_desc.lpSurface;
|
|
front->surface_desc.lpSurface = back->surface_desc.lpSurface;
|
|
back->surface_desc.lpSurface = tmp;
|
|
}
|
|
|
|
/* client_memory should not be different, but just in case */
|
|
{
|
|
BOOL tmp;
|
|
tmp = front_priv->dib.client_memory;
|
|
front_priv->dib.client_memory = back_priv->dib.client_memory;
|
|
back_priv->dib.client_memory = tmp;
|
|
}
|
|
|
|
return Main_DirectDrawSurface_flip_data(front, back, dwFlags);
|
|
}
|
|
|
|
/* Flip: generic */
|
|
/* FreePrivateData: generic */
|
|
/* GetAttachedSurface: generic */
|
|
/* GetBltStatus: generic */
|
|
/* GetCaps: generic (Returns the caps from This->surface_desc.) */
|
|
/* GetClipper: generic */
|
|
/* GetColorKey: generic */
|
|
|
|
HRESULT DIB_DirectDrawSurface_alloc_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
|
|
{
|
|
DIB_PRIV_VAR(priv, This);
|
|
HDC hDC;
|
|
|
|
TRACE("Grabbing a DC for surface: %p\n", This);
|
|
|
|
hDC = CreateCompatibleDC(0);
|
|
priv->dib.holdbitmap = SelectObject(hDC, priv->dib.DIBsection);
|
|
if (This->palette)
|
|
SelectPalette(hDC, This->palette->hpal, FALSE);
|
|
|
|
*phDC = hDC;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT DIB_DirectDrawSurface_free_dc(IDirectDrawSurfaceImpl* This, HDC hDC)
|
|
{
|
|
DIB_PRIV_VAR(priv, This);
|
|
|
|
TRACE("Releasing DC for surface: %p\n", This);
|
|
|
|
SelectObject(hDC, priv->dib.holdbitmap);
|
|
DeleteDC(hDC);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT DIB_DirectDrawSurface_get_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
|
|
{
|
|
return DIB_DirectDrawSurface_alloc_dc(This, phDC);
|
|
}
|
|
|
|
HRESULT DIB_DirectDrawSurface_release_dc(IDirectDrawSurfaceImpl* This, HDC hDC)
|
|
{
|
|
return DIB_DirectDrawSurface_free_dc(This, hDC);
|
|
}
|
|
|
|
/* GetDDInterface: generic */
|
|
/* GetFlipStatus: generic */
|
|
/* GetLOD: generic */
|
|
/* GetOverlayPosition: generic */
|
|
/* GetPalette: generic */
|
|
/* GetPixelFormat: generic */
|
|
/* GetPriority: generic */
|
|
/* GetPrivateData: generic */
|
|
/* GetSurfaceDesc: generic */
|
|
/* GetUniquenessValue: generic */
|
|
/* Initialize: generic */
|
|
/* IsLost: generic */
|
|
/* Lock: generic with callback? */
|
|
/* PageLock: generic */
|
|
/* PageUnlock: generic */
|
|
|
|
HRESULT WINAPI
|
|
DIB_DirectDrawSurface_Restore(LPDIRECTDRAWSURFACE7 iface)
|
|
{
|
|
TRACE("(%p)\n",iface);
|
|
return DD_OK; /* ??? */
|
|
}
|
|
|
|
/* SetClipper: generic */
|
|
/* SetColorKey: generic */
|
|
/* SetLOD: generic */
|
|
/* SetOverlayPosition: generic */
|
|
|
|
void DIB_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl* This,
|
|
IDirectDrawPaletteImpl* pal)
|
|
{
|
|
if (!pal) return;
|
|
if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
|
|
This->update_palette(This, pal,
|
|
0, pal->palNumEntries,
|
|
pal->palents);
|
|
}
|
|
|
|
void DIB_DirectDrawSurface_update_palette(IDirectDrawSurfaceImpl* This,
|
|
IDirectDrawPaletteImpl* pal,
|
|
DWORD dwStart, DWORD dwCount,
|
|
LPPALETTEENTRY palent)
|
|
{
|
|
RGBQUAD col[256];
|
|
unsigned int n;
|
|
HDC dc;
|
|
|
|
TRACE("updating primary palette\n");
|
|
for (n=0; n<dwCount; n++) {
|
|
col[n].rgbRed = palent[n].peRed;
|
|
col[n].rgbGreen = palent[n].peGreen;
|
|
col[n].rgbBlue = palent[n].peBlue;
|
|
col[n].rgbReserved = 0;
|
|
}
|
|
This->get_dc(This, &dc);
|
|
SetDIBColorTable(dc, dwStart, dwCount, col);
|
|
This->release_dc(This, dc);
|
|
|
|
/* Propagate change to backbuffers if there are any */
|
|
/* Basically this is a modification of the Flip code to find the backbuffer */
|
|
/* and duplicate the palette update there as well */
|
|
if ((This->surface_desc.ddsCaps.dwCaps&(DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
|
|
== (DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
|
|
{
|
|
static DDSCAPS2 back_caps = { DDSCAPS_BACKBUFFER };
|
|
LPDIRECTDRAWSURFACE7 tgt;
|
|
|
|
HRESULT hr = IDirectDrawSurface7_GetAttachedSurface(ICOM_INTERFACE(This,IDirectDrawSurface7),
|
|
&back_caps, &tgt);
|
|
if (!FAILED(hr))
|
|
{
|
|
IDirectDrawSurfaceImpl* target = ICOM_OBJECT(IDirectDrawSurfaceImpl,
|
|
IDirectDrawSurface7,tgt);
|
|
IDirectDrawSurface7_Release(tgt);
|
|
target->get_dc(target, &dc);
|
|
SetDIBColorTable(dc, dwStart, dwCount, col);
|
|
target->release_dc(target, dc);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* SetPalette: generic */
|
|
/* SetPriority: generic */
|
|
/* SetPrivateData: generic */
|
|
|
|
HRESULT WINAPI
|
|
DIB_DirectDrawSurface_SetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
|
|
LPDDSURFACEDESC2 pDDSD, DWORD dwFlags)
|
|
{
|
|
IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
|
|
DIB_PRIV_VAR(priv, This);
|
|
HRESULT hr = DD_OK;
|
|
DWORD flags = pDDSD->dwFlags;
|
|
|
|
if (TRACE_ON(ddraw)) {
|
|
TRACE("(%p)->(%p,%08lx)\n",iface,pDDSD,dwFlags);
|
|
DDRAW_dump_surface_desc(pDDSD);
|
|
}
|
|
|
|
if (pDDSD->dwFlags & DDSD_PIXELFORMAT) {
|
|
flags &= ~DDSD_PIXELFORMAT;
|
|
if (flags & DDSD_LPSURFACE) {
|
|
This->surface_desc.u4.ddpfPixelFormat = pDDSD->u4.ddpfPixelFormat;
|
|
} else {
|
|
FIXME("Change of pixel format without surface re-allocation is not supported !\n");
|
|
}
|
|
}
|
|
if (pDDSD->dwFlags & DDSD_LPSURFACE) {
|
|
HBITMAP oldbmp = priv->dib.DIBsection;
|
|
LPVOID oldsurf = This->surface_desc.lpSurface;
|
|
BOOL oldc = priv->dib.client_memory;
|
|
|
|
flags &= ~DDSD_LPSURFACE;
|
|
|
|
TRACE("new lpSurface=%p\n",pDDSD->lpSurface);
|
|
This->surface_desc.lpSurface = pDDSD->lpSurface;
|
|
priv->dib.client_memory = TRUE;
|
|
|
|
hr = create_dib(This);
|
|
if (FAILED(hr))
|
|
{
|
|
priv->dib.DIBsection = oldbmp;
|
|
This->surface_desc.lpSurface = oldsurf;
|
|
priv->dib.client_memory = oldc;
|
|
return hr;
|
|
}
|
|
|
|
DeleteObject(oldbmp);
|
|
|
|
if (!oldc)
|
|
VirtualFree(oldsurf, 0, MEM_RELEASE);
|
|
}
|
|
if (flags) {
|
|
WARN("Unhandled flags : %08lx\n", flags);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/* Unlock: ???, need callback */
|
|
/* UpdateOverlay: generic */
|
|
/* UpdateOverlayDisplay: generic */
|
|
/* UpdateOverlayZOrder: generic */
|
|
|
|
static const IDirectDrawSurface7Vtbl DIB_IDirectDrawSurface7_VTable =
|
|
{
|
|
Main_DirectDrawSurface_QueryInterface,
|
|
Main_DirectDrawSurface_AddRef,
|
|
Main_DirectDrawSurface_Release,
|
|
Main_DirectDrawSurface_AddAttachedSurface,
|
|
Main_DirectDrawSurface_AddOverlayDirtyRect,
|
|
DIB_DirectDrawSurface_Blt,
|
|
Main_DirectDrawSurface_BltBatch,
|
|
DIB_DirectDrawSurface_BltFast,
|
|
Main_DirectDrawSurface_DeleteAttachedSurface,
|
|
Main_DirectDrawSurface_EnumAttachedSurfaces,
|
|
Main_DirectDrawSurface_EnumOverlayZOrders,
|
|
Main_DirectDrawSurface_Flip,
|
|
Main_DirectDrawSurface_GetAttachedSurface,
|
|
Main_DirectDrawSurface_GetBltStatus,
|
|
Main_DirectDrawSurface_GetCaps,
|
|
Main_DirectDrawSurface_GetClipper,
|
|
Main_DirectDrawSurface_GetColorKey,
|
|
Main_DirectDrawSurface_GetDC,
|
|
Main_DirectDrawSurface_GetFlipStatus,
|
|
Main_DirectDrawSurface_GetOverlayPosition,
|
|
Main_DirectDrawSurface_GetPalette,
|
|
Main_DirectDrawSurface_GetPixelFormat,
|
|
Main_DirectDrawSurface_GetSurfaceDesc,
|
|
Main_DirectDrawSurface_Initialize,
|
|
Main_DirectDrawSurface_IsLost,
|
|
Main_DirectDrawSurface_Lock,
|
|
Main_DirectDrawSurface_ReleaseDC,
|
|
DIB_DirectDrawSurface_Restore,
|
|
Main_DirectDrawSurface_SetClipper,
|
|
Main_DirectDrawSurface_SetColorKey,
|
|
Main_DirectDrawSurface_SetOverlayPosition,
|
|
Main_DirectDrawSurface_SetPalette,
|
|
Main_DirectDrawSurface_Unlock,
|
|
Main_DirectDrawSurface_UpdateOverlay,
|
|
Main_DirectDrawSurface_UpdateOverlayDisplay,
|
|
Main_DirectDrawSurface_UpdateOverlayZOrder,
|
|
Main_DirectDrawSurface_GetDDInterface,
|
|
Main_DirectDrawSurface_PageLock,
|
|
Main_DirectDrawSurface_PageUnlock,
|
|
DIB_DirectDrawSurface_SetSurfaceDesc,
|
|
Main_DirectDrawSurface_SetPrivateData,
|
|
Main_DirectDrawSurface_GetPrivateData,
|
|
Main_DirectDrawSurface_FreePrivateData,
|
|
Main_DirectDrawSurface_GetUniquenessValue,
|
|
Main_DirectDrawSurface_ChangeUniquenessValue,
|
|
Main_DirectDrawSurface_SetPriority,
|
|
Main_DirectDrawSurface_GetPriority,
|
|
Main_DirectDrawSurface_SetLOD,
|
|
Main_DirectDrawSurface_GetLOD
|
|
};
|