source: trunk/src/ddraw/OS2SURFACE.CPP@ 46

Last change on this file since 46 was 46, checked in by sandervl, 26 years ago

* empty log message *
File size: 44.3 KB
Line 
1/*
2 * DirectDraw Surface class
3 *
4 * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
5 *
6 * Project Odin Software License can be found in LICENSE.TXT
7 *
8 */
9/*@Const************************************************************************
10* Defined Constants *
11*******************************************************************************/
12#define INIT_GUID
13#define INCL_MM_OS2
14#define WIN32SDK_NOPOSTWRAPPER
15
16#define BYTE0(a) (char)(a & 0xFF)
17#define BYTE1(a) (char)((a>>8) & 0xFF)
18#define BYTE2(a) (char)((a>>16) & 0xFF)
19#define BYTE3(a) (char)(a>>24)
20
21/*@Header***********************************************************************
22* Header Files *
23*******************************************************************************/
24#include <os2win.h>
25#include <dive.h>
26#include <stdlib.h>
27#include <string.h>
28#include <memory.h>
29
30#include "no.h"
31#include <w_windows.h>
32#include <ddraw.h>
33#include <d3d.h>
34#include <Win32SDKPostWrapper.h>
35
36#include <fourcc.h>
37
38#include "os2ddraw.h"
39#include "os2surface.h"
40#include "misc.h"
41#include "os2util.h"
42#include "asmutil.h"
43
44#ifndef __WATCOMC__
45 #include <builtin.h>
46#endif
47
48
49/* KSO Apr 19 1999: Set correct interface. *
50 * (INTERFACE is used in the THIS and THIS_ macros) */
51#undef INTERFACE
52#define INTERFACE IDirectDrawSurface2
53
54extern DIVE_CAPS dcaps;
55extern FOURCC fccFormats[100];
56
57//******************************************************************************
58//Assumes 8 bits or more per pixel
59//******************************************************************************
60OS2IDirectDrawSurface::OS2IDirectDrawSurface(OS2IDirectDraw *lpDirectDraw,
61 LPDDSURFACEDESC lpDDSurfaceDesc) :
62 Referenced(0), lastError(DD_OK),
63 diveBufNr(-1), lpClipper(NULL),
64 lpPalette(NULL), lpDraw(NULL),
65 fLocked(FALSE), hdcImage(NULL),
66 hbmImage(NULL), bitmapData(NULL),
67 pFrameBuffer(NULL), attached(NULL),
68 flip(NULL),lpBuffer(NULL), ColorKeyFlags(0)
69{
70 ULONG rc;
71
72 lpVtbl = &Vtbl;
73 Vtbl.AddRef = SurfAddRef;
74 Vtbl.Release = SurfRelease;
75 Vtbl.QueryInterface = SurfQueryInterface;
76 Vtbl.AddAttachedSurface = SurfAddAttachedSurface;
77 Vtbl.AddOverlayDirtyRect = SurfAddOverlayDirtyRect;
78 Vtbl.Blt = SurfBlt;
79 Vtbl.BltBatch = SurfBltBatch;
80 Vtbl.BltFast = SurfBltFast;
81 Vtbl.DeleteAttachedSurface = SurfDeleteAttachedSurface;
82 Vtbl.EnumAttachedSurfaces = SurfEnumAttachedSurfaces;
83 Vtbl.EnumOverlayZOrders = SurfEnumOverlayZOrders;
84 Vtbl.Flip = SurfFlip;
85 Vtbl.GetAttachedSurface = SurfGetAttachedSurface;
86 Vtbl.GetBltStatus = SurfGetBltStatus;
87 Vtbl.GetCaps = SurfGetCaps;
88 Vtbl.GetClipper = SurfGetClipper;
89 Vtbl.GetColorKey = SurfGetColorKey;
90 Vtbl.W32_GetDC = SurfGetDC; //KSO Apr 19 1999: side effect of the wrapper...
91 Vtbl.GetFlipStatus = SurfGetFlipStatus;
92 Vtbl.GetOverlayPosition = SurfGetOverlayPosition;
93 Vtbl.GetPalette = SurfGetPalette;
94 Vtbl.GetPixelFormat = SurfGetPixelFormat;
95 Vtbl.GetSurfaceDesc = SurfGetSurfaceDesc;
96 Vtbl.Initialize = SurfInitialize;
97 Vtbl.IsLost = SurfIsLost;
98 Vtbl.Lock = SurfLock;
99 Vtbl.W32_ReleaseDC = SurfReleaseDC;//KSO Apr 19 1999: side effect of the wrapper...
100 Vtbl.Restore = SurfRestore;
101 Vtbl.SetClipper = SurfSetClipper;
102 Vtbl.SetColorKey = SurfSetColorKey;
103 Vtbl.SetOverlayPosition = SurfSetOverlayPosition;
104 Vtbl.SetPalette = SurfSetPalette;
105 Vtbl.Unlock = SurfUnlock;
106 Vtbl.UpdateOverlay = SurfUpdateOverlay;
107 Vtbl.UpdateOverlayDisplay = SurfUpdateOverlayDisplay;
108 Vtbl.UpdateOverlayZOrder = SurfUpdateOverlayZOrder;
109 Vtbl.GetDDInterface = SurfGetDDInterface;
110 Vtbl.PageLock = SurfPageLock;
111 Vtbl.PageUnlock = SurfPageUnlock;
112
113 lpDraw = lpDirectDraw;
114 lpDraw->Vtbl.AddRef((IDirectDraw2*)lpDraw);
115 hDive = lpDirectDraw->GetDiveInstance();
116 surfaceType = DDSCAPS_OFFSCREENPLAIN;
117
118 memcpy((char *)&DDSurfaceDesc, (char *)lpDDSurfaceDesc, sizeof(DDSURFACEDESC));
119
120 //TODO: finish up and do better error checking (can't create multiple
121 // primary surfaces etc etc
122 if(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)
123 height = lpDDSurfaceDesc->dwHeight;
124 if(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)
125 width = lpDDSurfaceDesc->dwWidth;
126
127 if(height == 0)
128 height = lpDraw->GetScreenHeight();
129 if(width == 0)
130 width = lpDraw->GetScreenWidth();
131//test
132 lpDDSurfaceDesc->dwHeight = height;
133 lpDDSurfaceDesc->dwWidth = width;
134
135 //SvL: TODO: Check if DIVE supports all ddraw fourcc codes
136 if(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) {
137 if(lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_FOURCC) {
138 fccColorFormat = lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC;
139 }
140 else {
141 dprintf((" Unsupported pixel format, defaulting to LUT8"));
142 fccColorFormat = FOURCC_LUT8;
143 }
144 }
145 else fccColorFormat = FOURCC_LUT8;
146 screenXFact = 1.0;
147 screenYFact = 1.0;
148 //TODO: base this on the fourcc value!!
149 bpp = 8;
150
151 if(lpDDSurfaceDesc->dwFlags & DDSD_CAPS) {
152 surfaceType = lpDDSurfaceDesc->ddsCaps.dwCaps;
153 if(surfaceType & DDSCAPS_PRIMARYSURFACE) {
154 dprintf((" Primary surface!\n"));
155 diveBufNr = DIVE_BUFFER_SCREEN;
156 pFrameBuffer = lpDraw->GetFrameBuffer();
157 //SvL: Needed for stretching if we're not running in 640x480
158 if(lpDraw->IsFullScreen() == TRUE) {
159 screenYFact = (double)dcaps.ulVerticalResolution/(double)height;
160 screenXFact = (double)dcaps.ulHorizontalResolution/(double)width;
161 }
162 fccColorFormat = FOURCC_SCRN;
163 bpp = dcaps.ulDepth;
164 }
165 if(!(surfaceType & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_OFFSCREENPLAIN))) {
166 lastError = DDERR_INVALIDPARAMS;
167 }
168 }
169 else surfaceType = 0;
170
171 dprintf((" fccColorFormat %c%c%c%c", BYTE0(fccColorFormat), BYTE1(fccColorFormat), BYTE2(fccColorFormat), BYTE3(fccColorFormat)));
172
173 if(height && width && diveBufNr == -1) {
174 diveBufNr = 0; //need to set to 0 for new buffer!
175 lpBuffer = (PBYTE)OS2AllocMem(width*height*bpp/8);
176 if(lpBuffer == NULL) {
177 lastError = DDERR_INVALIDPARAMS;
178 return;
179 }
180 dprintf((" lpBuffer = %X", lpBuffer));
181 rc = DiveAllocImageBuffer(hDive, &diveBufNr, fccColorFormat, width, height, width, lpBuffer);
182 if(rc != DIVE_SUCCESS) {
183 dprintf((" DiveAllocImageBuffer failed with %d", rc));
184 lastError = DDERR_INVALIDPARAMS; //TODO: better errors
185 return;
186 }
187 else {
188 dprintf((" DiveAllocImageBuffer returned %d", diveBufNr));
189 }
190 }
191
192 dprintf((" Buf %X Screen Caps (%d,%d), bitcount %d\n", this, dcaps.ulVerticalResolution, dcaps.ulHorizontalResolution,
193 dcaps.ulDepth));
194
195 //todo: checking for flip & complex bits if backbuffer bit present!
196 if(lpDDSurfaceDesc->dwFlags & DDSD_BACKBUFFERCOUNT) {
197 OS2IDirectDrawSurface *attachedSurface, *tmpSurface = NULL;
198 DDSURFACEDESC surfDescription;
199
200 dprintf((" Create %d background surface(s)", lpDDSurfaceDesc->dwBackBufferCount));
201 memcpy((char *)&surfDescription, (char *)lpDDSurfaceDesc, sizeof(DDSURFACEDESC));
202 surfDescription.ddsCaps.dwCaps &= ~DDSCAPS_PRIMARYSURFACE;
203 surfDescription.dwBackBufferCount = 0;
204 surfDescription.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; //only the first one!
205
206 //SvL: Create background surfaces
207 for(int i=0;i<lpDDSurfaceDesc->dwBackBufferCount;i++) {
208 attachedSurface = new OS2IDirectDrawSurface(lpDirectDraw,
209 &surfDescription);
210 if(tmpSurface) {
211 tmpSurface->attached = attachedSurface;
212 }
213 else {
214 attached = attachedSurface;
215 flip = attached;
216 }
217
218 tmpSurface = attachedSurface;
219 //SvL: All other back surfaces have the flip bit set
220 surfDescription.ddsCaps.dwCaps = DDSCAPS_FLIP;
221 }
222 }
223 memset((char *)&SurfaceCaps, 0, sizeof(DDCAPS));
224 SurfaceCaps.ddsCaps.dwCaps = surfaceType;
225 SurfaceCaps.dwSize = sizeof(DDCAPS);
226 //TODO: might need to change some flags
227 SurfaceCaps.dwCaps = DDCAPS_COLORKEY | DDCAPS_NOHARDWARE;
228 SurfaceCaps.dwCaps2 = DDCAPS2_CERTIFIED; //of course we're certified
229 //TODO: might need to change some flags as we might support more in the future
230 SurfaceCaps.dwCKeyCaps = DDCKEYCAPS_SRCBLT;
231 SurfaceCaps.dwFXCaps = 0;
232 SurfaceCaps.dwFXAlphaCaps = 0;
233 //TODO
234 if(bpp == 8) {
235 SurfaceCaps.dwPalCaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
236 }
237 SurfaceCaps.dwVidMemTotal = 1024*1024; //todo
238 SurfaceCaps.dwVidMemFree = SurfaceCaps.dwVidMemTotal - dcaps.ulVerticalResolution*dcaps.ulVerticalResolution*dcaps.ulDepth/8;
239 SurfaceCaps.dwNumFourCCCodes = 1;
240 SurfaceCaps.dwAlignBoundarySrc = 4;
241 SurfaceCaps.dwAlignSizeDest = 4;
242 SurfaceCaps.dwAlignStrideAlign = 4;
243
244 dprintf(("DirectDrawSurface ctor end!"));
245}
246//******************************************************************************
247//******************************************************************************
248OS2IDirectDrawSurface::~OS2IDirectDrawSurface()
249{
250 if(diveBufNr != -1) {
251 if(fLocked)
252 DiveEndImageBufferAccess(hDive, diveBufNr);
253 fLocked = FALSE;
254 DiveFreeImageBuffer(hDive, diveBufNr);
255 diveBufNr = -1;
256 }
257 if(lpClipper) {
258 lpClipper->Vtbl.Release((IDirectDrawClipper*)lpClipper);
259 lpClipper = NULL;
260 }
261 if(lpPalette) {
262 if(surfaceType & DDSCAPS_PRIMARYSURFACE)
263 lpPalette->RestorePhysPalette();
264 lpPalette->Vtbl.Release((IDirectDrawPalette*)lpPalette);
265 lpPalette = NULL;
266 }
267 if(lpBuffer)
268 OS2FreeMem((char *)lpBuffer);
269 if(hbmImage)
270 DeleteObject((HANDLE)hbmImage);
271 if(hdcImage)
272 DeleteDC(hdcImage);
273 if(bitmapData)
274 free(bitmapData);
275 lpDraw->Vtbl.Release((IDirectDraw2*)lpDraw);
276}
277//******************************************************************************
278//******************************************************************************
279HRESULT __stdcall SurfQueryInterface(THIS, REFIID riid, LPVOID FAR * ppvObj)
280{
281 dprintf(("OS2IDirectDrawSurface::SurfQueryInterface\n"));
282 *ppvObj = NULL;
283
284 if(!IsEqualGUID(riid, IID_IDirectDrawSurface) &&
285 !IsEqualGUID(riid, IID_IDirectDrawSurface2))
286//&& !IsEqualGUID(riid, IID_IUnknown))
287 return E_NOINTERFACE;
288
289 *ppvObj = This;
290
291 SurfAddRef(This);
292
293 return(DD_OK);
294}
295//******************************************************************************
296//******************************************************************************
297ULONG __stdcall SurfAddRef(THIS)
298{
299 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
300
301 dprintf(("OS2IDirectDrawSurface::SurfAddRef %d\n", me->Referenced+1));
302 return ++me->Referenced;
303}
304//******************************************************************************
305//******************************************************************************
306ULONG __stdcall SurfRelease(THIS)
307{
308 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
309
310 dprintf(("OS2IDirectDrawSurface::SurfRelease %d\n", me->Referenced-1));
311 if(me->Referenced) {
312 me->Referenced--;
313 if(me->Referenced == 0) {
314 delete me;
315 return(0);
316 }
317 else return me->Referenced;
318 }
319 else return(0);
320}
321//******************************************************************************
322//******************************************************************************
323HRESULT __stdcall SurfAddAttachedSurface(THIS_ LPDIRECTDRAWSURFACE2)
324{
325 dprintf(("SurfAddAttachedSurfacer\n"));
326 return(DD_OK);
327}
328//******************************************************************************
329//******************************************************************************
330HRESULT __stdcall SurfAddOverlayDirtyRect(THIS_ W32_LPRECT)
331{
332 dprintf(("SurfAddOverlayDirtyRect\n"));
333 return(DD_OK);
334}
335//******************************************************************************
336//******************************************************************************
337HRESULT __stdcall SurfBlt(THIS_ W32_LPRECT lpDestRect, LPDIRECTDRAWSURFACE2 lpDDSrcSurface,
338 W32_LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
339{
340 OS2IDirectDrawSurface *dest = (OS2IDirectDrawSurface *)This;
341 OS2IDirectDrawSurface *src = (OS2IDirectDrawSurface *)lpDDSrcSurface;
342 SETUP_BLITTER blit;
343 ULONG rc;
344 RECTL cliprect;
345
346 dprintf(("SurfBlt to (%d,%d)(%d,%d) from (%d,%d)(%d,%d)\n", lpDestRect->left, lpDestRect->top,
347 lpDestRect->right, lpDestRect->bottom, lpSrcRect->left, lpSrcRect->top,
348 lpSrcRect->right, lpSrcRect->bottom));
349
350 blit.ulStructLen = sizeof(blit);
351 blit.fInvert = FALSE;
352 blit.fccSrcColorFormat = src->fccColorFormat;
353 blit.ulSrcWidth = lpSrcRect->right - lpSrcRect->left;
354 blit.ulSrcHeight = lpSrcRect->bottom - lpSrcRect->top;
355 blit.ulSrcPosX = lpSrcRect->left;
356 blit.ulSrcPosY = lpSrcRect->top;
357
358 blit.fccDstColorFormat = dest->fccColorFormat;
359 blit.ulDstWidth = lpDestRect->right - lpDestRect->left;
360 blit.ulDstHeight = lpDestRect->bottom - lpDestRect->top;
361 blit.lDstPosX = lpDestRect->left;
362 blit.lDstPosY = dcaps.ulVerticalResolution - lpDestRect->bottom;
363 blit.lScreenPosX = 0;
364 blit.lScreenPosY = 0;
365 blit.ulNumDstRects = 1;
366 blit.pVisDstRects = &cliprect;
367 cliprect.top = 0;
368 cliprect.bottom = dcaps.ulVerticalResolution;
369 cliprect.left = lpDestRect->left;
370 cliprect.right = lpDestRect->right;
371#if 0
372 rc = DiveSetupBlitter(dest->hDive, &blit);
373 if(rc != DIVE_SUCCESS) {
374 dprintf(("Error setting up blitter %d\n", rc));
375 return(DDERR_GENERIC);
376 }
377 rc = DiveBlitImage(dest->hDive, src->diveBufNr, dest->diveBufNr);
378 if(rc != DIVE_SUCCESS) {
379 dprintf(("Error while blitting %d\n", rc));
380 return(DDERR_GENERIC);
381 }
382#else
383 char *srcbuf, *destbuf;
384 ULONG srcscanbytes, destscanbytes, i, nrScanLines;
385 OS2RECTL rectl;
386
387 if(dest->diveBufNr == DIVE_BUFFER_SCREEN) {
388 dprintf(("Dest == DIVE_BUFFER_SCREEN\n"));
389 rectl.xLeft = blit.lDstPosX;
390 rectl.yBottom = blit.lDstPosY;
391 rectl.xRight = blit.lDstPosX + blit.ulSrcWidth;
392 rectl.yTop = blit.lDstPosY + blit.ulSrcHeight;
393 destscanbytes = dcaps.ulHorizontalResolution;
394 destbuf = dest->pFrameBuffer;
395 rc = DiveAcquireFrameBuffer(dest->hDive, (PRECTL)&rectl);
396 if(rc != DIVE_SUCCESS) {
397 dprintf(("frame buffer access error %d\n", rc));
398 return(DDERR_INVALIDPARAMS);
399 }
400 }
401 else {
402 rc = DiveBeginImageBufferAccess(dest->hDive, dest->diveBufNr, (PBYTE *)&destbuf,
403 &destscanbytes, &nrScanLines);
404 if(rc != DIVE_SUCCESS) {
405 dprintf(("dest bufffer access error %d\n", rc));
406 return(DDERR_INVALIDPARAMS);
407 }
408 }
409 rc = DiveBeginImageBufferAccess(src->hDive, src->diveBufNr, (PBYTE *)&srcbuf,
410 &srcscanbytes, &nrScanLines);
411 if(rc != DIVE_SUCCESS) {
412 dprintf(("src bufffer access error %d\n", rc));
413 return(DDERR_INVALIDPARAMS);
414 }
415 dprintf(("src %X, dest %X\n", srcbuf, destbuf));
416
417 for(i=0;i<blit.ulSrcHeight;i++) {
418 #ifdef DEBUG1
419 dprintf(("%d blit (%d,%d) from (%d,%d) len %d\n", i, blit.lDstPosX, destscanbytes*lpDestRect->top + i*destscanbytes,
420 blit.ulSrcPosX, srcscanbytes*blit.ulSrcPosY + i*srcscanbytes, blit.ulSrcWidth));
421 dprintf(("dest address %X\n", destbuf + blit.lDstPosX + destscanbytes*lpDestRect->top + i*destscanbytes + blit.ulSrcWidth - 1));
422 #endif
423 memcpy(destbuf + blit.lDstPosX + destscanbytes*lpDestRect->top + i*destscanbytes,
424 srcbuf + blit.ulSrcPosX + srcscanbytes*blit.ulSrcPosY + i*srcscanbytes,
425 blit.ulSrcWidth);
426 }
427
428 if(dest->diveBufNr == DIVE_BUFFER_SCREEN) {
429 DiveDeacquireFrameBuffer(dest->hDive);
430 }
431 else DiveEndImageBufferAccess(dest->hDive, dest->diveBufNr);
432
433 DiveEndImageBufferAccess(src->hDive, src->diveBufNr);
434
435#endif
436 return(DD_OK);
437}
438//******************************************************************************
439//******************************************************************************
440HRESULT __stdcall SurfBltBatch(THIS_ LPDDBLTBATCH, DWORD, DWORD )
441{
442 dprintf(("SurfBltBatch\n"));
443 return(DD_OK);
444}
445//******************************************************************************
446//******************************************************************************
447HRESULT __stdcall SurfBltFast(THIS_ DWORD dwDestX, DWORD dwDestY,
448 LPDIRECTDRAWSURFACE2 srcSurface,
449 W32_LPRECT lpSrcRect, DWORD dwTrans)
450{
451 OS2IDirectDrawSurface *src = (OS2IDirectDrawSurface *)srcSurface;
452 OS2IDirectDrawSurface *dest = (OS2IDirectDrawSurface *)This;
453 SETUP_BLITTER blit;
454 ULONG rc;
455 RECTL cliprect;
456
457 dprintf(("SurfBltFast (%d,%d) (%d,%d) to (%d,%d) dest %X src %X\n", lpSrcRect->left, lpSrcRect->top, lpSrcRect->right, lpSrcRect->bottom, dwDestX, dwDestY, dest, src));
458
459 blit.ulStructLen = sizeof(blit);
460 blit.fInvert = FALSE;
461 blit.fccSrcColorFormat = src->fccColorFormat;
462 blit.ulSrcWidth = lpSrcRect->right - lpSrcRect->left;
463 blit.ulSrcHeight = lpSrcRect->bottom - lpSrcRect->top;
464 blit.ulSrcPosX = lpSrcRect->left;
465 blit.ulSrcPosY = lpSrcRect->top;
466
467 //to prevent inaccuracies when stretching
468 if(blit.ulSrcWidth == src->lpDraw->GetScreenWidth()) {
469 blit.ulDstWidth = dcaps.ulHorizontalResolution;
470 }
471 else blit.ulDstWidth = (int)((double)blit.ulSrcWidth*dest->screenXFact);
472
473 //to prevent inaccuracies when stretching
474 if(blit.ulSrcHeight == src->lpDraw->GetScreenHeight()) {
475 blit.ulDstHeight = dcaps.ulVerticalResolution;
476 }
477 else blit.ulDstHeight = (int)((double)blit.ulSrcHeight*dest->screenYFact);
478
479 blit.fccDstColorFormat = dest->fccColorFormat;
480 blit.lDstPosX = (int)((double)dwDestX*dest->screenXFact);
481 blit.lDstPosY = (int)((double)dwDestY*dest->screenXFact);
482 blit.lScreenPosX = 0;
483 blit.lScreenPosY = 0;
484
485 blit.ulNumDstRects = 1;
486 blit.pVisDstRects = &cliprect;
487 cliprect.top = 0;
488 cliprect.bottom = dcaps.ulVerticalResolution;
489 cliprect.left = 0;
490 cliprect.right = dcaps.ulHorizontalResolution;
491
492 //We can't do anything but simple 1:1 blitting ourselves
493 if(src->diveBufNr == DIVE_BUFFER_SCREEN || dest->diveBufNr == DIVE_BUFFER_SCREEN ||
494 blit.fccSrcColorFormat != blit.fccDstColorFormat ||
495 blit.ulDstWidth != blit.ulSrcWidth || blit.ulDstHeight != blit.ulSrcHeight)
496 {
497//SvL: Other color key types not supported in dive (dest)
498 if(dwTrans & DDBLTFAST_SRCCOLORKEY && src->ColorKeyFlags & DDCKEY_SRCBLT) {
499 dprintf(("Set colorkey for blitting"));
500 rc = DiveSetTransparentBlitMode(dest->hDive, DIVE_TBM_EXCLUDE_SOURCE_VALUE,
501 src->ColorSpaceLowValue[COLORKEY_SRC],
502 src->ColorSpaceHighValue[COLORKEY_SRC]);
503 if(rc != DIVE_SUCCESS) {
504 dprintf(("Error setting up colorkey for blitter %d\n", rc));
505 return(DDERR_GENERIC);
506 }
507 }
508// dprintf(("Blit: (%d,%d) (%d,%d) to (%d,%d) (%d,%d)", blit.ulSrcPosX, blit.ulSrcPosY, blit.ulSrcWidth, blit.ulSrcHeight, blit.lDstPosX, blit.lDstPosY, blit.ulDstWidth, blit.ulDstHeight));
509 rc = DiveSetupBlitter(dest->hDive, &blit);
510 if(rc != DIVE_SUCCESS) {
511 dprintf(("Error setting up blitter %d\n", rc));
512 return(DDERR_GENERIC);
513 }
514 rc = DiveBlitImage(dest->hDive, src->diveBufNr, dest->diveBufNr);
515 if(rc != DIVE_SUCCESS) {
516 dprintf(("Error while blitting %d\n", rc));
517 return(DDERR_GENERIC);
518 }
519 }
520 else { //manual blit
521 PBYTE srcbuf, destbuf;
522 ULONG i, j, destscanlinesize, srcscanlinesize, blitlinesize;
523
524 srcbuf = src->lpBuffer + blit.ulSrcPosX + src->width*blit.ulSrcPosY;
525 destbuf = dest->lpBuffer + blit.lDstPosX + dest->width*blit.lDstPosY;
526
527 if(blit.ulSrcWidth == src->width && blit.ulSrcWidth == dest->width) {
528 //TODO: other colorkey types, ranges and only 8 bits supported now!!
529 if(dwTrans & DDBLTFAST_SRCCOLORKEY && src->ColorKeyFlags & DDCKEY_SRCBLT) {
530 BlitColorKey8(destbuf, srcbuf, src->ColorSpaceLowValue[COLORKEY_SRC],
531 blit.ulSrcWidth*blit.ulSrcHeight*src->bpp/8);
532 }
533 else {
534 memcpy(destbuf, srcbuf, blit.ulSrcWidth*blit.ulSrcHeight*src->bpp/8);
535 }
536 }
537 else {
538 destscanlinesize = dest->width*dest->bpp/8;
539 srcscanlinesize = src->width*src->bpp/8;
540 blitlinesize = blit.ulSrcWidth*src->bpp/8;
541
542 //TODO: other colorkey types, ranges and only 8 bits supported now!!
543 if(dwTrans & DDBLTFAST_SRCCOLORKEY && src->ColorKeyFlags & DDCKEY_SRCBLT) {
544#if 0
545 BYTE colorkey = (BYTE)src->ColorSpaceLowValue[COLORKEY_SRC];
546 PBYTE endpos;
547 for(i=0;i<blit.ulSrcHeight;i++) {
548 endpos = destbuf + blitlinesize;
549 while(destbuf < endpos) {
550 if(*srcbuf == colorkey) {
551 destbuf++;
552 }
553 else *destbuf++ = *srcbuf;
554 srcbuf++;
555 }
556 destbuf += (destscanlinesize-blitlinesize);
557 srcbuf += (srcscanlinesize-blitlinesize);
558 }
559#else
560 for(i=0;i<blit.ulSrcHeight;i++) {
561 BlitColorKey8(destbuf+i*destscanlinesize, srcbuf+i*srcscanlinesize,
562 src->ColorSpaceLowValue[COLORKEY_SRC], blitlinesize);
563 }
564#endif
565 }
566 else {
567 for(i=0;i<blit.ulSrcHeight;i++) {
568 memcpy(destbuf + i*destscanlinesize, srcbuf + i*srcscanlinesize,
569 blitlinesize);
570 }
571 }
572 }
573 }
574 return(DD_OK);
575}
576//******************************************************************************
577//******************************************************************************
578HRESULT __stdcall SurfDeleteAttachedSurface(THIS_ DWORD,LPDIRECTDRAWSURFACE2)
579{
580 dprintf(("SurfDeleteAttachedSurface\n"));
581 return(DD_OK);
582}
583//******************************************************************************
584//******************************************************************************
585HRESULT __stdcall SurfEnumAttachedSurfaces(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK)
586{
587 dprintf(("SurfEnumAttachedSurfaces\n"));
588 return(DD_OK);
589}
590//******************************************************************************
591//******************************************************************************
592HRESULT __stdcall SurfEnumOverlayZOrders(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK)
593{
594 dprintf(("SurfEnumOverlayZOrders\n"));
595 return(DD_OK);
596}
597//******************************************************************************
598//******************************************************************************
599HRESULT __stdcall SurfFlip(THIS_ LPDIRECTDRAWSURFACE2 lpDDSurfaceTargetOverride, DWORD dwFlags)
600{
601 OS2IDirectDrawSurface *dest = (OS2IDirectDrawSurface *)This;
602 OS2IDirectDrawSurface *src = (OS2IDirectDrawSurface *)dest->flip;
603 SETUP_BLITTER blit;
604 ULONG rc;
605 RECTL cliprect;
606
607 dprintf(("SurfFlip dest %X, src %X", dest, src));
608 if(dest == NULL || src == NULL) {
609 return DDERR_INVALIDOBJECT;
610 }
611 if(lpDDSurfaceTargetOverride) {
612 dprintf(("SurfFlip, lpDDSurfaceTargetOverride not supported yet\n"));
613 return(DDERR_UNSUPPORTED);
614 }
615 if(!(dest->surfaceType & DDSCAPS_PRIMARYSURFACE) ||
616 src == NULL) {
617 return(DDERR_INVALIDOBJECT);
618 }
619
620 dprintf(("SurfFlip (%d,%d) (%d,%d) %d %d", src->width, src->height, dest->width, dest->height, src->diveBufNr, dest->diveBufNr));
621
622 blit.ulStructLen = sizeof(blit);
623 blit.fInvert = FALSE;
624 blit.fccSrcColorFormat = src->fccColorFormat;
625 blit.ulSrcWidth = src->width;
626 blit.ulSrcHeight = src->height;
627 blit.ulSrcPosX = 0;
628 blit.ulSrcPosY = 0;
629
630 //to prevent inaccuracies when stretching
631 if(blit.ulSrcWidth == src->lpDraw->GetScreenWidth()) {
632 blit.ulDstWidth = dcaps.ulHorizontalResolution;
633 }
634 else blit.ulDstWidth = (int)((double)blit.ulSrcWidth*dest->screenXFact);
635
636 //to prevent inaccuracies when stretching
637 if(blit.ulSrcHeight == src->lpDraw->GetScreenHeight()) {
638 blit.ulDstHeight = dcaps.ulVerticalResolution;
639 }
640 else blit.ulDstHeight = (int)((double)blit.ulSrcHeight*dest->screenYFact);
641
642 blit.fccDstColorFormat = dest->fccColorFormat;
643 blit.lDstPosX = 0;
644 blit.lDstPosY = 0;
645 blit.lScreenPosX = 0;
646 blit.lScreenPosY = 0;
647 blit.ulNumDstRects = 1;
648 blit.pVisDstRects = &cliprect;
649 cliprect.top = 0;
650 cliprect.bottom = blit.ulDstHeight;
651 cliprect.left = 0;
652 cliprect.right = blit.ulDstWidth;
653
654// dprintf(("Flip: (%d,%d) (%d,%d) to (%d,%d) (%d,%d)", blit.ulSrcPosX, blit.ulSrcPosY, blit.ulSrcWidth, blit.ulSrcHeight, blit.lDstPosX, blit.lDstPosY, blit.ulDstWidth, blit.ulDstHeight));
655 rc = DiveSetupBlitter(dest->hDive, &blit);
656 if(rc != DIVE_SUCCESS) {
657 dprintf(("Error setting up blitter %d\n", rc));
658 return(DDERR_GENERIC);
659 }
660 rc = DiveBlitImage(dest->hDive, src->diveBufNr, dest->diveBufNr);
661 if(rc != DIVE_SUCCESS) {
662 dprintf(("Error while blitting %d\n", rc));
663 return(DDERR_GENERIC);
664 }
665
666 //find next flip back surface if present
667 if(src->attached) {
668 dest->flip = src->attached;
669 }
670 else dest->flip = dest->attached; //start with first back buffer
671 return(DD_OK);
672}
673//******************************************************************************
674//******************************************************************************
675HRESULT __stdcall SurfGetAttachedSurface(THIS_ LPDDSCAPS lpddscaps, LPDIRECTDRAWSURFACE2 FAR *lpAttachedSurface)
676{
677 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
678 OS2IDirectDrawSurface *attached = me->attached;
679
680 if(me == NULL) {
681 return DDERR_INVALIDOBJECT;
682 }
683 while(attached) {
684 dprintf(("SurfGetAttachedSurface %x %x\n", attached->DDSurfaceDesc.ddsCaps.dwCaps, lpddscaps->dwCaps));
685 if(attached->DDSurfaceDesc.ddsCaps.dwCaps == lpddscaps->dwCaps) {
686 *lpAttachedSurface = (LPDIRECTDRAWSURFACE2)attached;
687 return(DD_OK);
688 }
689 attached = attached->attached;
690 }
691 return(DDERR_NOTFOUND);
692}
693//******************************************************************************
694//******************************************************************************
695HRESULT __stdcall SurfGetBltStatus(THIS_ DWORD)
696{
697 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
698
699 dprintf(("SurfGetBltStatus\n"));
700 if(me == NULL) {
701 return DDERR_INVALIDOBJECT;
702 }
703 return(DD_OK);
704}
705//******************************************************************************
706//******************************************************************************
707HRESULT __stdcall SurfGetCaps(THIS_ LPDDSCAPS lpCaps)
708{
709 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
710
711 dprintf(("SurfGetCaps\n"));
712 if(me == NULL || lpCaps == NULL) {
713 return DDERR_INVALIDOBJECT;
714 }
715 lpCaps->dwCaps = me->surfaceType;
716
717 return(DD_OK);
718}
719//******************************************************************************
720//******************************************************************************
721HRESULT __stdcall SurfGetClipper(THIS_ LPDIRECTDRAWCLIPPER FAR *lplpClipper)
722{
723 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
724
725 dprintf(("SurfGetClipper\n"));
726 if(me == NULL) {
727 return DDERR_INVALIDOBJECT;
728 }
729 if(me->lpClipper) {
730 *lplpClipper = (LPDIRECTDRAWCLIPPER) me->lpClipper;
731 return(DD_OK);
732 }
733 else return(DDERR_NOCLIPPERATTACHED);
734}
735//******************************************************************************
736//******************************************************************************
737HRESULT __stdcall SurfGetColorKey(THIS_ DWORD dwFlags, LPDDCOLORKEY lpColorkey)
738{
739 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
740
741 dprintf(("SurfGetColorKey\n"));
742 if(me == NULL) {
743 return DDERR_INVALIDOBJECT;
744 }
745
746 if(dwFlags & DDCKEY_DESTBLT) {
747 lpColorkey->dwColorSpaceLowValue = me->ColorSpaceLowValue[COLORKEY_DEST];
748 lpColorkey->dwColorSpaceHighValue = me->ColorSpaceHighValue[COLORKEY_DEST];
749 return(DD_OK);
750 }
751 if(dwFlags & DDCKEY_DESTOVERLAY) {
752 lpColorkey->dwColorSpaceLowValue = me->ColorSpaceLowValue[COLORKEY_DESTOVERLAY];
753 lpColorkey->dwColorSpaceHighValue = me->ColorSpaceHighValue[COLORKEY_DESTOVERLAY];
754 return(DD_OK);
755 }
756 if(dwFlags & DDCKEY_SRCBLT) {
757 lpColorkey->dwColorSpaceLowValue = me->ColorSpaceLowValue[COLORKEY_SRC];
758 lpColorkey->dwColorSpaceHighValue = me->ColorSpaceHighValue[COLORKEY_SRC];
759 return(DD_OK);
760 }
761 if(dwFlags & DDCKEY_SRCOVERLAY) {
762 lpColorkey->dwColorSpaceLowValue = me->ColorSpaceLowValue[COLORKEY_SRCOVERLAY];
763 lpColorkey->dwColorSpaceHighValue = me->ColorSpaceHighValue[COLORKEY_SRCOVERLAY];
764 return(DD_OK);
765 }
766 return(DDERR_INVALIDPARAMS);
767}
768//******************************************************************************
769//******************************************************************************
770HRESULT __stdcall SurfGetDC(THIS_ W32_HDC FAR *hdc)
771{
772 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
773
774 dprintf(("SurfGetDC %X\n", me));
775 if(me == NULL) {
776 return DDERR_INVALIDOBJECT;
777 }
778
779 if(me->surfaceType & DDSCAPS_PRIMARYSURFACE) {
780 dprintf(("Primary surface!\n"));
781 }
782
783 if(me->fLocked) {
784 return(DDERR_DCALREADYCREATED);
785 }
786 me->fLocked = TRUE;
787 if(me->hdcImage == NULL && me->hbmImage == NULL) {
788 me->hdcImage = CreateCompatibleDC(NULL);
789 if(me->hdcImage == NULL) {
790 dprintf(("Can't create compatible DC!\n"));
791 me->fLocked = FALSE;
792 return(DDERR_GENERIC);
793 }
794 dprintf(("CreateBitmap %d %d", me->width, me->height));
795 me->hbmImage = (HBITMAP)CreateBitmap(me->width, me->height, 1, me->bpp, NULL); //KSO Apr 19 1999: TODO! Why do I have to case this?
796 if(me->hbmImage == NULL) {
797 dprintf(("Can't create compatible bitmap!\n"));
798 DeleteDC(me->hdcImage);
799 me->hdcImage = NULL;
800 me->fLocked = FALSE;
801 return(DDERR_GENERIC);
802 }
803 if((me->hgdiOld = SelectObject(me->hdcImage, (HGDIOBJ)me->hbmImage)) == NULL) {
804 dprintf(("Can't select bitmap into dc!\n"));
805 DeleteDC(me->hdcImage);
806 me->hdcImage = NULL;
807 DeleteObject((HANDLE)me->hbmImage);
808 me->hbmImage = NULL;
809 me->fLocked = FALSE;
810 return(DDERR_GENERIC);
811 }
812 me->bitmapData = (char *)malloc(sizeof(BITMAPINFOHEADER) +
813 me->width*me->height*me->bpp/8);
814 }
815 *hdc = (W32_HDC)me->hdcImage;
816 return(DD_OK);
817}
818//******************************************************************************
819//******************************************************************************
820HRESULT __stdcall SurfGetFlipStatus(THIS_ DWORD)
821{
822 dprintf(("SurfGetFlipStatus\n"));
823 return(DD_OK);
824}
825//******************************************************************************
826//******************************************************************************
827HRESULT __stdcall SurfGetOverlayPosition(THIS_ LPLONG, LPLONG )
828{
829 dprintf(("SurfGetOverlayPosition\n"));
830 return(DD_OK);
831}
832//******************************************************************************
833//******************************************************************************
834HRESULT __stdcall SurfGetPalette(THIS_ LPDIRECTDRAWPALETTE FAR *lplpPalette)
835{
836 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
837
838 dprintf(("SurfGetPalette\n"));
839 if(me == NULL) {
840 return DDERR_INVALIDOBJECT;
841 }
842 if(me->lpPalette) {
843 *lplpPalette = (LPDIRECTDRAWPALETTE)me->lpPalette;
844 return(DD_OK);
845 }
846 else return(DDERR_NOPALETTEATTACHED);
847}
848//******************************************************************************
849//******************************************************************************
850HRESULT __stdcall SurfGetPixelFormat(THIS_ LPDDPIXELFORMAT)
851{
852 dprintf(("SurfGetPixelFormat\n"));
853 return(DD_OK);
854}
855//******************************************************************************
856//******************************************************************************
857HRESULT __stdcall SurfGetSurfaceDesc(THIS_ LPDDSURFACEDESC lpSurface)
858{
859 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
860 ULONG dwFlags;
861
862 if(me == NULL) {
863 return DDERR_INVALIDOBJECT;
864 }
865 if(lpSurface == NULL)
866 return(DDERR_INVALIDPARAMS);
867
868 dwFlags = lpSurface->dwFlags;
869 dprintf(("SurfGetSurfaceDesc %X\n", lpSurface->dwFlags));
870 memcpy((char *)lpSurface, (char *)&me->DDSurfaceDesc, sizeof(DDSURFACEDESC));
871
872 lpSurface->dwFlags = dwFlags;
873 if(lpSurface->dwFlags & DDSD_HEIGHT) {
874 lpSurface->dwHeight = me->height;
875 }
876 if(lpSurface->dwFlags & DDSD_WIDTH) {
877 lpSurface->dwWidth = me->width;
878 }
879 //TODO: handle rest of flags
880 return(DD_OK);
881}
882//******************************************************************************
883//******************************************************************************
884HRESULT __stdcall SurfInitialize(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC)
885{
886 dprintf(("SurfInitialize\n"));
887 return(DD_OK);
888}
889//******************************************************************************
890//******************************************************************************
891HRESULT __stdcall SurfIsLost(THIS)
892{
893 dprintf(("SurfIsLost\n"));
894 return(DD_OK);
895}
896//******************************************************************************
897//******************************************************************************
898HRESULT __stdcall SurfLock(THIS_ W32_LPRECT lpRect, LPDDSURFACEDESC lpSurfaceDesc,
899 DWORD dwFlags, W32_HANDLE hEvent)
900{
901 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
902 ULONG pImageBuffer, nrBytesPerScanLine, nrScanLines, rc;
903 OS2RECTL rectl;
904 static int times = 0;
905
906 dprintf(("SurfLock %X %X %d %d\n", me, (int)lpRect, dwFlags, hEvent));
907 if(me == NULL) {
908 return DDERR_INVALIDOBJECT;
909 }
910
911 if(me->fLocked) {
912 dprintf(("SurfLock: Surface already locked\n"));
913 return(DDERR_SURFACEBUSY);
914 }
915 me->fLocked = TRUE; //TODO: not really safe
916 if(me->diveBufNr == DIVE_BUFFER_SCREEN) {
917 if(lpRect) {
918 rectl.xLeft = lpRect->left;
919 rectl.yBottom = lpRect->bottom;
920 rectl.xRight = lpRect->right;
921 rectl.yTop = lpRect->top;
922 }
923 else {
924 rectl.xLeft = 0;
925 rectl.yBottom = me->lpDraw->GetScreenHeight();
926 rectl.xRight = me->lpDraw->GetScreenWidth();
927 rectl.yTop = 0;
928 }
929 dprintf(("SurfLock: Screen buffer!\n"));
930 rc = DiveAcquireFrameBuffer(me->hDive, (PRECTL)&rectl);
931 if(rc != DIVE_SUCCESS) {
932 dprintf(("frame buffer access error %d\n", rc));
933 me->fLocked = FALSE;
934 return(DDERR_INVALIDPARAMS);
935 }
936 pImageBuffer = (ULONG)me->pFrameBuffer;
937 }
938 else {
939 rc = DiveBeginImageBufferAccess(me->hDive, me->diveBufNr, (PBYTE *)&pImageBuffer,
940 &nrBytesPerScanLine, &nrScanLines);
941 if(rc != DIVE_SUCCESS) {
942 dprintf(("SurfLock: DiveBeginImageBufferAccess returned %d\n", rc));
943 me->fLocked = FALSE;
944 return(DDERR_INVALIDPARAMS);
945 }
946 }
947
948 if(!(dwFlags & DDLOCK_SURFACEMEMORYPTR) && lpRect != NULL) {
949 pImageBuffer += lpRect->top*nrBytesPerScanLine + lpRect->left;
950 lpSurfaceDesc->lpSurface = (LPVOID)pImageBuffer;
951 dprintf(("SurfLock %X (x,y) = (%d,%d)\n", pImageBuffer, lpRect->top, lpRect->left));
952 }
953 else {
954 dprintf(("SurfLock %X \n", pImageBuffer));
955 }
956 //copy buffer address in surface structure
957 me->DDSurfaceDesc.lpSurface = (LPVOID)pImageBuffer;
958 memcpy((char *)lpSurfaceDesc, (char *)&me->DDSurfaceDesc, sizeof(DDSURFACEDESC));
959
960 lpSurfaceDesc->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
961 lpSurfaceDesc->dwHeight = me->height;
962 lpSurfaceDesc->dwWidth = me->width;
963 lpSurfaceDesc->lPitch = me->width*me->bpp/8;
964 memset((char *)&lpSurfaceDesc->ddpfPixelFormat, 0, sizeof(DDPIXELFORMAT));
965 lpSurfaceDesc->ddpfPixelFormat.dwFourCC = me->fccColorFormat;
966 lpSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
967 lpSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC | DDPF_PALETTEINDEXED8 | DDPF_RGB;
968 lpSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = 8;
969 return(DD_OK);
970}
971//******************************************************************************
972//******************************************************************************
973HRESULT __stdcall SurfReleaseDC(THIS_ W32_HDC hdc)
974{
975 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
976 ULONG pImageBuffer, nrBytesPerScanLine, nrScanLines, rc;
977 int i;
978
979 dprintf(("SurfReleaseDC %X\n", me));
980 if(me == NULL) {
981 return DDERR_INVALIDOBJECT;
982 }
983
984 if((HDC)hdc != me->hdcImage) {
985 dprintf(("hdc != me->hdcImage %d != %d", hdc, me->hdcImage));
986 return(DDERR_INVALIDOBJECT);
987 }
988 rc = GetBitmapBits((HANDLE)me->hbmImage, me->width*me->height*me->bpp/8, me->bitmapData);
989 if(rc == 0) {
990 dprintf(("GetBitmapBits error"));
991 return(DDERR_INVALIDOBJECT);
992 }
993
994 rc = DiveBeginImageBufferAccess(me->hDive, me->diveBufNr, (PBYTE *)&pImageBuffer,
995 &nrBytesPerScanLine, &nrScanLines);
996 if(rc != DIVE_SUCCESS) {
997 dprintf(("DiveBeginImageBufferAccess returned %d", rc));
998 me->fLocked = FALSE;
999 return(DDERR_GENERIC);
1000 }
1001 dprintf(("SurfReleaseDC; copy bitmap to image buffer %d %d", me->width, me->height));
1002
1003 if(memcmp((char *)pImageBuffer, me->bitmapData, me->height*me->width*me->bpp/8) == 0) {
1004 dprintf(("identical!!"));
1005 }
1006 memcpy((char *)pImageBuffer, me->bitmapData, me->height*me->width*me->bpp/8);
1007
1008 DiveEndImageBufferAccess(me->hDive, me->diveBufNr);
1009 me->fLocked = FALSE;
1010 return(DD_OK);
1011}
1012//******************************************************************************
1013//******************************************************************************
1014HRESULT __stdcall SurfRestore(THIS)
1015{
1016 dprintf(("SurfRestore\n"));
1017 return(DD_OK);
1018}
1019//******************************************************************************
1020//******************************************************************************
1021HRESULT __stdcall SurfSetClipper(THIS_ LPDIRECTDRAWCLIPPER lpClipper)
1022{
1023 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
1024
1025 dprintf(("SurfSetClipper\n"));
1026 if(me == NULL) {
1027 return DDERR_INVALIDOBJECT;
1028 }
1029 if(lpClipper == NULL) {//deattach surface
1030 if(me->lpClipper) {
1031 me->lpClipper->Vtbl.Release((IDirectDrawClipper*)me->lpClipper);
1032 me->lpClipper = NULL;
1033 return(DD_OK);
1034 }
1035 else return(DDERR_NOCLIPPERATTACHED);
1036 }
1037 if(lpClipper == (LPDIRECTDRAWCLIPPER)me->lpClipper)
1038 return(DD_OK); //already attached
1039 if(me->lpClipper != NULL) {
1040 me->lpClipper->Vtbl.Release((IDirectDrawClipper*)me->lpClipper); //attach other surface
1041 return(DD_OK);
1042 }
1043 me->lpClipper = (OS2IDirectDrawClipper *)lpClipper;
1044 me->lpClipper->Vtbl.AddRef((IDirectDrawClipper*)me->lpClipper);
1045 return(DD_OK);
1046}
1047//******************************************************************************
1048//******************************************************************************
1049HRESULT __stdcall SurfSetColorKey(THIS_ DWORD dwFlags, LPDDCOLORKEY lpColorkey)
1050{
1051 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
1052
1053 dprintf(("SurfSetColorKey\n"));
1054 if(me == NULL) {
1055 return DDERR_INVALIDOBJECT;
1056 }
1057 me->ColorKeyFlags |= dwFlags;
1058 if(dwFlags & DDCKEY_DESTBLT) {
1059 me->ColorSpaceLowValue[COLORKEY_DEST] = lpColorkey->dwColorSpaceLowValue;
1060 me->ColorSpaceHighValue[COLORKEY_DEST] = lpColorkey->dwColorSpaceHighValue;
1061 return(DD_OK);
1062 }
1063 if(dwFlags & DDCKEY_DESTOVERLAY) {
1064 me->ColorSpaceLowValue[COLORKEY_DESTOVERLAY] = lpColorkey->dwColorSpaceLowValue;
1065 me->ColorSpaceHighValue[COLORKEY_DESTOVERLAY] = lpColorkey->dwColorSpaceHighValue;
1066 return(DD_OK);
1067 }
1068 if(dwFlags & DDCKEY_SRCBLT) {
1069 me->ColorSpaceLowValue[COLORKEY_SRC] = lpColorkey->dwColorSpaceLowValue;
1070 me->ColorSpaceHighValue[COLORKEY_SRC] = lpColorkey->dwColorSpaceHighValue;
1071 return(DD_OK);
1072 }
1073 if(dwFlags & DDCKEY_SRCOVERLAY) {
1074 me->ColorSpaceLowValue[COLORKEY_SRCOVERLAY] = lpColorkey->dwColorSpaceLowValue;
1075 me->ColorSpaceHighValue[COLORKEY_SRCOVERLAY] = lpColorkey->dwColorSpaceHighValue;
1076 return(DD_OK);
1077 }
1078 return(DDERR_INVALIDPARAMS);
1079}
1080//******************************************************************************
1081//******************************************************************************
1082HRESULT __stdcall SurfSetOverlayPosition(THIS_ LONG, LONG )
1083{
1084 dprintf(("SurfSetOverlayPosition\n"));
1085 return(DD_OK);
1086}
1087//******************************************************************************
1088//******************************************************************************
1089HRESULT __stdcall SurfSetPalette(THIS_ LPDIRECTDRAWPALETTE lpPalette)
1090{
1091 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
1092
1093 dprintf(("SurfSetPalette %X\n", me));
1094 if(me == NULL) {
1095 return DDERR_INVALIDOBJECT;
1096 }
1097 if(lpPalette == NULL) {//deattach palette
1098 if(me->lpPalette) {
1099 me->lpPalette->Vtbl.Release((IDirectDrawPalette*)me->lpPalette);
1100 me->lpPalette = NULL;
1101 return(DD_OK);
1102 }
1103 else return(DDERR_NOCLIPPERATTACHED);
1104 }
1105 if(lpPalette == (LPDIRECTDRAWPALETTE)me->lpPalette)
1106 return(DD_OK); //already attached
1107//?????
1108#if 0
1109 if(me->lpPalette != NULL) {
1110 me->lpClipper->Vtbl.Release(me->lpPalette); //attach other palette
1111 return(DD_OK);
1112 }
1113#endif
1114
1115 me->lpPalette = (OS2IDirectDrawPalette *)lpPalette;
1116 me->lpPalette->Vtbl.AddRef((IDirectDrawPalette*)me->lpPalette);
1117 if(me->surfaceType & DDSCAPS_PRIMARYSURFACE)
1118 me->lpPalette->SetPhysPalette();
1119
1120 return(DD_OK);
1121}
1122//******************************************************************************
1123//******************************************************************************
1124HRESULT __stdcall SurfUnlock(THIS_ LPVOID lpSurfaceData)
1125{
1126 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
1127
1128 dprintf(("SurfUnlock\n"));
1129 if(me == NULL) {
1130 return DDERR_INVALIDOBJECT;
1131 }
1132 if(me->fLocked == FALSE)
1133 return(DDERR_NOTLOCKED);
1134
1135 if(me->diveBufNr == DIVE_BUFFER_SCREEN) {
1136 DiveDeacquireFrameBuffer(me->hDive);
1137 dprintf(("SurfUnlock: Frame buffer unlocked\n"));
1138 me->fLocked = FALSE;
1139 return(DD_OK);
1140 }
1141
1142 if(lpSurfaceData != NULL &&
1143 ((int)lpSurfaceData < (int)me->DDSurfaceDesc.lpSurface ||
1144 (int)lpSurfaceData > (int)me->DDSurfaceDesc.lpSurface + me->height*me->width)) {
1145 dprintf(("SurfUnlock: invalid params\n"));
1146 return(DDERR_INVALIDPARAMS);
1147 }
1148 me->fLocked = FALSE;
1149 DiveEndImageBufferAccess(me->hDive, me->diveBufNr);
1150
1151 dprintf(("SurfUnlock ok\n"));
1152 return(DD_OK);
1153}
1154//******************************************************************************
1155//******************************************************************************
1156HRESULT __stdcall SurfUpdateOverlay(THIS_ W32_LPRECT, LPDIRECTDRAWSURFACE2, W32_LPRECT,DWORD, LPDDOVERLAYFX)
1157{
1158 dprintf(("SurfUpdateOverlay\n"));
1159 return(DD_OK);
1160}
1161//******************************************************************************
1162//******************************************************************************
1163HRESULT __stdcall SurfUpdateOverlayDisplay(THIS_ DWORD)
1164{
1165 dprintf(("SurfUpdateOverlayDisplay\n"));
1166 return(DD_OK);
1167}
1168//******************************************************************************
1169//******************************************************************************
1170HRESULT __stdcall SurfUpdateOverlayZOrder(THIS_ DWORD, LPDIRECTDRAWSURFACE2)
1171{
1172 dprintf(("SurfUpdateOverlayZOrder\n"));
1173 return(DD_OK);
1174}
1175//******************************************************************************
1176//******************************************************************************
1177HRESULT __stdcall SurfGetDDInterface(THIS_ LPVOID FAR *lplpDirectDraw)
1178{
1179 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
1180
1181 dprintf(("SurfGetDDInterface\n"));
1182 if(me == NULL) {
1183 return DDERR_INVALIDOBJECT;
1184 }
1185 *lplpDirectDraw = (LPVOID FAR *)me->lpDraw;
1186 return(DD_OK);
1187}
1188//******************************************************************************
1189//******************************************************************************
1190HRESULT __stdcall SurfPageLock(THIS_ DWORD)
1191{
1192 dprintf(("SurfPageLock\n"));
1193 return(DD_OK);
1194}
1195//******************************************************************************
1196//******************************************************************************
1197HRESULT __stdcall SurfPageUnlock(THIS_ DWORD)
1198{
1199 dprintf(("SurfPageUnlock\n"));
1200 return(DD_OK);
1201}
1202//******************************************************************************
1203//******************************************************************************
Note: See TracBrowser for help on using the repository browser.