Changeset 5291 for trunk/src/ddraw/new/OS2SURFACE.CPP

Timestamp:

Mar 9, 2001, 11:48:48 PM (25 years ago)

Author:

mike

Message:

Updates/cleanup for Watcom (not complete)

File:

• trunk/src/ddraw/new/OS2SURFACE.CPP (modified) (157 diffs)

trunk/src/ddraw/new/OS2SURFACE.CPP

@@ -1 @@
-/* $Id: OS2SURFACE.CPP,v 1.2 2000-09-25 20:54:01 mike Exp $ */
+/* $Id: OS2SURFACE.CPP,v 1.3 2001-03-09 22:48:48 mike Exp $ */
 
 /*
- * Direct/X Surface class implementaion
+ * DirectDraw Surface class implementaion
  *
  * Copyright 1999 Markus Montkowski
+ * Copyright 2000 Michal Necasek
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -302 +303 @@
 
 #define CBM_CREATEDIB   0x02L   /* create DIB bitmap */
+
 #ifdef DEBUG
-
 // ******************************************************************************
 // *    internal helper functions from WINE
@@ -536 +537 @@
   _dump_DDPIXELFORMAT(pf->dwFlags);
   dprintf(("DDRAW: dwFourCC : %ld\n", pf->dwFourCC));
-  dprintf(("DDRAW: RBG bit cbout : %ld\n", pf->dwRGBBitCount));
+  dprintf(("DDRAW: RBG bit count : %ld\n", pf->dwRGBBitCount));
   dprintf(("DDRAW: Masks : R %08lx  G %08lx  B %08lx  A %08lx\n",
        pf->dwRBitMask, pf->dwGBitMask, pf->dwBBitMask, pf->dwRGBAlphaBitMask));
@@ -559 +560 @@
 
 {
-  ULONG rc;
-  DWORD i;
-  DIVE_CAPS dCaps;
+  DWORD rc;
   DDSURFACEDESC2 ComplexSurfaceDesc;
-  OS2IDirectDrawSurface *AttachedSurface;
   OS2IDirectDrawSurface *MipMapSurface;
 
@@ -721 +719 @@
   if(NULL==DPA_SurfaceMipMaps)
   {
-    #ifdef DEBUG
-      dprintf(("DDRAW: Internal : Error creating DPA for MipMaps\n"));
-    #endif
+    dprintf(("DDRAW: Internal : Error creating DPA for MipMaps\n"));
     lastError = DDERR_OUTOFMEMORY ;
     return;
@@ -747 +743 @@
   if(NULL==DPA_SurfacePrivateData)
   {
-    dprintf(("DDRAW: Internal : Error creating DPA for priva surface Data\n"));
+    dprintf(("DDRAW: Internal : Error creating DPA for private surface Data\n"));
     lastError = DDERR_OUTOFMEMORY ;
     return;
@@ -778 +774 @@
           break;
         default:
-          dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
+          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
           BltSolid  = NULL;
           ColorConv = NULL;
@@ -809 +805 @@
           break;
         default:
-          dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
+          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
           BltSolid  = NULL;
           ColorConv = NULL;
@@ -840 +836 @@
           break;
         default:
-          dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
+          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
           BltSolid  = NULL;
           ColorConv = NULL;
@@ -871 +867 @@
           break;
         default:
-          dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
+          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
           BltSolid  = NULL;
           ColorConv = NULL;
@@ -879 +875 @@
       break;
     default:
-      dprintf(("DDRAW: Unsupported DX ColorDeapth %d",lpDraw->GetScreenBpp()));
+      dprintf(("DDRAW: Unsupported DX ColorDepth %d",lpDraw->GetScreenBpp()));
       BltSolid  = NULL;
       ColorConv = NULL;
@@ -896 +892 @@
     if( surfaceType & DDSCAPS_PRIMARYSURFACE)
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: Primary surface!\n"));
-      #endif
-
+      dprintf(("DDRAW: Primary surface!\n"));
       if( lpDraw->HasPrimarySurface())
       {
-        #ifdef DEBUG
-          dprintf(("DDRAW: Primary surface already exits!\n"));
-        #endif
+        dprintf(("DDRAW: Primary surface already exits!\n"));
         lastError = DDERR_PRIMARYSURFACEALREADYEXISTS;
         return;
@@ -925 +916 @@
       if( lpDraw->dCaps.ulDepth == lpDraw->GetScreenBpp() )
       {
-        dprintf(("DDRAW: DirectScreenAccess possible\n"));
+        dprintf(("DDRAW: Direct Screen Access possible\n"));
 
         // Yes so direct access to framebuffer is possible
@@ -940 +931 @@
         // and blit to the real framebuffer on Unlock to do color conversion
 
-        dprintf( ("Need Color conversation %d => %d Bit\n",
+        dprintf( ("Need Color conversion %d => %d Bit\n",
                   lpDraw->GetScreenBpp(),
                   lpDraw->dCaps.ulDepth
@@ -962 +953 @@
 
       dprintf(("DDRAW: Setting up Surface\n"));
-
       DDSurfaceDesc.dwFlags     |= DDSD_WIDTH | DDSD_HEIGHT |
                                    DDSD_PITCH | DDSD_LPSURFACE |
@@ -1056 +1046 @@
           dprintf(("DDRAW: Unsupported Complex Surface\n"));
           #ifdef DEBUG
-            _dump_DDSCAPS(DDSurfaceDesc.dwFlags);
+          _dump_DDSCAPS(DDSurfaceDesc.dwFlags);
           #endif
           lastError = DDERR_OUTOFMEMORY;
@@ -1409 +1399 @@
 {
 
-  int i, FillWidth, FillHeight, Top, Left;
+  int  FillWidth, FillHeight, Top, Left;
   DWORD *pPal24;
   WORD  *pPal16;
-  #ifdef DEBUG
-    dprintf(("DDRAW: ColorFill with %08X\n", dwFillColor));
-  #endif
+  dprintf(("DDRAW: ColorFill with %08X\n", dwFillColor));
 
   if(NULL!=lpDestRect)
@@ -1436 +1424 @@
   //dprintf(("DDRAW: 0x%08X (%d/%d) at\n", pLine,FillWidth,FillHeight));
 
-  // Better safe then sorry
-  if(FillHeight<=0)
+  // Better safe than sorry
+  if (FillHeight <= 0)
     return(DD_OK);
 
@@ -1647 +1635 @@
       break;
     default:
-      #ifdef DEBUG
         dprintf( ("Unexpected Screen Bitdepth %d\n",
                   lpDraw->dCaps.ulDepth));
-      #endif
       break;
   }
@@ -1677 +1663 @@
 OS2IDirectDrawSurface::~OS2IDirectDrawSurface()
 {
-  OS2IDirectDrawSurface  *AttachedSurface;
-
 
   if(DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
@@ -1755 +1739 @@
 
   lpDraw->Vtbl.Release(lpDraw);
-
-}
+}
+
 //******************************************************************************
 //******************************************************************************
@@ -1794 +1778 @@
     else
     {
-      dprintf(("DDRAW: We are oe of many buffers\n"));
+      dprintf(("DDRAW: We are one of many buffers\n"));
       DDSurfaceDesc.ddsCaps.dwCaps &=  ~DDSCAPS_BACKBUFFER ;
       DDSurfaceDesc.ddsCaps.dwCaps |=  DDSCAPS_FLIP;
@@ -1807 +1791 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
+HRESULT WIN32API SurfQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
 {
   // ToDo: Add Interface handling for D3D Textures
@@ -1826 +1810 @@
   if(IsEqualGUID(riid, IID_IDirectDrawSurface))
   {
-    *ppvObj = &me->Vtbl2;  // ToDo DO a real V1 table
+    *ppvObj = &me->lpVtbl;  // ToDo DO a real V1 table
     rc = DD_OK;
     goto RetFn;
@@ -1832 +1816 @@
   if(IsEqualGUID(riid, IID_IDirectDrawSurface2))
   {
-    *ppvObj = &me->Vtbl2;
+    *ppvObj = &me->lpVtbl2;
     rc = DD_OK;
     goto RetFn;
@@ -1859 +1843 @@
 //******************************************************************************
 //******************************************************************************
-ULONG __stdcall SurfAddRef(THIS This)
+ULONG WIN32API SurfAddRef(THIS This)
 {
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: OS2IDirectDrawSurface::SurfAddRef %d\n", me->Referenced+1));
-  #endif
+  dprintf(("DDRAW: OS2IDirectDrawSurface::SurfAddRef %d\n", me->Referenced+1));
 
   return ++me->Referenced;
@@ -1871 +1853 @@
 //******************************************************************************
 //******************************************************************************
-ULONG __stdcall SurfRelease(THIS This)
+ULONG WIN32API SurfRelease(THIS This)
 {
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: OS2IDirectDrawSurface::SurfRelease %d\n", me->Referenced-1));
-    dprintf(("DDRAW: OS2IDirectDrawSurface::Surface %X\n", me));
-  #endif
+  dprintf(("DDRAW: OS2IDirectDrawSurface::SurfRelease %d\n", me->Referenced-1));
+  dprintf(("DDRAW: OS2IDirectDrawSurface::Surface %X\n", me));
   if(me->Referenced)
   {
@@ -1898 +1878 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfAddAttachedSurface(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurface)
-{
-
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfAddAttachedSurface\n"));
-  #endif
+HRESULT WIN32API SurfAddAttachedSurface(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurface)
+{
+
+  dprintf(("DDRAW: SurfAddAttachedSurface\n"));
   return SurfAddAttachedSurface4(This, (LPDIRECTDRAWSURFACE4)lpDDSurface);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfAddAttachedSurface3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurface)
-{
-
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfAddAttachedSurface\n"));
-  #endif
+HRESULT WIN32API SurfAddAttachedSurface3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurface)
+{
+
+  dprintf(("DDRAW: SurfAddAttachedSurface\n"));
   return SurfAddAttachedSurface4(This, (LPDIRECTDRAWSURFACE4)lpDDSurface);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfAddAttachedSurface4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurface)
+HRESULT WIN32API SurfAddAttachedSurface4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurface)
 {
   OS2IDirectDrawSurface *AttachedSurface;
@@ -1925 +1901 @@
   int rc;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfAddAttachedSurface4\n"));
-  #endif
+  dprintf(("DDRAW: SurfAddAttachedSurface4\n"));
 
   if (NULL==lpDDSurface)
@@ -1936 +1910 @@
   if(AttachedSurface->IsImplicitSurface())
   {
-    #ifdef DEBUG
-     dprintf(("DDRAW: Internal : Can't attach an implicit created surface to an other surface\n"));
-    #endif
+    dprintf(("DDRAW: Internal : Can't attach an implicitly created surface to another surface\n"));
     return(DDERR_CANNOTATTACHSURFACE);
   }
@@ -1944 +1916 @@
   if(This == AttachedSurface)
   {
-    #ifdef DEBUG
-     dprintf(("DDRAW: Can't attach an surface to itself\n"));
-    #endif
+    dprintf(("DDRAW: Can't attach a surface to itself\n"));
     return(DDERR_CANNOTATTACHSURFACE);
   }
@@ -1969 +1939 @@
         else
         {
-          #ifdef DEBUG
-            dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
-          #endif
+          dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
           return(DDERR_CANNOTATTACHSURFACE);
         }
@@ -1977 +1945 @@
       else
       {
-        #ifdef DEBUG
-          dprintf(("DDRAW: Target Surface isn't a MipMap\n"));
-        #endif
+        dprintf(("DDRAW: Target Surface isn't a MipMap\n"));
         return(DDERR_CANNOTATTACHSURFACE);
       }
@@ -1995 +1961 @@
       else
       {
-        #ifdef DEBUG
-          dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
-        #endif
+        dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
         return(DDERR_CANNOTATTACHSURFACE);
       }
@@ -2010 +1974 @@
        )
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: Surfaces don't have same dimensions\n"));
-      #endif
+      dprintf(("DDRAW: Surfaces don't have equal dimensions\n"));
       return(DDERR_CANNOTATTACHSURFACE);
     }
@@ -2021 +1983 @@
         if( (AttachedSurface->GetFrontBuffer()!=NULL) || (AttachedSurface->BackBuffer!= NULL))
         {
-          #ifdef DEBUG
-            dprintf(("DDRAW: Surfaces already has a front/backbuffer\n"));
-          #endif
+          dprintf(("DDRAW: Surface already has a front/backbuffer\n"));
           return(DDERR_SURFACEALREADYATTACHED);
         }
@@ -2056 +2016 @@
         else
         {
-          #ifdef DEBUG
-            dprintf(("DDRAW: Can't attach backbuffer to anything but a frontbuffer\n"));
-          #endif
-         return(DDERR_CANNOTATTACHSURFACE);
+          dprintf(("DDRAW: Can't attach backbuffer to anything but a frontbuffer\n"));
+          return(DDERR_CANNOTATTACHSURFACE);
         }
       }
@@ -2080 +2038 @@
             else
             {
-              #ifdef DEBUG
-                dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
-              #endif
+              dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
               return(DDERR_CANNOTATTACHSURFACE);
             }
@@ -2088 +2044 @@
           else
           {
-            #ifdef DEBUG
-              dprintf(("DDRAW: Tagget Surface isn't a MipMap\n"));
-            #endif
+            dprintf(("DDRAW: Target Surface isn't a MipMap\n"));
            return(DDERR_CANNOTATTACHSURFACE);
           }
@@ -2104 +2058 @@
           else
           {
-            #ifdef DEBUG
-              dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
-            #endif
+            dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
             return(DDERR_CANNOTATTACHSURFACE);
           }
@@ -2118 +2070 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfAddOverlayDirtyRect(THIS, LPRECT)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfAddOverlayDirtyRect Not implemented by M$ in V 6.0! \n"));
-  #endif
+HRESULT WIN32API SurfAddOverlayDirtyRect(THIS, LPRECT)
+{
+  dprintf(("DDRAW: SurfAddOverlayDirtyRect Not implemented by M$ in DX 6.0!\n"));
 
   return(DD_OK);
@@ -2128 +2078 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE2 lpDDSrcSurface,
+HRESULT WIN32API SurfBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE2 lpDDSrcSurface,
         LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
 {
@@ -2140 +2090 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfBlt3(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE3 lpDDSrcSurface,
+HRESULT WIN32API SurfBlt3(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE3 lpDDSrcSurface,
         LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
 {
@@ -2152 +2102 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfBlt4(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
+HRESULT WIN32API SurfBlt4(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
         LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
 {
@@ -2170 +2120 @@
  OS2IDirectDrawSurface *src  = (OS2IDirectDrawSurface *)lpDDSrcSurface;
 
- HRESULT                rc;
- ULONG                  ulColor, *pColor;
- RECTL                  cliprect;
-
- int                    x, y, i, j, BlitWidth, BlitHeight;
+ int                    x, i, BlitWidth, BlitHeight;
  PALETTEENTRY           SysPal[257];
  PLOGPALETTE            pLogPal = (PLOGPALETTE) SysPal;
@@ -2185 +2131 @@
 
   #ifdef DEBUG
-    dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X, flags %08X", dest, src, dwFlags));
+    dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X\n",dest,src));
     if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
       dprintf(("DDRAW: SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
@@ -2289 +2235 @@
     {
       delete pIRectDest;
-      dprintf(("DDRAW: Blt: Dest Surface partly locked\n"));
+      dprintf(("DDRAW: Blt: Dest Surface partially locked\n"));
       return(DDERR_SURFACEBUSY);
     }
@@ -2474 +2420 @@
     }
   }
-/*
+
   if( ( (NULL==lpDestRect) && (NULL!=lpSrcRect) ) ||
       ( (NULL==lpSrcRect) && (NULL!=lpDestRect) ) )
   {
-    dprintf(("DDRAW: Blitting with scaleing\n Not supported.\n"));
-
-    return DDERR_NOSTRETCHHW;
+    dprintf(("DDRAW: Blitting with scaling\n Not supported.\n"));
+
+//    return DDERR_NOSTRETCHHW;
   }
 
@@ -2492 +2438 @@
     return DDERR_NOSTRETCHHW;
   }
-*/
+
   if (dest->DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
   {
@@ -2593 +2539 @@
     {
       // copy from the screen to a buffer
-      dprintf(("DDRAW: Screen to buffer"));
 
       if( (NULL==lpDestRect) &&
@@ -2659 +2604 @@
     {
       // DIVE => DIVE  or Mem => Dive can be handelt in the same way
-      dprintf(("DDRAW: Buffer to screen"));
 
       if( (src->pDiveBuffer == dest->pDiveBuffer) &&
@@ -2725 +2669 @@
         {
           DWORD dwFx;
-          DWORD dwSrcColor, dwDestColor;
 
           dwFlags &= ~DDBLT_DDFX; // remove the handled flag
@@ -3189 +3132 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD )
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfBltBatch Not implemented by M$\n"));
-  #endif
+HRESULT WIN32API SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD )
+{
+  dprintf(("DDRAW: SurfBltBatch Not implemented by M$\n"));
 
   return(DD_OK);
@@ -3199 +3140 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfBltFast( THIS This ,
+HRESULT WIN32API SurfBltFast( THIS This ,
                                DWORD dwX,
                                DWORD dwY,
@@ -3216 +3157 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfBltFast3(THIS This ,
+HRESULT WIN32API SurfBltFast3(THIS This ,
                                DWORD dwX,
                                DWORD dwY,
@@ -3233 +3174 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfBltFast4( THIS This,
+HRESULT WIN32API SurfBltFast4( THIS This,
                                 DWORD dwX,
                                 DWORD dwY,
@@ -3244 +3185 @@
   RECTL SrcRect;
   char *pBltPos, *pSrcPos;
-  DWORD dwDestColor, dwSrcColor, BlitWidth, BlitHeight,x,y;
+  DWORD dwDestColor, dwSrcColor, BlitWidth, BlitHeight, x;
 
   dprintf(("DDRAW: SurfBltFast4 %08X at(%d/%d) onto %08X with flags %08X\n",src, dwX,dwY, dest, dwTrans));
 
-  if( (NULL==lpDDSrcSurface) ||
-      (dwX<0) || (dwY<0) ||
-      (dwX>dest->width) ||
-      (dwY>dest->height))
+  if( (NULL == lpDDSrcSurface) ||
+      ((LONG)dwX < 0) || ((LONG)dwY < 0) ||
+      (dwX > dest->width) ||
+      (dwY > dest->height))
   {
     dprintf(("DDRAW: Invalid Parameters %08X, %d %d", lpDDSrcSurface ,dest->width , dest->height));
@@ -3257 +3198 @@
   }
 
-  if (NULL!=lpSrcRect)
+  if (NULL != lpSrcRect)
   {
     memcpy(&SrcRect,lpSrcRect,sizeof(RECTL) );
@@ -3285 +3226 @@
   if(DDBLTFAST_NOCOLORKEY == dwTrans )
   {
-    dprintf(( "Solid Blit, %d pels wide => %d bytes per line\n",
+    dprintf(( "Solid Blit, %d bits => %d bytes per line\n",
               (SrcRect.right - SrcRect.left),
               BlitWidth) );
     #ifdef USE_ASM
       BltRec(pBltPos, pSrcPos, BlitWidth, BlitHeight,
-             dest->dwPitchDB, src->dwPitchDB);
+             dest->dwPitchDB,
+             src->dwPitchDB);
     #else
       // Solid Blit
       while(1)
       {
-        memcpy(pBltPos, pSrcPos, BlitWidth);
+        memcpy(pBltPos,pSrcPos,BlitWidth);
         pBltPos += dest->dwPitchDB;
         pSrcPos += src->dwPitchDB;
@@ -3308 +3250 @@
     dprintf(("DDRAW: TransBlit\n"));
 
-    if (dwTrans & DDBLTFAST_SRCCOLORKEY)
+    if(dwTrans & DDBLTFAST_SRCCOLORKEY)
     {
       dprintf(("DDRAW: Trans SRC\n"));
@@ -3416 +3358 @@
         {
           case 1:
-            if(CPUHasMMX())
-              while(BlitHeight--)
+            if (CPUHasMMX())
+              while (BlitHeight--)
               {
                 BlitColorKey8MMX((PBYTE)pBltPos,(PBYTE)pSrcPos,dwSrcColor,BlitWidth);
@@ -3424 +3366 @@
               }
             else
-              while(BlitHeight--)
+              while (BlitHeight--)
               {
                 BlitColorKey8((PBYTE)pBltPos,(PBYTE)pSrcPos,dwSrcColor,BlitWidth);
@@ -3433 +3375 @@
           case 2:
 
-            if(CPUHasMMX())
+            if (CPUHasMMX())
               while(BlitHeight--)
               {
@@ -3481 +3423 @@
     else
     {
-      if(dwTrans & DDBLTFAST_DESTCOLORKEY)
+      if (dwTrans & DDBLTFAST_DESTCOLORKEY)
       {
         dprintf(("DDRAW: DestColorKey\n"));
@@ -3571 +3513 @@
   //   dest->Vtbl4->ChangeUniquenessValue(dest);
 
-  return(DD_OK);
-}
-
-//******************************************************************************
-//******************************************************************************
-HRESULT __stdcall SurfDeleteAttachedSurface(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE2 lpDDSurface)
+  return DD_OK;
+}
+//******************************************************************************
+//******************************************************************************
+HRESULT WIN32API SurfDeleteAttachedSurface(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE2 lpDDSurface)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -3583 +3524 @@
   return(SurfDeleteAttachedSurface4(me, dwFlags, (LPDIRECTDRAWSURFACE4)lpDDSurface));
 }
-
-//******************************************************************************
-//******************************************************************************
-HRESULT __stdcall SurfDeleteAttachedSurface3(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE3 lpDDSurface)
+//******************************************************************************
+//******************************************************************************
+HRESULT WIN32API SurfDeleteAttachedSurface3(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE3 lpDDSurface)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
-  #endif
+  dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
 
   return(SurfDeleteAttachedSurface4(me, dwFlags, (LPDIRECTDRAWSURFACE4)lpDDSurface));
@@ -3597 +3535 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfDeleteAttachedSurface4(THIS This, DWORD dwFlags , LPDIRECTDRAWSURFACE4 lpDDSurface)
+HRESULT WIN32API SurfDeleteAttachedSurface4(THIS This, DWORD dwFlags , LPDIRECTDRAWSURFACE4 lpDDSurface)
 {
 
@@ -3606 +3544 @@
 
   BOOL Found = FALSE;
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
-  #endif
+  dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
 
   if((0!=dwFlags)||(NULL==lpDDSurface))
@@ -3745 +3681 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfEnumAttachedSurfaces(THIS This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpCallBack)
+HRESULT WIN32API SurfEnumAttachedSurfaces(THIS This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpCallBack)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
-  #endif
+  dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
 
   return(SurfEnumAttachedSurfaces4(me,lpContext, (LPDDENUMSURFACESCALLBACK2) lpCallBack));
@@ -3756 +3690 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfEnumAttachedSurfaces4(THIS This, LPVOID lpContext ,LPDDENUMSURFACESCALLBACK2 lpCallBack)
+HRESULT WIN32API SurfEnumAttachedSurfaces4(THIS This, LPVOID lpContext ,LPDDENUMSURFACESCALLBACK2 lpCallBack)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -3764 +3698 @@
   HRESULT rc;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
-  #endif
+  dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
   if (NULL==lpCallBack)
     return (DDERR_INVALIDPARAMS);
@@ -3816 +3748 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK)
+HRESULT WIN32API SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK)
 {
   dprintf(("DDRAW: SurfEnumOverlayZOrders\n"));
@@ -3824 +3756 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2)
+HRESULT WIN32API SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2)
 {
   dprintf(("DDRAW: SurfEnumOverlayZOrders\n"));
@@ -3832 +3764 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfFlip(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurf, DWORD dwFlags)
+HRESULT WIN32API SurfFlip(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurf, DWORD dwFlags)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -3842 +3774 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfFlip3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurf, DWORD dwFlags)
+HRESULT WIN32API SurfFlip3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurf, DWORD dwFlags)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -3852 +3784 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfFlip4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurf, DWORD dwFlags)
+HRESULT WIN32API SurfFlip4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurf, DWORD dwFlags)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -3859 +3791 @@
   LPVOID Data;
   char *pcrFB,*pcFB,*pcrDB,*pcDB;
-  ULONG rc;
 
   dprintf(("DDRAW: SurfFlip4\n"));
@@ -3907 +3838 @@
   }
 
-  if(-1 != me->diveBufNr)
+  if (-1 != me->diveBufNr)
   {
     //dprintf(("DDRAW: DIVE Flipchain DiveBuffer #%d",FlipSurface->diveBufNr));
@@ -3934 +3865 @@
   else
   {
-    #ifdef DEBUG
-      dprintf(("DDRAW: Memory Flipchain"));
-    #endif
+    dprintf(("DDRAW: Memory Flipchain"));
     // Memory Flipchain
     //
@@ -3960 +3889 @@
     me->pDiveBuffer             = FlipSurface->pDiveBuffer;
 
-    if(NULL==lpDDSurf)
-    {
-      while(NULL!=FlipSurface->BackBuffer)
+    if (NULL==lpDDSurf)
+    {
+      while (NULL!=FlipSurface->BackBuffer)
       {
         FlipSurface->DDSurfaceDesc.lpSurface = FlipSurface->BackBuffer->DDSurfaceDesc.lpSurface;
@@ -3979 +3908 @@
   }
 
-  return(DD_OK);
-}
-//******************************************************************************
-//******************************************************************************
-HRESULT __stdcall SurfGetAttachedSurface(THIS This, LPDDSCAPS lpDDCaps,
+  return DD_OK;
+}
+
+//******************************************************************************
+//******************************************************************************
+HRESULT WIN32API SurfGetAttachedSurface(THIS This, LPDDSCAPS lpDDCaps,
                                          LPDIRECTDRAWSURFACE2 FAR * lpDDSurf)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetAttachedSurface\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetAttachedSurface\n"));
 
   return(SurfGetAttachedSurface4(me, (LPDDSCAPS2)lpDDCaps , (LPDIRECTDRAWSURFACE4*)lpDDSurf));
@@ -3995 +3923 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetAttachedSurface3(THIS This, LPDDSCAPS lpDDCaps,
+HRESULT WIN32API SurfGetAttachedSurface3(THIS This, LPDDSCAPS lpDDCaps,
                                          LPDIRECTDRAWSURFACE3 FAR * lpDDSurf)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetAttachedSurface3\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetAttachedSurface3\n"));
 
   return(SurfGetAttachedSurface4(me, (LPDDSCAPS2)lpDDCaps , (LPDIRECTDRAWSURFACE4*)lpDDSurf));
@@ -4007 +3933 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetAttachedSurface4(THIS This, LPDDSCAPS2 lpDDCaps,
+HRESULT WIN32API SurfGetAttachedSurface4(THIS This, LPDDSCAPS2 lpDDCaps,
                                           LPDIRECTDRAWSURFACE4 FAR * lpDDSurf)
 {
@@ -4094 +4020 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetBltStatus(THIS This, DWORD)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetBltStatus\n"));
-  #endif
+HRESULT WIN32API SurfGetBltStatus(THIS This, DWORD)
+{
+  dprintf(("DDRAW: SurfGetBltStatus\n"));
 
   return(DD_OK);
@@ -4104 +4028 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetCaps(THIS This, LPDDSCAPS lpDDCaps)
+HRESULT WIN32API SurfGetCaps(THIS This, LPDDSCAPS lpDDCaps)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetCaps\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetCaps\n"));
 
   if(NULL==lpDDCaps)
@@ -4123 +4045 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetCaps4(THIS This, LPDDSCAPS2 lpDDCaps)
+HRESULT WIN32API SurfGetCaps4(THIS This, LPDDSCAPS2 lpDDCaps)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetCaps4\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetCaps4\n"));
 
   if(NULL==lpDDCaps)
@@ -4137 +4057 @@
     _dump_DDSCAPS(lpDDCaps->dwCaps);
     _dump_DDSCAPS2(lpDDCaps->dwCaps2);
-
   #endif
 
@@ -4144 +4063 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetClipper(THIS This, LPDIRECTDRAWCLIPPER FAR *lplpClipper)
+HRESULT WIN32API SurfGetClipper(THIS This, LPDIRECTDRAWCLIPPER FAR *lplpClipper)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetClipper\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetClipper\n"));
 
   if(me->lpClipper)
@@ -4162 +4079 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetColorKey(THIS This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
+HRESULT WIN32API SurfGetColorKey(THIS This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-
-#ifdef DEBUG
   dprintf(("DDRAW: SurfGetColorKey\n"));
-#endif
 
   if ((0==dwFlags) || (NULL==lpDDColKey))
@@ -4193 +4107 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetDC(THIS This, HDC FAR *hdc)
+HRESULT WIN32API SurfGetDC(THIS This, HDC FAR *hdc)
 {
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
  DDSURFACEDESC2        LockedSurfaceDesc;
- HRESULT rc;
+ HRESULT               rc;
+ BITMAPINFOHEADER      bmihHdr;
  BITMAP bmpSurface;
  struct
@@ -4205 +4120 @@
  } BitmapInfo;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetDC\n"));
-  #endif
-
-  if (NULL==hdc)
+  dprintf(("DDRAW: SurfGetDC\n"));
+
+  if (hdc == NULL)
     return(DDERR_INVALIDPARAMS);
 
@@ -4227 +4140 @@
     if(me->hdcImage == NULL)
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: Can't create compatible DC!\n"));
-      #endif
+      dprintf(("DDRAW: Can't create compatible DC!\n"));
       me->Vtbl.Unlock(me,NULL);
       rc = DDERR_GENERIC;
     }
-    InverseDC(me->hdcImage, LockedSurfaceDesc.dwHeight);
-  }
-
-  if( (DD_OK==rc) &&
-      (me->hbmImage == NULL) )
-  {
+  }
+
+  if( (DD_OK==rc) && (me->hbmImage == NULL) )
+  {
+    OS2IDirectDrawPalette *ddpal = NULL;
+
     dprintf( ("Trying to create Bitmap (%d/%d) at %d Bit\n",
-              LockedSurfaceDesc.lPitch/ (LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount>>3),
+              LockedSurfaceDesc.dwWidth,
               LockedSurfaceDesc.dwHeight,
               LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount
             ));
-    #if 0
+    #if 1
     memset(&BitmapInfo, 0, sizeof(BitmapInfo));
-    BitmapInfo.bmiHead.biSize   = sizeof(BITMAPINFOHEADER);
-    BitmapInfo.bmiHead.biWidth  = LockedSurfaceDesc.lPitch/ (LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount>>3);
-    BitmapInfo.bmiHead.biHeight = LockedSurfaceDesc.dwHeight;
-    BitmapInfo.bmiHead.biPlanes = 1;
-    BitmapInfo.bmiHead.biBitCount    = LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
+    BitmapInfo.bmiHead.biSize     = sizeof(BITMAPINFOHEADER);
+    BitmapInfo.bmiHead.biWidth    = LockedSurfaceDesc.dwWidth;
+    BitmapInfo.bmiHead.biHeight   = LockedSurfaceDesc.dwHeight;
+    BitmapInfo.bmiHead.biPlanes   = 1;
+    BitmapInfo.bmiHead.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
+    memset(&bmihHdr, 0, sizeof(bmihHdr));
+    bmihHdr.biSize     = sizeof(BITMAPINFOHEADER);
+    bmihHdr.biWidth    = LockedSurfaceDesc.dwWidth;
+    bmihHdr.biHeight   = LockedSurfaceDesc.dwHeight;
+    bmihHdr.biPlanes   = 1;
+    bmihHdr.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
     #else
     bmpSurface.bmType       = 0;
@@ -4266 +4183 @@
         break;
       case 8:
-        #if 0
+        #if 1
         BitmapInfo.bmiHead.biCompression = BI_RGB;
-        GetSystemPaletteEntries(me->hdcImage,0,255,(PPALETTEENTRY)&BitmapInfo.bmiCols[0]);
+        if (me->lpPalette != NULL)
+           ddpal = me->lpPalette;
+        if ((me->FrontBuffer != NULL) && (me->FrontBuffer->lpPalette != NULL))
+           ddpal = me->FrontBuffer->lpPalette;
+        if (ddpal != NULL) {
+           ddpal->Vtbl.GetEntries((IDirectDrawPalette*)ddpal,
+              0, 0, 256, (PPALETTEENTRY)&BitmapInfo.bmiCols[0]);
+        }
+        else {
+           dprintf(("DDRAW: Using default palette\n"));
+           for (DWORD i = 0; i < 256; i++) {
+              BitmapInfo.bmiCols[i].rgbBlue  = DefaultPalette[i*3+2];
+              BitmapInfo.bmiCols[i].rgbGreen = DefaultPalette[i*3+1];
+              BitmapInfo.bmiCols[i].rgbRed   = DefaultPalette[i*3];
+              BitmapInfo.bmiCols[i].rgbReserved = 0;
+           }
+        }
         me->hbmImage = CreateDIBitmap( me->hdcImage,
-                                       NULL,
-                                       CBM_CREATEDIB,
+                                       &bmihHdr,
+                                       CBM_INIT,
                                        LockedSurfaceDesc.lpSurface,
                                        (PBITMAPINFO)&BitmapInfo,
@@ -4292 +4225 @@
                                        LockedSurfaceDesc.lpSurface,
                                        (PBITMAPINFO)&BitmapInfo,
-                                       DIB_RGB_COLORS);
+                                       DIB_RGB_COLORS );
         #else
         bmpSurface.bmBitsPixel  = 24;
@@ -4299 +4232 @@
         break;
       default:
-        #ifdef DEBUG
-          dprintf( ("Unexptected BitCount %d \n",
+        dprintf( ("Unexpected BitCount %d \n",
                     LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
-        #endif
         me->hbmImage=NULL;
     } // end switch (me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
@@ -4308 +4239 @@
     if(me->hbmImage == NULL)
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: Can't create bitmap!\n"));
-      #endif
+      dprintf(("DDRAW: Can't create bitmap!\n"));
       DeleteDC(me->hdcImage);
       me->hdcImage = NULL;
@@ -4319 +4248 @@
   else
   {
-    if( (DD_OK==rc) &&
-        (me->dwLastDCUnique != me->dwUniqueValue) )
-    {
-      #ifdef DEBUG
-        dprintf(("DDRAW: The Surface was locked/unlocked after the last DC was created =>Update Bitmap!\n"));
-      #endif
+    if( (DD_OK==rc) && (me->dwLastDCUnique != me->dwUniqueValue) )
+    {
+      dprintf(("DDRAW: The Surface was locked/unlocked after the last DC was created =>Update Bitmap!\n"));
 
       memset(&BitmapInfo,0, sizeof(BitmapInfo));
       BitmapInfo.bmiHead.biSize     = sizeof(BITMAPINFOHEADER);
-      BitmapInfo.bmiHead.biWidth    = LockedSurfaceDesc.lPitch/ (LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount>>3);
+      BitmapInfo.bmiHead.biWidth    = LockedSurfaceDesc.dwWidth;
       BitmapInfo.bmiHead.biHeight   = LockedSurfaceDesc.dwHeight;
       BitmapInfo.bmiHead.biPlanes   = 1;
-      BitmapInfo.bmiHead.biBitCount = LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
+      BitmapInfo.bmiHead.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
 
       switch(LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
@@ -4359 +4285 @@
           break;
         default:
-          #ifdef DEBUG
-            dprintf(("DDRAW: Unexptected BitCount %d => Bitmap not updated!\n",LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
-          #endif
+          dprintf(("DDRAW: Unexpected BitCount %d => Bitmap not updated!\n",LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
           break;
       } // end switch (me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
@@ -4370 +4294 @@
   // Allways select the bitmap into the DC! No matter if the old or a new one
 
-  if(DD_OK==rc)
-  {
-    if((me->hgdiOld = SelectObject(me->hdcImage, me->hbmImage)) == NULL)
-    {
-      #ifdef DEBUG
-        dprintf(("DDRAW: Can't select bitmap into dc!\n"));
-      #endif
+  if (DD_OK==rc)
+  {
+    if ((me->hgdiOld = SelectObject(me->hdcImage, me->hbmImage)) == NULL)
+    {
+      dprintf(("DDRAW: Can't select bitmap into DC!\n"));
       DeleteDC(me->hdcImage);
       me->hdcImage = NULL;
@@ -4394 +4316 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetFlipStatus(THIS This, DWORD dwFlags)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetFlipStatus\n"));
-  #endif
+HRESULT WIN32API SurfGetFlipStatus(THIS This, DWORD dwFlags)
+{
+  dprintf(("DDRAW: SurfGetFlipStatus\n"));
 
   if( (DDGFS_CANFLIP!=dwFlags) && (DDGFS_ISFLIPDONE!=dwFlags) )
@@ -4407 +4327 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetOverlayPosition(THIS This, LPLONG lplX, LPLONG lplY)
+HRESULT WIN32API SurfGetOverlayPosition(THIS This, LPLONG lplX, LPLONG lplY)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetOverlayPosition\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetOverlayPosition\n"));
 
   // Maybe simply return dderr_notsupported as we retun a max overlay value of 0 in the caps ?
@@ -4435 +4353 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetPalette(THIS This, LPDIRECTDRAWPALETTE FAR *lplpPalette)
+HRESULT WIN32API SurfGetPalette(THIS This, LPDIRECTDRAWPALETTE FAR *lplpPalette)
 {
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetPalette\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetPalette\n"));
 
   if(me->lpPalette)
@@ -4453 +4369 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetPixelFormat(THIS This, LPDDPIXELFORMAT lpPixelFormat)
+HRESULT WIN32API SurfGetPixelFormat(THIS This, LPDDPIXELFORMAT lpPixelFormat)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetPixelFormat\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetPixelFormat %x %x", This, lpPixelFormat));
 
   if(NULL==lpPixelFormat)
@@ -4472 +4386 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurface)
+HRESULT WIN32API SurfGetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurface)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetSurfaceDesc\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetSurfaceDesc\n"));
 
   if((lpSurface == NULL)||(lpSurface->dwSize != sizeof(DDSURFACEDESC)) )
@@ -4491 +4403 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurface)
+HRESULT WIN32API SurfGetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurface)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetSurfaceDesc4\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetSurfaceDesc4\n"));
 
   if((lpSurface == NULL)||(lpSurface->dwSize != sizeof(DDSURFACEDESC2)) )
@@ -4510 +4420 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfInitialize\n"));
-  #endif
+HRESULT WIN32API SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC)
+{
+  dprintf(("DDRAW: SurfInitialize\n"));
 
   return(DDERR_ALREADYINITIALIZED); // Init is done during creation see M$ Doc
@@ -4520 +4428 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfInitialize\n"));
-  #endif
+HRESULT WIN32API SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2)
+{
+  dprintf(("DDRAW: SurfInitialize\n"));
 
   return(DDERR_ALREADYINITIALIZED); // Init is done during creation see M$ Doc
@@ -4530 +4436 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfIsLost(THIS)
+HRESULT WIN32API SurfIsLost(THIS)
 {
   // We don't loose any surface ;)
@@ -4536 +4442 @@
   // if  they are preserved if switching to a FS DOS/OS2 session
   //
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfIsLost\n"));
-  #endif
+  dprintf(("DDRAW: SurfIsLost\n"));
 
   return(DD_OK);
@@ -4544 +4448 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfLock( THIS This,
+HRESULT WIN32API SurfLock( THIS This,
                             LPRECT lpRect,
                             LPDDSURFACEDESC lpSurfaceDesc,
@@ -4553 +4457 @@
   HRESULT rc;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfLock %d %08X %d %d\n", (int)lpRect, (int)lpSurfaceDesc, dwFlags, hEvent));
-  #endif
+  dprintf(("DDRAW: SurfLock %d %08X %d %d\n", (int)lpRect, (int)lpSurfaceDesc, dwFlags, hEvent));
 
   if((NULL==lpSurfaceDesc)||(NULL!=hEvent))
@@ -4581 +4483 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfLock4( THIS This,
+HRESULT WIN32API SurfLock4( THIS This,
                              LPRECT lpRect,
                              LPDDSURFACEDESC2 lpSurfaceDesc,
@@ -4592 +4494 @@
 
   BOOL Found;
-  ULONG  nrScanLines;
-  char *pBuffer;
   DDRectangle *pIRectCurrent,*pIRectNew;
-  static int times = 0;
   HRESULT rc;
 
-  #ifdef DEBUG
-    dprintf( ("SurfLock4 %08X %08X %08X %d %d\n",
-              me,
-              (int)lpRect,
-              (int)lpSurfaceDesc,
-              dwFlags,
-              hEvent) );
-  #endif
+  dprintf( ("SurfLock4 %08X %08X %08X %d %d\n",
+            me,
+            (int)lpRect,
+            (int)lpSurfaceDesc,
+            dwFlags,
+            hEvent) );
 
   if( (NULL==lpSurfaceDesc) ||
@@ -4633 +4530 @@
     if (NULL==lpRect)
     {
-      // If anything is locked we can't locke the complete surface
-      dprintf(("DDRAW: Surface has locked Rectangles, and we want to complete lock it\n"));
+      // If anything is locked we can't lock the complete surface
+      dprintf(("DDRAW: Surface has locked Rectangles and we want to completely lock it\n"));
       Found = TRUE;
     }
@@ -4642 +4539 @@
       // be locked so check for this
 
-      dprintf(("DDRAW: Surface has locked Rectangles, check if the overlap\n"));
+      dprintf(("DDRAW: Surface has locked Rectangles, check if they overlap\n"));
 
       i=0;
@@ -4664 +4561 @@
     {
       delete pIRectNew;
-      #ifdef DEBUG
-        dprintf(("DDRAW: SurfLock4: Surface already locked\n\n"));
-      #endif
+      dprintf(("DDRAW: SurfLock4: Surface already locked\n\n"));
       rc = DDERR_SURFACEBUSY;
     }
@@ -4681 +4576 @@
                                   (lpRect->top * me->dwPitchFB) +
                                   (lpRect->left * (lpSurfaceDesc->ddpfPixelFormat.dwRGBBitCount>>3)));
-      #ifdef DEBUG
-        dprintf(("DDRAW: SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left));
-      #endif
+      dprintf(("DDRAW: SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left));
     }
     else
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface));
-      #endif
+      dprintf(("DDRAW: SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface));
     }
     // Add the rectangle to the list of locked rectangles
@@ -4707 +4598 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfReleaseDC(THIS This, HDC hdc)
+HRESULT WIN32API SurfReleaseDC(THIS This, HDC hdc)
 {
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -4715 +4606 @@
    RGBQUAD           bmiCols[256];
  } BitmapInfo;
- BITMAP bmpData;
- char szError[256];
- int i,rc;
-
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfReleaseDC\n"));
-  #endif
+// BITMAP bmpData;
+ int rc;
+
+  dprintf(("DDRAW: SurfReleaseDC\n"));
 
   if(hdc != me->hdcImage)
@@ -4751 +4639 @@
                       (PBITMAPINFO)&BitmapInfo,
                       DIB_RGB_COLORS);
+//      BitmapInfo.bmiHead.biHeight = -BitmapInfo.bmiHead.biHeight;
       dprintf( ("GetDIBits rc=%d\n Size   :%d\n Width  :%d\n Height :%d\n"
                 " Planes :%d\n BitCount :%d\nLastEror = %d\nPixel[0,0] = 0x%02X\n",
@@ -4761 +4650 @@
                 GetLastError(),
                 ((char*)me->DDSurfaceDesc.lpSurface)[0]));
+
       rc = GetDIBits( hdc,
                       me->hbmImage,
@@ -4789 +4679 @@
       break;
     default:
-      #ifdef DEBUG
-        dprintf(("DDRAW: Unexptected BitCount %d => Surface unlocked but no data copied back\n",me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
-      #endif
+      dprintf(("DDRAW: Unexpected BitCount %d => Surface unlocked but no data copied back\n",me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
       // we might could keep the surface locked and return an error but this is more "safe"
       break;
@@ -4814 +4702 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfRestore(THIS)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfRestore\n"));
-  #endif
+HRESULT WIN32API SurfRestore(THIS)
+{
+  dprintf(("DDRAW: SurfRestore\n"));
 
   return(DD_OK);
@@ -4824 +4710 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfSetClipper(THIS This, LPDIRECTDRAWCLIPPER lpClipper)
+HRESULT WIN32API SurfSetClipper(THIS This, LPDIRECTDRAWCLIPPER lpClipper)
 {
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfSetClipper\n"));
-  #endif
+  dprintf(("DDRAW: SurfSetClipper %x %x", This, lpClipper));
 
   if(lpClipper == NULL)
@@ -4861 +4745 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfSetColorKey(THIS  This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
+HRESULT WIN32API SurfSetColorKey(THIS  This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -4913 +4797 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfSetOverlayPosition(THIS This, LONG lX, LONG lY)
+HRESULT WIN32API SurfSetOverlayPosition(THIS This, LONG lX, LONG lY)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfSetOverlayPosition\n"));
-  #endif
+  dprintf(("DDRAW: SurfSetOverlayPosition\n"));
 
   if( (me->DDSurfaceDesc.dwFlags & DDSD_CAPS) &&
@@ -4942 +4824 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfSetPalette(THIS This, LPDIRECTDRAWPALETTE lpPalette)
+HRESULT WIN32API SurfSetPalette(THIS This, LPDIRECTDRAWPALETTE lpPalette)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfSetPalette\n"));
-  #endif
+  dprintf(("DDRAW: SurfSetPalette\n"));
 
   if(lpPalette == NULL)
@@ -4999 +4879 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUnlock(THIS This, LPVOID lpSurfaceData)
+HRESULT WIN32API SurfUnlock(THIS This, LPVOID lpSurfaceData)
 {
 
@@ -5009 +4889 @@
   HRESULT rc;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUnlock at %08X\n",lpSurfaceData));
-  #endif
+  dprintf(("DDRAW: SurfUnlock at %08X\n",lpSurfaceData));
 
   if(me->fLocked == FALSE)
   {
-    #ifdef DEBUG
-      dprintf(("DDRAW: Surface not locked!\n"));
-    #endif
+    dprintf(("DDRAW: Surface not locked!\n"));
     return(DDERR_NOTLOCKED);
   }
-
-  #ifdef DEBUG
-    dprintf(("DDRAW: Start Emuneration of Locked Rects\n"));
-  #endif
 
   i=0;
@@ -5033 +4905 @@
     // this pointer in the locked rects DPA to unlock the right rect.
 
-    while(i<DPA_GetPtrCount(me->DPA_LockedRects) && !Found)
+    while(i < DPA_GetPtrCount(me->DPA_LockedRects) && !Found)
     {
       pIRectEnum = (DDRectangle*)DPA_FastGetPtr(me->DPA_LockedRects,i);
@@ -5047 +4919 @@
       if(!Found)
       {
-        #ifdef DEBUG
-          dprintf(("DDRAW: Not Found, try Next rect\n"));
-        #endif
+        dprintf(("DDRAW: Not Found, try Next rect\n"));
         i++;
       }
-      #ifdef DEBUG
       else
       {
         dprintf(("DDRAW: Found Rect\n"));
       }
-      #endif
     }
   }
@@ -5082 +4950 @@
       if(!Found)
       {
-        #ifdef DEBUG
-          dprintf(("DDRAW: Not Found, try Next rect\n"));
-        #endif
+        dprintf(("DDRAW: Not Found, try Next rect\n"));
         i++;
       }
-      #ifdef DEBUG
       else
       {
         dprintf(("DDRAW: Found Rect\n"));
       }
-      #endif
     }
     delete pIRectUnlock;
@@ -5099 +4963 @@
   if(!Found)
   {
-    #ifdef DEBUG
-      dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
-    #endif
+    dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
     rc = DDERR_INVALIDRECT;
   }
   else
   {
-    #ifdef DEBUG
-      dprintf(("DDRAW: Remove Rect %d from Seq.\n",i));
-    #endif
+    dprintf(("DDRAW: Remove Rect %d from Seq.\n",i));
 
     DPA_DeletePtr(me->DPA_LockedRects,i);
 
-    #ifdef DEBUG
-      dprintf(("DDRAW: Test if locked Rects main\n"));
-    #endif
+    dprintf(("DDRAW: Test if locked Rects main\n"));
 
     if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: No Locked Rects left for surface\n"));
-      #endif
+      dprintf(("DDRAW: No Locked Rects left for surface\n"));
       me->fLocked = FALSE;
     }
@@ -5131 +4987 @@
     if(me->pFrameBuffer != me->pDiveBuffer)
     {
-      #ifdef DEBUG
-        dprintf(( "ColorConversion Needed %08X != %08X\n",
-                  me->pFrameBuffer,
-                  me->pDiveBuffer));
-      #endif
+      dprintf(( "ColorConversion Needed %08X != %08X\n",
+                me->pFrameBuffer,
+                me->pDiveBuffer));
       if(NULL!=lpSurfaceData)
       {
@@ -5150 +5004 @@
       }
     }
-    #ifdef DEBUG
     else
       dprintf( ("No ColorConversion Needed"));
-    #endif
 
     // delete tne DDRectobject of the found rectangle
@@ -5169 +5021 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUnlock4(THIS This, LPRECT lpSurfaceRect)
+HRESULT WIN32API SurfUnlock4(THIS This, LPRECT lpSurfaceRect)
 {
   // MS changed the parameter from LPVOID to LPRECT with DX6
@@ -5185 +5037 @@
   HRESULT rc;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUnlock4\n"));
-  #endif
+  dprintf(("DDRAW: SurfUnlock4\n"));
 
   if(me->fLocked == FALSE)
   {
-    #ifdef DEBUG
-      dprintf(("DDRAW: Surface not locked!\n"));
-    #endif
+    dprintf(("DDRAW: Surface not locked!\n"));
     return(DDERR_NOTLOCKED);
   }
@@ -5217 +5065 @@
             pIRectUnlock->Right() ));
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: Start Emuneration of Locked Rects\n"));
-  #endif
+  dprintf(("DDRAW: Start Enumeration of Locked Rects\n"));
 
   i=0;
@@ -5234 +5080 @@
     if(!Found)
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: Not Found, try Next rect\n"));
-      #endif
+      dprintf(("DDRAW: Not Found, try Next rect\n"));
       i++;
     }
-    #ifdef DEBUG
     else
     {
       dprintf(("DDRAW: Found Rect\n"));
     }
-    #endif
   }
 
@@ -5252 +5094 @@
     if(NULL==lpSurfaceRect)
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
-      #endif
+      dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
       return(DDERR_INVALIDRECT);
     }
@@ -5262 +5102 @@
   else
   {
-    #ifdef DEBUG
-      dprintf(("DDRAW: Remove Rect from Seq.\n"));
-    #endif
+    dprintf(("DDRAW: Remove Rect from Seq.\n"));
 
     DPA_DeletePtr(me->DPA_LockedRects,i);
@@ -5270 +5108 @@
     if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
     {
-      #ifdef DEBUG
-        dprintf(("DDRAW: No Locked Rects left for surface\n"));
-      #endif
+      dprintf(("DDRAW: No Locked Rects left for surface\n"));
       me->fLocked = FALSE;
     }
@@ -5278 +5114 @@
     if(me->pFrameBuffer != me->pDiveBuffer)
     {
-      #ifdef DEBUG
-        dprintf(( "ColorConversion Needed %08X != %08X\n",
-                  me->pFrameBuffer,
-                  me->pDiveBuffer));
-      #endif
+      dprintf(( "ColorConversion Needed %08X != %08X\n",
+                me->pFrameBuffer,
+                me->pDiveBuffer));
       me->ColorConversion(lpSurfaceRect);
     }
@@ -5296 +5130 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUpdateOverlay(THIS This, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUpdateOverlay\n"));
-  #endif
+HRESULT WIN32API SurfUpdateOverlay(THIS This, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX)
+{
+  dprintf(("DDRAW: SurfUpdateOverlay\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUpdateOverlay3(THIS This, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUpdateOverlay\n"));
-  #endif
+HRESULT WIN32API SurfUpdateOverlay3(THIS This, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX)
+{
+  dprintf(("DDRAW: SurfUpdateOverlay\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUpdateOverlay\n"));
-  #endif
+HRESULT WIN32API SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX)
+{
+  dprintf(("DDRAW: SurfUpdateOverlay\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUpdateOverlayDisplay(THIS, DWORD)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUpdateOverlayDisplay\n"));
-  #endif
+HRESULT WIN32API SurfUpdateOverlayDisplay(THIS, DWORD)
+{
+  dprintf(("DDRAW: SurfUpdateOverlayDisplay\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
-  #endif
+HRESULT WIN32API SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2)
+{
+  dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
-  #endif
+HRESULT WIN32API SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3)
+{
+  dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfUpdateOverlayZOrder4\n"));
-  #endif
+HRESULT WIN32API SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4)
+{
+  dprintf(("DDRAW: SurfUpdateOverlayZOrder4\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetDDInterface(THIS This, LPVOID FAR *lplpDirectDraw)
+HRESULT WIN32API SurfGetDDInterface(THIS This, LPVOID FAR *lplpDirectDraw)
 {
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetDDInterface\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetDDInterface\n"));
   *lplpDirectDraw = (LPVOID FAR *)me->lpDraw;
   return(DD_OK);
@@ -5371 +5189 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfPageLock(THIS, DWORD)
+HRESULT WIN32API SurfPageLock(THIS, DWORD)
 {
   // Only used for DMA memory access
   // If we implement this for the None dive buffers with a pdd the we must change
   // from malloc to DosAllocMem and use OBJ_TILE flag
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfPageLock\n"));
-  #endif
+  dprintf(("DDRAW: SurfPageLock\n"));
   return(DD_OK);
 }
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfPageUnlock(THIS, DWORD)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfPageUnlock\n"));
-  #endif
+HRESULT WIN32API SurfPageUnlock(THIS, DWORD)
+{
+  dprintf(("DDRAW: SurfPageUnlock\n"));
   return(DD_OK);
 }
@@ -5394 +5208 @@
 // V3 Interface Functions
 
-HRESULT __stdcall SurfSetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurfDesc, DWORD dwFlags)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfSetSurfaceDesc\n"));
-  #endif
+HRESULT WIN32API SurfSetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurfDesc, DWORD dwFlags)
+{
+  dprintf(("DDRAW: SurfSetSurfaceDesc\n"));
 
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -5441 +5253 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfSetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurfDesc, DWORD dwFlags)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfSetSurfaceDesc4\n"));
-  #endif
+HRESULT WIN32API SurfSetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurfDesc, DWORD dwFlags)
+{
+  dprintf(("DDRAW: SurfSetSurfaceDesc4\n"));
 
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -5491 +5301 @@
 // V4 Interface Functions
 
-HRESULT __stdcall SurfSetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData,
+HRESULT WIN32API SurfSetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData,
                                      DWORD dwDataSize, DWORD dwFlags)
 {
@@ -5501 +5311 @@
   HRESULT rc;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfSetPrivateData\n"));
-  #endif
+  dprintf(("DDRAW: SurfSetPrivateData\n"));
 
   if(NULL==me)
@@ -5676 +5484 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData, LPDWORD lpDataSize)
+HRESULT WIN32API SurfGetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData, LPDWORD lpDataSize)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -5684 +5492 @@
   BOOL bFound = FALSE;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetPrivateData\n"));
-  #endif
+  dprintf(("DDRAW: SurfGetPrivateData\n"));
 
   if(NULL==me)
@@ -5737 +5543 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfFreePrivateData(THIS This, REFGUID refGUID)
+HRESULT WIN32API SurfFreePrivateData(THIS This, REFGUID refGUID)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -5744 +5550 @@
   BOOL bFound = FALSE;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfFreePrivateData\n"));
-  #endif
+  dprintf(("DDRAW: SurfFreePrivateData\n"));
 
   if(NULL==me)
@@ -5787 +5591 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfGetUniquenessValue(THIS This, LPDWORD lpValue)
-{
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfGetUniquenessValue\n"));
-  #endif
+HRESULT WIN32API SurfGetUniquenessValue(THIS This, LPDWORD lpValue)
+{
+  dprintf(("DDRAW: SurfGetUniquenessValue\n"));
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
   if (NULL==lpValue)
@@ -5801 +5603 @@
 //******************************************************************************
 //******************************************************************************
-HRESULT __stdcall SurfChangeUniquenessValue(THIS This)
+HRESULT WIN32API SurfChangeUniquenessValue(THIS This)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -5808 +5610 @@
 
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfChangeUniquenessValue\n"));
-  #endif
+  dprintf(("DDRAW: SurfChangeUniquenessValue\n"));
   me->dwUniqueValue++;
 
@@ -5964 +5764 @@
   DWORD dwTLineStart;     // # DWORD in which the first transinfo is
   DWORD dwTDWStart;       // byte in which the firs transinfo is
-  DWORD dwTrans;          // current transparentvalue
-  DWORD BlitWidth;
+
   dwTLineLen = 1 + ((pSrcDesc->dwWidth + 31) & ~31);
   pdwTLine = (DWORD*)pAlpha + (dwTLineLen* lpSrcRect->top);