Changeset 587 for trunk/src

Timestamp:

Aug 19, 1999, 8:08:48 PM (26 years ago)

Author:

hugh

Message:

Implemented new colorconversion routine and fixed bug in fastblt function.
Changed the palettehandling code

Location:

trunk/src/ddraw

Files:

• OS2DDRAW.CPP (modified) (7 diffs)
• OS2DDRAW.H (modified) (3 diffs)
• OS2PALETTE.CPP (modified) (8 diffs)
• OS2PALETTE.H (modified) (3 diffs)
• OS2SURFACE.CPP (modified) (22 diffs)
• OS2SURFACE.H (modified) (1 diff)

trunk/src/ddraw/OS2DDRAW.CPP

@@ -26 +26 @@
 #define KEY_DIRECT2DRAW "\\Software\\Win32OS2\\Direct2\\Draw"
 
-FOURCC  SupportedFourCCs[] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_RGB4};
+FOURCC  SupportedFourCCs[] = {FOURCC_SCRN,FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_RGB4};
 //******************************************************************************
 //******************************************************************************
@@ -32 +32 @@
      Referenced(0), lastError(DD_OK),
      pFrameBuffer(NULL), hwndClient(0), screenwidth(640),
-     screenheight(480), screenbpp(8),PrimaryExists(FALSE)
+     screenheight(480), screenbpp(8),PrimaryExists(FALSE),pPrimSurf(NULL)
 
 {
@@ -337 +337 @@
     #endif
 
-    newpal = new OS2IDirectDrawPalette(me, palsize, lpColorTable, dwFlags);
+    newpal = new OS2IDirectDrawPalette((VOID*)me, palsize, lpColorTable, dwFlags);
 
     if(newpal == NULL)
@@ -754 +754 @@
 {
   #ifdef DEBUG
-    WriteLog("GetCaps\n");
+    WriteLog("DDGetCaps of ");
   #endif
 
@@ -764 +764 @@
     // Caller want Driver Caps
 
+    WriteLog("Driver\n");
+
     if(sizeof(DDCAPS)!=lpDDDriverCaps->dwSize)
+    {
+      WriteLog("Size Not Set\n");
       return(DDERR_INVALIDPARAMS);
-
+    }
     // Clear structure so we only have to set the supported flags
 
@@ -777 +781 @@
 
     // Now report the CAPs back which we support
-   lpDDDriverCaps->dwCaps = DDCAPS_BLT |              // We do blitting
-                            DDCAPS_BLTCOLORFILL |     // We do colorfills
-                            DDCAPS_COLORKEY |         // We support Colorkeying
-                            DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
-                            DDCAPS_GDI |              // Maybe check if we are on Voodoo ?
-                            DDCAPS_PALETTEVSYNC;      // Got VSync
+    lpDDDriverCaps->dwCaps = DDCAPS_BLT |              // We do blitting
+                             DDCAPS_BLTCOLORFILL |     // We do colorfills
+                             DDCAPS_COLORKEY |         // We support Colorkeying
+                             DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
+                             DDCAPS_GDI |              // Maybe check if we are on Voodoo ?
+                             DDCAPS_PALETTEVSYNC;      // Got VSync
 
     lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED |         // Who cares so say yes
@@ -843 +847 @@
   if(NULL!=lpDDHELCaps)
   {
-    // Caler wants HEL Caps
+    // Caller wants HEL Caps
+    WriteLog(" HEL\n");
+
     if(sizeof(DDCAPS)!=lpDDHELCaps->dwSize)
+    {
+      WriteLog("Size Not Set\n");
       return(DDERR_INVALIDPARAMS);
+    }
+    // Clear structure so we only have to set the supported flags
+
+
+    memset(lpDDHELCaps,0,sizeof(DDCAPS));
+
+
+    // Reset the size
+    lpDDHELCaps->dwSize = sizeof(DDCAPS);
+
+    // Now report the CAPs back which we support
+    lpDDHELCaps->dwCaps = DDCAPS_BLT |              // We do blitting
+                             DDCAPS_BLTCOLORFILL |     // We do colorfills
+                             DDCAPS_COLORKEY |         // We support Colorkeying
+                             DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
+                             DDCAPS_GDI |              // Maybe check if we are on Voodoo ?
+                             DDCAPS_PALETTEVSYNC;      // Got VSync
+
+    lpDDHELCaps->dwCaps2 = DDCAPS2_CERTIFIED |         // Who cares so say yes
+                              DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
+                              DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
+                              DDCAPS2_NONLOCALVIDMEM |    // All surfaces are in memory
+                              DDCAPS2_WIDESURFACES;       // Any size you want!
+
+    lpDDHELCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
+
+//    lpDDDriverCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN; // DIVE supports this, do we also ?
+                                                         // Maybe later add stretching support?
+
+    lpDDHELCaps->dwPalCaps = DDPCAPS_8BIT |          // Only 8 Bits pals
+                                DDPCAPS_ALLOW256 |      // But all 256 colors
+                                DDPCAPS_VSYNC  |        // Vsync yet
+                                DDPCAPS_PRIMARYSURFACE; //
+    lpDDHELCaps->dwVidMemTotal = 2048*1024;           // total video memory
+    lpDDHELCaps->dwVidMemFree  = 2048*1024;            // total free video memory
+    lpDDHELCaps->dwNumFourCCCodes;        // number of supported FOURCC codes
+    lpDDHELCaps->dwRops[DD_ROP_SPACE];    // supported raster ops
+    lpDDHELCaps->dwSVBCaps = DDCAPS_BLT |              // We do blitting
+                                DDCAPS_BLTCOLORFILL |     // We do colorfills
+                                DDCAPS_COLORKEY |         // We support Colorkeying
+                                DDCAPS_COLORKEYHWASSIST;
+    lpDDHELCaps->dwSVBCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
+    lpDDHELCaps->dwSVBFXCaps;             //  .
+    lpDDHELCaps->dwSVBRops[DD_ROP_SPACE]; //  .
+    lpDDHELCaps->dwVSBCaps = DDCAPS_BLT |              // We do blitting
+                                DDCAPS_BLTCOLORFILL |     // We do colorfills
+                                DDCAPS_COLORKEY |         // We support Colorkeying
+                                DDCAPS_COLORKEYHWASSIST;
+    lpDDHELCaps->dwVSBCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
+    lpDDHELCaps->dwVSBFXCaps;             //  .
+    lpDDHELCaps->dwVSBRops[DD_ROP_SPACE]; //  .
+    lpDDHELCaps->dwSSBCaps = DDCAPS_BLT |              // We do blitting
+                                DDCAPS_BLTCOLORFILL |     // We do colorfills
+                                DDCAPS_COLORKEY |         // We support Colorkeying
+                                DDCAPS_COLORKEYHWASSIST;
+    lpDDHELCaps->dwSSBCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
+    lpDDHELCaps->dwSSBFXCaps;            //  .
+    lpDDHELCaps->dwSSBRops[DD_ROP_SPACE]; //  .
+    lpDDHELCaps->dwSVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
+                                 DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
+                                 DDCAPS2_WIDESURFACES;       // Any size you want!
+    lpDDHELCaps->dwNLVBCaps = DDCAPS_BLT |              // We do blitting
+                                 DDCAPS_BLTCOLORFILL |     // We do colorfills
+                                 DDCAPS_COLORKEY |         // We support Colorkeying
+                                 DDCAPS_COLORKEYHWASSIST;
+    lpDDHELCaps->dwNLVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
+                                  DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
+                                  DDCAPS2_WIDESURFACES;       // Any size you want!
+    lpDDHELCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
+    lpDDHELCaps->dwNLVBFXCaps;            //  .
+    lpDDHELCaps->dwNLVBRops[DD_ROP_SPACE];//  .
 
   }

trunk/src/ddraw/OS2DDRAW.H

@@ -7 +7 @@
 #define APIENTRY _System
 #include "divewrap.h"
-
 #define DEBUG 1
 #define mmioFOURCC( ch0, ch1, ch2, ch3 )                         \
@@ -13 +12 @@
                   ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
 #include <fourcc.h>
+#undef THIS
 #define THIS VOID*
 class OS2IDirectDraw
@@ -45 +45 @@
     // also needed so get all the info we can get
     DIVE_CAPS dCaps;
+    VOID *pPrimSurf;
 
   private:

trunk/src/ddraw/OS2PALETTE.CPP

@@ -4 +4 @@
 #include <memory.h>
 #define INITGUID
+#include "os2ddraw.h"
+#include "os2clipper.h"
 #include "os2palette.h"
+#include "os2surface.h"
 #define _OS2WIN_H
 #define FAR
@@ -11 +14 @@
 #include <winerror.h>
 
-//******************************************************************************
-//******************************************************************************
-OS2IDirectDrawPalette::OS2IDirectDrawPalette( OS2IDirectDraw *lpDirectDraw,
+#undef THIS
+#define THIS IDirectDrawPalette*
+
+//******************************************************************************
+//******************************************************************************
+OS2IDirectDrawPalette::OS2IDirectDrawPalette( VOID *lpDirectDraw,
                                               int palsize,
                                               LPPALETTEENTRY lpColorTable,
@@ -19 +25 @@
                                               Referenced(0), os2pal(NULL),
                                               lastError(DD_OK), lpDraw(NULL)
+
 {
   lpVtbl              = &Vtbl;
@@ -30 +37 @@
 
   lpDraw                        = lpDirectDraw;
-  lpDraw->Vtbl.AddRef(lpDraw);
-  hDive                         = lpDirectDraw->GetDiveInstance();
+  ((OS2IDirectDraw*)lpDraw)->Vtbl.AddRef(lpDraw);
+  hDive                         = ((OS2IDirectDraw*)lpDirectDraw)->GetDiveInstance();
   dwCaps                        = dwPalFlags;
+  hDiveCC                       = ((OS2IDirectDraw*)lpDirectDraw)->GetCCDiveInstance();
 
   dwSize = palsize;
@@ -41 +49 @@
   os2pal = (LPPALETTEENTRY)malloc(palsize*sizeof(PALETTEENTRY));
   memcpy((char *)os2pal, (char *)lpColorTable, palsize*sizeof(PALETTEENTRY));
+
+  for(DWORD i=0;i<dwSize;i++)
+  {
+    aPal16[i] = (lpColorTable[i].peBlue>>3) +
+                ((lpColorTable[i].peGreen>>2) <<5) +
+                ((lpColorTable[i].peRed>>3) << 11);
+    aPal24[i] = (lpColorTable[i].peBlue <<8) +
+                (lpColorTable[i].peGreen<<16) +
+                (lpColorTable[i].peRed<<24);
+  }
 }
 //******************************************************************************
@@ -48 +66 @@
   if(os2pal)
     free(os2pal);
-  lpDraw->Vtbl.Release(lpDraw);
+  ((OS2IDirectDraw*)lpDraw)->Vtbl.Release((OS2IDirectDraw*)lpDraw);
 }
 //******************************************************************************
@@ -175 +193 @@
          dwNumEntries*sizeof(PALETTEENTRY));
 
-  if(me->fAttachedToPrimary)
-    me->SetPhysPalette();
-
+  for(DWORD i=0;i<dwNumEntries;i++)
+  {
+    me->aPal16[dwBase+i] = (lpNewEntries[i].peBlue>>3) +
+                           ((lpNewEntries[i].peGreen>>2) <<5) +
+                           ((lpNewEntries[i].peRed>>3) << 11);
+    me->aPal24[dwBase+i] = (lpNewEntries[i].peBlue <<8) +
+                           (lpNewEntries[i].peGreen<<16) +
+                           (lpNewEntries[i].peRed<<24);
+  }
+
+  if(8==((OS2IDirectDraw*)me->lpDraw)->dCaps.ulDepth)
+  {
+    if(me->fAttachedToPrimary)
+      me->SetPhysPalette();
+  }
+  else
+  {
+    if(NULL!=((OS2IDirectDraw*)me->lpDraw)->pPrimSurf)
+      ((OS2IDirectDrawSurface*)((OS2IDirectDraw*)me->lpDraw)->pPrimSurf)->ColorConversion(NULL);;
+  }
+  /*
+  if(NULL!=me->hDiveCC)
+  {
+    DiveSetSourcePalette( me->hDiveCC,
+                          dwBase,
+                          dwNumEntries,
+                          (PBYTE)lpNewEntries);
+
+  }
+  else
+  {
+    // Only usefull if system and game are in 8bit mode
+    // 16bit games don't use palettes and setting the Phys palette
+    // in >8Bit Modes has no effect.
+
+    if(me->fAttachedToPrimary)
+      me->SetPhysPalette();
+  }
+  */
   return(DD_OK);
 }
@@ -199 +253 @@
     return;
   fAttachedToPrimary = fNewVal;
+
+  /*
   if(fAttachedToPrimary)
-    SetPhysPalette();
-
-}
-//******************************************************************************
-//******************************************************************************
-
+  {
+    if(NULL!=hDiveCC)
+      DiveSetSourcePalette( hDiveCC,
+                            0,
+                            255,
+                            (PBYTE)os2pal);
+    else
+      SetPhysPalette();
+  }
+  */
+}
+//******************************************************************************
+//******************************************************************************
+

trunk/src/ddraw/OS2PALETTE.H

@@ -2 +2 @@
 #define __OS2PALETTE_H__
 
-#include "os2ddraw.h"
 #include "divewrap.h"
 #define FAR
@@ -27 +26 @@
   IDirectDrawPaletteVtbl  Vtbl;
 
-  OS2IDirectDrawPalette( OS2IDirectDraw *lpDirectDraw,
+  OS2IDirectDrawPalette( VOID *lpDirectDraw,
                          int palsize,
                          LPPALETTEENTRY lpColorTable,
@@ -38 +37 @@
   int           Referenced;
   inline  HRESULT       GetLastError() { return lastError; };
+  WORD           aPal16[256];
+  DWORD          aPal24[256];
  private:
 
  protected:
   HDIVE          hDive;
+  HDIVE          hDiveCC;
   HRESULT        lastError;
   LPPALETTEENTRY os2pal;
-  OS2IDirectDraw *lpDraw;
+  VOID           *lpDraw;
   DWORD          dwCaps;
   DWORD          dwSize;

trunk/src/ddraw/OS2SURFACE.CPP

@@ -6 +6 @@
                   ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
 #include <fourcc.h>
+#define INITGUID
+#include "os2ddraw.h"
+#include "os2clipper.h"
+#include "os2palette.h"
 #include "os2surface.h"
 #include "rectangle.h"
@@ -154 +158 @@
   WriteLog("\n");
 }
+
+static void _dump_DDSCAPS2(DWORD flagmask) {
+  int  i;
+  const struct {
+    DWORD  mask;
+    char  *name;
+  } flags[] = {
+#define FE(x) { x, #x},
+    FE(DDSCAPS2_HARDWAREDEINTERLACE)
+    FE(DDSCAPS2_HINTANTIALIASING)
+    FE(DDSCAPS2_HINTDYNAMIC)
+    FE(DDSCAPS2_HINTSTATIC)
+    FE(DDSCAPS2_OPAQUE)
+    FE(DDSCAPS2_TEXTUREMANAGE)
+  };
+  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
+    if (flags[i].mask & flagmask)
+      WriteLog("%s ",flags[i].name);
+  WriteLog("\n");
+}
+
 
 static void _dump_DDSD(DWORD flagmask) {
@@ -553 +578 @@
       height = DDSurfaceDesc.dwHeight;
 
+      lpDraw->pPrimSurf = this;
+
       lastError = DD_OK;
       return;
@@ -591 +618 @@
       {
         WriteLog(" Use Screen Format :");
-        dwBpp = dwBytesPPDive << 3; // No use Screenformat
+        dwBpp = lpDraw->GetScreenBpp(); // No use Screenformat
         lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
         lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC = (DWORD) lpDraw->GetScreenFourCC();
@@ -740 +767 @@
           dwPitchFB = lpDDSurfaceDesc->dwWidth * (dwBpp<8?1:dwBpp/8);
           dwPitchFB = (dwPitchFB +7) & ~7;  // Align on QWords
-
           DDSurfaceDesc.lPitch    = dwPitchFB;
           lpDDSurfaceDesc->lPitch = dwPitchFB;
@@ -764 +790 @@
           pFrameBuffer = (char*)(((int)pFBreal + 7) & ~7); // align to QWORD
 
-          WriteLog( " Framebuffer @ %08X QWAligned @ %08X with a Pitch of %d",
+          WriteLog( " Framebuffer @ %08X QWAligned @ %08X with a Pitch of %d\n",
                     pFBreal, pFrameBuffer, dwPitchFB);
 
@@ -780 +806 @@
           {
             WriteLog(" Alloc CCBuf ");
+            dwPitchDB = (lpDDSurfaceDesc->dwWidth * (lpDraw->dCaps.ulDepth/8) +7) & ~7;
             if(Mainchain)
             {
@@ -790 +817 @@
                                     lpDDSurfaceDesc->dwWidth,
                                     lpDDSurfaceDesc->dwHeight,
-                                    (lpDDSurfaceDesc->dwWidth * (lpDraw->dCaps.ulDepth/8) +7) & ~7,
+                                    dwPitchDB,
                                     (PBYTE)pDiveBuffer);
             }
             else
             {
-              WriteLog("with malloc");
+              WriteLog( "with malloc (%dx%d) Pitch %d ",
+                        lpDDSurfaceDesc->dwHeight,
+                        lpDDSurfaceDesc->dwWidth,
+                        dwPitchDB);
               // No so we must create the Divebuffer to do the colortranslation
               // and blit to the real framebuffer on Unlock to do color conversion
               pDiveBuffer = (char*)malloc( lpDDSurfaceDesc->dwHeight *
-                                   ((lpDDSurfaceDesc->dwWidth * (lpDraw->dCaps.ulDepth/8) +7) & ~7) );
+                                           dwPitchDB);
             }
+            WriteLog( "  @ %08X\n", pDiveBuffer);
           }
 
@@ -1154 +1185 @@
 void OS2IDirectDrawSurface::ColorConversion(LPRECT lpRect)
 {
+  char *pSrc,*pDst,*pSLine,*pDLine;
+  DWORD CCwidth,CCheight,x,y;
+  DWORD *pPal24;
+  WORD  *pPal16;
+
+  if(NULL== lpDraw->pPrimSurf)
+  {
+    WriteLog("No Primary Surface! => No CC\n");
+    return;
+  }
+
+  if(NULL== ((OS2IDirectDrawSurface*)lpDraw->pPrimSurf)->lpPalette)
+  {
+    WriteLog("No DDrawpalette defined!=> No CC\n");
+    return;
+  }
+
+  if(NULL==lpRect)
+  {
+    pSrc = pFrameBuffer;
+    pDst = pDiveBuffer;
+    CCwidth  = width;
+    CCheight = height;
+  }
+  else
+  {
+    // ToDo: Check why the top/bottom values come in swaped here
+    // for now simply reverse them with the following 3 lines
+    y = lpRect->top;
+    lpRect->top = lpRect->bottom;
+    lpRect->bottom = y;
+    // end of hack
+    pSrc = pFrameBuffer +
+           (lpRect->top * dwPitchFB) +
+           (lpRect->left* (lpDraw->dCaps.ulDepth/8));
+    pDst = pDiveBuffer +
+           (lpRect->top * dwPitchDB) +
+           (lpRect->left* dwBytesPPDive);
+    CCwidth  = lpRect->right - lpRect->left;
+    CCheight = lpRect->bottom - lpRect->top;
+
+  }
+
+  WriteLog( "H: %d W: %d\n SRC @ %08X\n DST @ %08X\n",
+            CCheight, CCwidth, pSrc,pDst);
+
+  pSLine = pSrc;
+  pDLine = pDst;
+
+  switch(lpDraw->dCaps.ulDepth)
+  {
+    case 8:
+      WriteLog(" 8Bit target CC not implemented\n");
+      break;
+    case 15:
+      WriteLog(" 15 Bit not implemented using 16bit might look ugly\n");
+    case 16:
+      if(8==lpDraw->GetScreenBpp())
+      {
+        pPal16 = ((OS2IDirectDrawSurface*)lpDraw->pPrimSurf)->lpPalette->aPal16;
+        WriteLog("8->16Bit CC\n");
+        for(y=0;CCheight;CCheight--,y++)
+        {
+          WriteLog("Converting Line %d\n",y);
+          for(x=0;x<width;x++)
+          {
+            *((WORD*)pDLine) = pPal16[pSLine[x]];
+          }
+          pSLine += dwPitchFB;
+          pDLine += dwPitchDB;
+        }
+      }
+      else
+      {
+        WriteLog("%d ->16Bit Not implemented",lpDraw->GetScreenBpp());
+      }
+      break;
+    case 24:
+      if(8==lpDraw->GetScreenBpp())
+      {
+        WriteLog("8->24Bit CC");
+      }
+      else
+      {
+        WriteLog("%d ->16Bit Not implemented",lpDraw->GetScreenBpp());
+      }
+      break;
+    case 32:
+      if(8==lpDraw->GetScreenBpp())
+      {
+        WriteLog("8->32Bit CC");
+      }
+      else
+      {
+        WriteLog("%d ->16Bit Not implemented",lpDraw->GetScreenBpp());
+      }
+      break;
+    default:
+      #ifdef DEBUG
+        WriteLog( "Unexpected Screen Bitdepth %d\n",
+                  lpDraw->dCaps.ulDepth);
+      #endif
+      break;
+  }
+
+/*
   SETUP_BLITTER sBlt;
   ULONG ulDN1, ulDN2;
@@ -1182 +1319 @@
   sBlt.lDstPosY          = sBlt.ulSrcPosY;
   sBlt.ulNumDstRects     = DIVE_FULLY_VISIBLE;
+
+  WriteLog( "Colorconversion:\n FCC SRC %08X\n FCC DST %08X\n",
+            sBlt.fccSrcColorFormat,
+            sBlt.fccDstColorFormat );
 
   rc = DiveAllocImageBuffer( hDiveCC,
@@ -1190 +1331 @@
                              dwPitchFB,
                              (PBYTE)pFrameBuffer);
-  WriteLog("AllocDiveSrc Buffer rc= %X\n",rc);
+  WriteLog("AllocDiveSrc Buffer rc= 0x%08X\n",rc);
 
   rc = DiveAllocImageBuffer( hDiveCC,
@@ -1199 +1340 @@
                              dwPitchDB,
                              (PBYTE)pDiveBuffer);
-  WriteLog("AllocDiveDst Buffer rc= %Xd\n",rc);
+  WriteLog("AllocDiveDst Buffer rc= 0x%08X\n",rc);
 
   rc = DiveSetupBlitter( hDiveCC,
@@ -1219 +1360 @@
 
   WriteLog("Free dst rc= %X\n",rc);
-
+*/
 }
 //******************************************************************************
@@ -2571 +2712 @@
   BlitWidth  = (SrcRect.right - SrcRect.left) * src->dwBytesPPDive;
 
-  if(dwTrans & DDBLTFAST_NOCOLORKEY)
+  // Remove unsupported wait flag
+  dwTrans &= ~DDBLTFAST_WAIT;
+
+  if(DDBLTFAST_NOCOLORKEY == dwTrans )
   {
     WriteLog("Solid Blit");
@@ -2593 +2737 @@
   else
   {
-    WriteLog("TransBlit");
+    WriteLog("TransBlit\n");
 
     if(dwTrans & DDBLTFAST_SRCCOLORKEY)
     {
+      WriteLog("Trans SRC\n");
       // transparent source
       dwSrcColor = src->DDSurfaceDesc.ddckCKSrcBlt.dwColorSpaceLowValue;
       if(dwTrans & DDBLTFAST_DESTCOLORKEY)
       {
+        WriteLog("And Dest Colorkey");
         dwDestColor = dest->DDSurfaceDesc.ddckCKDestBlt.dwColorSpaceLowValue;
         // Source and dest colorkeying
@@ -2697 +2843 @@
         // This MMX detection should be moved into OS2Draw
         // and into the surface constructor a setup for blitting pointers
-
+        WriteLog("Only Src ColorKey");
         switch(dest->dwBytesPPDive)
         {
@@ -2768 +2914 @@
       if(dwTrans & DDBLTFAST_DESTCOLORKEY)
       {
+        WriteLog("DestColorKey\n");
+
         dwDestColor = dest->DDSurfaceDesc.ddckCKDestBlt.dwColorSpaceLowValue;
         switch(dest->dwBytesPPDive)
@@ -2844 +2992 @@
         }  // End switch
       }
+      else
+      {
+        WriteLog("Unexpected Flags");
+      }
     }
   }
@@ -3349 +3501 @@
 
   lpDDCaps->dwCaps = me->DDSurfaceDesc.ddsCaps.dwCaps;
-
+  #ifdef DEBUG
+    _dump_DDSCAPS(lpDDCaps->dwCaps);
+  #endif
   return(DD_OK);
 }
@@ -3365 +3519 @@
 
   memcpy(lpDDCaps, &(me->DDSurfaceDesc.ddsCaps), sizeof(DDSCAPS2) );
+  #ifdef DEBUG
+    _dump_DDSCAPS(lpDDCaps->dwCaps);
+    _dump_DDSCAPS2(lpDDCaps->dwCaps2);
+
+  #endif
 
   return(DD_OK);
@@ -4098 +4257 @@
       // primary surface => doesn't modify physical palette
       if(me->surfaceType & DDSCAPS_PRIMARYSURFACE)
+      {
         me->lpPalette->SetIsPrimary(FALSE);
-
+      }
       me->lpPalette->Vtbl.Release((IDirectDrawPalette*)me->lpPalette);
       me->lpPalette = NULL;
@@ -4128 +4288 @@
 
   if(me->surfaceType & DDSCAPS_PRIMARYSURFACE)
+  {
     me->lpPalette->SetIsPrimary(TRUE);
-
+  }
   me->lpVtbl->ChangeUniquenessValue(me);
 

trunk/src/ddraw/OS2SURFACE.H

@@ -2 +2 @@
 #define __OS2SURFACE_H__
 #define FAR
-#define INITGUID
-#include "os2ddraw.h"
-#include "os2clipper.h"
-#include "os2palette.h"
 #include "divewrap.h"
 #include <commctrl.h>