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

Last change on this file since 4 was 4, checked in by ktk, 26 years ago

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