Changeset 503 for trunk/src

Timestamp:

Aug 16, 1999, 2:40:48 AM (26 years ago)

Author:

hugh

Message:

Changed to use ODINCRT macros to preserve FS, but still does crash

Location:

trunk/src/ddraw

Files:

• OS2CLIPPER.CPP (modified) (2 diffs)
• OS2D3D.CPP (modified) (3 diffs)
• OS2DDRAW.CPP (modified) (42 diffs)
• OS2PALETTE.CPP (modified) (4 diffs)
• OS2PALSET.CPP (modified) (5 diffs)
• OS2SURFACE.CPP (modified) (78 diffs)
• OS2UTIL.CPP (modified) (2 diffs)
• ddraw.CPP (modified) (5 diffs)
• makefile (modified) (2 diffs)
• os2DDWindow.cpp (modified) (4 diffs)

trunk/src/ddraw/OS2CLIPPER.CPP

@@ -8 +8 @@
 #include "misc.h"
 #include <winerror.h>
+#include <odincrt.h>
 
 //******************************************************************************
@@ -83 +84 @@
     if(me->Referenced == 0)
     {
-      delete me;
+      ODIN_delete( me);
       return(0);
     }

trunk/src/ddraw/OS2D3D.CPP

@@ -11 +11 @@
 #include <winerror.h>
 #include <builtin.h>
+#include <odincrt.h>
 #undef THIS
 #define THIS VOID*
@@ -22 +23 @@
 
   if(IID_IDirect3D != (GUID &)&riid)
-  return E_NOINTERFACE;
+    return E_NOINTERFACE;
 
   *ppvObj = This;
@@ -46 +47 @@
   dprintf(("OS2IDirectDraw::Release %d\n", me->Referenced-1));
   dprintf(("OS2IDirectDraw::%X \n", me));
-  if(me->Referenced) {
-  me->Referenced--;
-  if(me->Referenced == 0) {
-    delete me;
+  if(me->Referenced)
+  {
+    me->Referenced--;
+    if(me->Referenced == 0)
+    {
+      ODIN_delete(me);
+      return(0);
+    }
+    else
+      return me->Referenced;
+  }
+  else
     return(0);
-  }
-  else    return me->Referenced;
-  }
-  else  return(0);
 }
 //******************************************************************************

trunk/src/ddraw/OS2DDRAW.CPP

@@ -21 +21 @@
 #include "os2ddrawmodes.h"
 #include "os2DDWindow.h"
-
+#include "os2palset.h"
+#include <odincrt.h>
 #define KEY_DIRECT2 "\\Software\\Win32OS2\\Direct2"
 #define KEY_DIRECT2DRAW "\\Software\\Win32OS2\\Direct2\\Draw"
@@ -36 +37 @@
   HKEY  hkDirectDraw2;
   DWORD dwVSize, dwVType;
+  ULONG rc;
 
   // Setup table for 3d devices
@@ -126 +128 @@
   }
 
-  ULONG rc = DiveOpen( &hDive,
-                       FALSE,
-                       &pFrameBuffer);
+  ODIN_FS_BEGIN
+    rc = DiveOpen( &hDive,
+                   FALSE,
+                   &pFrameBuffer);
+  ODIN_FS_END
   if(rc)
   {
@@ -160 +164 @@
   if(hDive)
     DiveClose(hDive);
+  if(hDiveColorConv)
+    DiveClose(hDiveColorConv);
+
+  // Safty call in case the program did set the pal to all black
+  // so if the destructor gets called we might be able change this back
+  OS2ResetPhysPalette();
 }
 //******************************************************************************
@@ -199 +209 @@
   *ppvObj = This;
   DrawAddRef(This);
+
   return(DD_OK);
 }
@@ -218 +229 @@
 {
  OS2IDirectDraw *me = (OS2IDirectDraw *)This;
+ ULONG rc;
 
   #ifdef DEBUG
@@ -230 +242 @@
     if(me->Referenced == 0)
     {
-      delete me;
-      return(0);
+      ODIN_delete(me);
+      rc = 0;
     }
     else
-      return me->Referenced;
+      rc = me->Referenced;
   }
   else
-    return(0);
+    rc = 0;
+
+  return rc;
 }
 //******************************************************************************
@@ -254 +268 @@
 {
  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
- OS2IDirectDrawClipper *newclip = new OS2IDirectDrawClipper(me);
+ OS2IDirectDrawClipper *newclip;
  HRESULT                rc;
 
+ ODIN_FS_BEGIN
+
+  newclip = new OS2IDirectDrawClipper(me);
+
   #ifdef DEBUG
     WriteLog("CreateClipper\n");
@@ -262 +280 @@
 
   if(newclip == NULL)
-    return(DDERR_OUTOFMEMORY);
-
-  newclip->Vtbl.AddRef((IDirectDrawClipper *)newclip);
-  rc = newclip->GetLastError();
-  if(rc != DD_OK)
-  {
-    *lplpDD = NULL;
-    delete newclip;
+  {
+    rc = DDERR_OUTOFMEMORY;
   }
   else
-    *lplpDD = (IDirectDrawClipper *)newclip;
+  {
+    newclip->Vtbl.AddRef((IDirectDrawClipper *)newclip);
+    rc = newclip->GetLastError();
+    if(rc != DD_OK)
+    {
+      *lplpDD = NULL;
+      delete newclip;
+    }
+    else
+      *lplpDD = (IDirectDrawClipper *)newclip;
+  }
+
+  ODIN_FS_END
 
   return(rc);
@@ -285 +309 @@
   OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
   OS2IDirectDrawPalette *newpal;
-  HRESULT                rc;
+  HRESULT                rc = DD_OK;
   int                    palsize = 0;
 
+  ODIN_FS_BEGIN
+
   if(dwFlags & DDPCAPS_8BITENTRIES)
   {
     // We Don't support Indexed palettes...
 
-    return DDERR_INVALIDPARAMS;
+    rc = DDERR_INVALIDPARAMS;
   }
 
@@ -305 +331 @@
 
   if(palsize == 0)
-    return DDERR_INVALIDPARAMS;
-
-  #ifdef DEBUG
-    WriteLog("CreatePalette with %d colors\n", palsize);
-  #endif
-
-  newpal = new OS2IDirectDrawPalette(me, palsize, lpColorTable, dwFlags);
-  if(newpal == NULL)
-    return(DDERR_OUTOFMEMORY);
-
-  newpal->Vtbl.AddRef((IDirectDrawPalette *)newpal);
-  rc = newpal->GetLastError();
-  if(rc != DD_OK)
-  {
-    *lplpDD = NULL;
-    delete newpal;
-  }
-  else
-    *lplpDD = (IDirectDrawPalette *)newpal;
+    rc = DDERR_INVALIDPARAMS;
+
+  if(DD_OK == rc)
+  {
+    #ifdef DEBUG
+      WriteLog("CreatePalette with %d colors\n", palsize);
+    #endif
+
+    newpal = new OS2IDirectDrawPalette(me, palsize, lpColorTable, dwFlags);
+
+    if(newpal == NULL)
+    {
+      rc = DDERR_OUTOFMEMORY;
+    }
+    else
+    {
+      newpal->Vtbl.AddRef((IDirectDrawPalette *)newpal);
+      rc = newpal->GetLastError();
+
+      if(DD_OK != rc)
+      {
+        *lplpDD = NULL;
+        delete newpal;
+      }
+      else
+        *lplpDD = (IDirectDrawPalette *)newpal;
+    }
+  }
+
+  ODIN_FS_END
 
   return(rc);
@@ -336 +373 @@
  OS2IDirectDrawSurface *newsurf;
  HRESULT                rc;
+
+  ODIN_FS_BEGIN
 
   #ifdef DEBUG
@@ -351 +390 @@
 
   newsurf = new OS2IDirectDrawSurface(me, (LPDDSURFACEDESC2)lpDDSurfaceDesc);
-
   if(newsurf == NULL)
-    return(DDERR_OUTOFMEMORY);
-
-  newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
-  rc = newsurf->GetLastError();
-  if(rc != DD_OK)
-  {
-    WriteLog("Error createing Surface\n\n");
-    *lplpDD = NULL;
-    delete newsurf;
+  {
+    rc = DDERR_OUTOFMEMORY;
   }
   else
-    *lplpDD = (IDirectDrawSurface *)newsurf;
-
-  WriteLog("New Surface created at %08X\n\n", newsurf);
+  {
+    newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
+    rc = newsurf->GetLastError();
+    if(rc != DD_OK)
+    {
+      WriteLog("Error createing Surface\n\n");
+      *lplpDD = NULL;
+      delete newsurf;
+    }
+    else
+      *lplpDD = (IDirectDrawSurface *)newsurf;
+
+    WriteLog("New Surface created at %08X\n\n", newsurf);
+  }
+
+  ODIN_FS_END
+
   return(rc);
 }
@@ -379 +424 @@
  HRESULT                rc;
 
-#ifdef DEBUG
-  WriteLog("CreateSurface4\n");
-  WriteLog("dwSize %d\n", lpDDSurfaceDesc2->dwSize);
-  WriteLog("dwHeight %d\n", lpDDSurfaceDesc2->dwHeight);
-  WriteLog("dwWidth %d\n", lpDDSurfaceDesc2->dwWidth);
-  WriteLog("lPitch %d\n", lpDDSurfaceDesc2->lPitch);
-  WriteLog("dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount);
-  WriteLog("dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount);
-  WriteLog("dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth);
-  WriteLog("ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps);
-#endif
+  ODIN_FS_BEGIN
+
+  #ifdef DEBUG
+    WriteLog("CreateSurface4\n");
+    WriteLog("dwSize %d\n", lpDDSurfaceDesc2->dwSize);
+    WriteLog("dwHeight %d\n", lpDDSurfaceDesc2->dwHeight);
+    WriteLog("dwWidth %d\n", lpDDSurfaceDesc2->dwWidth);
+    WriteLog("lPitch %d\n", lpDDSurfaceDesc2->lPitch);
+    WriteLog("dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount);
+    WriteLog("dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount);
+    WriteLog("dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth);
+    WriteLog("ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps);
+  #endif
 
   newsurf = new OS2IDirectDrawSurface(me, lpDDSurfaceDesc2);
 
   if(newsurf == NULL)
-    return(DDERR_OUTOFMEMORY);
-
-  newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
-  rc = newsurf->GetLastError();
-  if(rc != DD_OK)
-  {
-    WriteLog("Error createing Surface\n\n");
-    *lplpDD = NULL;
-    delete newsurf;
+  {
+    rc =DDERR_OUTOFMEMORY;
   }
   else
-    *lplpDD = (IDirectDrawSurface4 *)newsurf;
-
-  WriteLog("New Surface created at %08X\n\n", newsurf);
+  {
+    newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
+    rc = newsurf->GetLastError();
+    if(rc != DD_OK)
+    {
+      WriteLog("Error createing Surface\n\n");
+      *lplpDD = NULL;
+
+      delete newsurf;
+    }
+    else
+      *lplpDD = (IDirectDrawSurface4 *)newsurf;
+
+    WriteLog("New Surface created at %08X\n\n", newsurf);
+  }
+
+  ODIN_FS_END
 
   return(rc);
@@ -416 +470 @@
 {
   #ifdef DEBUG
-    WriteLog("DuplicateSurface\n");
+    WriteLog("DuplicateSurface NIY\n");
   #endif
   return(DD_OK);
@@ -425 +479 @@
 {
   #ifdef DEBUG
-    WriteLog("DuplicateSurface\n");
+    WriteLog("DuplicateSurface4 NIY\n");
   #endif
 
@@ -454 +508 @@
   }
 
+
+  ODIN_FS_BEGIN
 
   // Setting up the surface
@@ -481 +537 @@
         DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
         if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
+        {
+          {ODIN_FS_END
           return (DD_OK);
+        }
       }
       // Don't know the flag for Mode X so we skip reporting it
@@ -550 +609 @@
         DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
         if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
+        {
+          {ODIN_FS_END
           return (DD_OK);
+        }
       }
       // Don't know the flag for Mode X so we skip reporting it
@@ -619 +681 @@
 
       if (lpDDSurfaceDesc->dwFlags & !(DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT))
+      {
+        {ODIN_FS_END
         return(DDERR_INVALIDPARAMS);
+      }
 
       iMode = 2;
@@ -652 +717 @@
   }
 
+  ODIN_FS_END
+
   return(DD_OK);
 }
@@ -665 +732 @@
 
   #ifdef DEBUG
-    WriteLog("EnumDisplayModes4\n");
+    WriteLog("EnumDisplayModes4 NIY\n");
   #endif
   return(DD_OK);
@@ -674 +741 @@
 {
   #ifdef DEBUG
-    WriteLog("EnumSurfaces\n");
+    WriteLog("EnumSurfaces NIY\n");
   #endif
 
@@ -684 +751 @@
 {
   #ifdef DEBUG
-    WriteLog("EnumSurfaces4\n");
+    WriteLog("EnumSurfaces4 NIY\n");
   #endif
 
@@ -694 +761 @@
 {
   #ifdef DEBUG
-    WriteLog("FlipToGDISurface\n");
+    WriteLog("FlipToGDISurface NIY\n");
   #endif
 
@@ -718 +785 @@
 
     // Clear structure so we only have to set the supported flags
+
+    ODIN_FS_BEGIN
     memset(lpDDDriverCaps,0,sizeof(DDCAPS));
+    ODIN_FS_END
 
     // Reset the size
@@ -1063 +1133 @@
 {
   #ifdef DEBUG
-    WriteLog("GetGDISurface\n");
+    WriteLog("GetGDISurface NYI\n");
   #endif
 
@@ -1073 +1143 @@
 {
   #ifdef DEBUG
-    WriteLog("GetGDISurface\n");
+    WriteLog("GetGDISurface NYI\n");
   #endif
 
@@ -1089 +1159 @@
   if(NULL==lpdwFreq)
     return(DDERR_INVALIDPARAMS);
+
+  ODIN_FS_BEGIN
 
   if(DD_OK==DrawWaitForVerticalBlank(This, dwFlags, 0))
@@ -1110 +1182 @@
     *lpdwFreq = 70;
   }
+
+  ODIN_FS_END
+
   return(DD_OK);
 }
@@ -1140 +1215 @@
 HRESULT __stdcall DrawGetVerticalBlankStatus(THIS , LPBOOL lpbIsInVB)
 {
+  int rc;
   #ifdef DEBUG
     WriteLog("GetVerticalBlankStatus\n");
@@ -1145 +1221 @@
   if(NULL==lpbIsInVB)
     return(DDERR_INVALIDPARAMS);
-  if(0==io_init1())  // try to get IOPL for the thread
+
+  ODIN_FS_BEGIN
+    rc = io_init1();
+  ODIN_FS_END
+
+  if(0==rc)  // try to get IOPL for the thread
   {
     *lpbIsInVB = (c_inb1(0x3da)&0x08)!=0;
-    io_exit1(); // reset IOPL
+    ODIN_FS_BEGIN
+      io_exit1(); // reset IOPL
+    ODIN_FS_END
     return(DD_OK);
   }
@@ -1186 +1269 @@
   me->hwndClient = hwndClient;
   #if 0
-  OS2DDSubclassWindow(hwndClient);
+    OS2DDSubclassWindow(hwndClient);
   #endif
   return(DD_OK);
@@ -1200 +1283 @@
  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
 
-#ifdef DEBUG
-  WriteLog("SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP);
-#endif
+  #ifdef DEBUG
+    WriteLog("SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP);
+  #endif
+
   me->screenwidth  = dwWidth;
   me->screenheight = dwHeight;
@@ -1247 +1331 @@
 {
   HRESULT rc;
+  int rci;
+
   #ifdef DEBUG
     WriteLog("WaitForVerticalBlank\n");
@@ -1254 +1340 @@
     return (DDERR_UNSUPPORTED);
 
-  if(io_init1())  // try to get IOPL for the thread
+  ODIN_FS_BEGIN
+    rci = io_init1();
+  ODIN_FS_END
+
+  if(rci)  // try to get IOPL for the thread
     return (DDERR_UNSUPPORTED);  // we failed so return error that we don't support this
 
@@ -1283 +1373 @@
   }
 
-  io_exit1();
+  ODIN_FS_BEGIN
+    io_exit1();
+  ODIN_FS_END
 
   return (rc);
@@ -1344 +1436 @@
 {
   #ifdef DEBUG
-    WriteLog("GetSurfaceFromDC Unimplemented Stub\n");
+    WriteLog("GetSurfaceFromDC NYI\n");
   #endif
 
@@ -1379 +1471 @@
   if(NULL==lpdddi)
     return DDERR_INVALIDPARAMS;
+
+  ODIN_FS_BEGIN
 
   memset( lpdddi,
@@ -1388 +1482 @@
   strcpy( lpdddi->szDescription,
           "ODIN DD Emulation Driver");
+
+  ODIN_FS_END
+
   return(DD_OK);
 }
@@ -1396 +1493 @@
   DWORD dwVType, dwVSize;
   HKEY hkDirectDraw2;
+
+  ODIN_FS_BEGIN
 
   if (bScale)
@@ -1410 +1509 @@
       bScale = FALSE;
   }
-}
-//******************************************************************************
-//******************************************************************************
-
+
+  ODIN_FS_END
+}
+//******************************************************************************
+//******************************************************************************
+

trunk/src/ddraw/OS2PALETTE.CPP

@@ -10 +10 @@
 #include "os2palset.h"
 #include <winerror.h>
+#include <odincrt.h>
 
 //******************************************************************************
@@ -96 +97 @@
     if(me->Referenced == 0)
     {
-      delete me;
+      ODIN_delete(me);
       return(0);
     }
@@ -141 +142 @@
     return(DDERR_INVALIDPARAMS);
 
+  ODIN_FS_BEGIN
+
   memcpy( (char *)lpEntries,
           (char *)(me->os2pal + dwBase),
           dwNumEntries*sizeof(PALETTEENTRY));
+
+  ODIN_FS_END
+
   return(DD_OK);
 }
@@ -169 +175 @@
   if( (NULL== lpNewEntries) ||(0!=dwFlags) ||(dwBase<0) ||((dwBase + dwNumEntries)>me->dwSize) )
     return(DDERR_INVALIDPARAMS);
+
+  ODIN_FS_BEGIN
+
   memcpy((char *)(me->os2pal + dwBase),
          (char *)lpNewEntries,
          dwNumEntries*sizeof(PALETTEENTRY));
+
+  ODIN_FS_END
 
   if(me->fAttachedToPrimary)

trunk/src/ddraw/OS2PALSET.CPP

@@ -7 +7 @@
 #include <string.h>
 #include "os2palset.h"
-#define FAR
-#include "misc.h"
-
+#include <odincrt.h>
 //******************************************************************************
 //******************************************************************************
@@ -19 +17 @@
  RGB2 os2rgb[256];
  int  i;
+
+  ODIN_FS_BEGIN
 
   hps = WinGetPS(HWND_DESKTOP);
@@ -44 +44 @@
                      TRUE);
   WinReleasePS(hps);
+
+  ODIN_FS_END
+
 }
 //******************************************************************************
@@ -51 +54 @@
  HPS hps;
  HDC hdc;
+
+  ODIN_FS_BEGIN
 
   hps = WinGetPS( HWND_DESKTOP);
@@ -65 +70 @@
 
   WinReleasePS(hps);
+
+  ODIN_FS_END
+
 }
 //******************************************************************************

trunk/src/ddraw/OS2SURFACE.CPP

@@ -13 +13 @@
 #include "asmutil.h"
 #include <winerror.h>
+#include <odincrt.h>
+
 #ifndef __WATCOMC__
-#include <builtin.h>
+  #include <builtin.h>
 #endif
 
@@ -992 +994 @@
   pFillPos = pLine + dwPitchDB;
 
+  #ifndef USE_ASM
+    ODIN_FS_BEGIN
+  #endif
   for( y=0;y<FillHeight;y++,pFillPos+=dwPitchDB)
   {
@@ -1003 +1008 @@
     #endif
   }
+  #ifndef USE_ASM
+    ODIN_FS_END
+  #endif
 
   return(DD_OK);
@@ -1225 +1233 @@
 int  DestroyRects(LPVOID lpItem, DWORD dwRes)
 {
-  delete (DDRectangle*) lpItem;
+  DDRectangle *pItem = (DDRectangle*) lpItem;
+  ODIN_delete(pItem);
   return 1;
 }
@@ -1243 +1252 @@
   OS2IDirectDrawSurface  *AttachedSurface;
 
+  ODIN_FS_BEGIN
+
   if(DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
   {
@@ -1317 +1328 @@
 
   lpDraw->Vtbl.Release(lpDraw);
+
+  ODIN_FS_END
+
 }
 //******************************************************************************
@@ -1406 +1420 @@
     if(me->Referenced == 0)
     {
-      delete me;
+      ODIN_delete( me);
       #ifndef __WATCOMC__
         //_interrupt(3);
@@ -1435 +1449 @@
   OS2IDirectDrawSurface *BBCursor;
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
+  int rc;
+
   #ifdef DEBUG
     WriteLog("SurfAddAttachedSurface4\n");
@@ -1466 +1482 @@
       if(me->DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
       {
-        if( DPA_InsertPtr( me->DPA_SurfaceMipMaps,
-                           DPA_GetPtrCount(me->DPA_SurfaceMipMaps),
-                           AttachedSurface) >=0)
+        ODIN_FS_BEGIN
+          rc = DPA_InsertPtr( me->DPA_SurfaceMipMaps,
+                              DPA_GetPtrCount(me->DPA_SurfaceMipMaps),
+                              AttachedSurface);
+        ODIN_FS_END
+
+        if( rc>=0)
         {
           me->DDSurfaceDesc.dwFlags |= DDSD_MIPMAPCOUNT;
@@ -1493 +1513 @@
     else
     {
-      if( DPA_InsertPtr( me->DPA_SurfaceAttached,
-                         DPA_GetPtrCount(me->DPA_SurfaceAttached),
-                         AttachedSurface) >=0)
+      ODIN_FS_BEGIN
+        rc = DPA_InsertPtr( me->DPA_SurfaceAttached,
+                            DPA_GetPtrCount(me->DPA_SurfaceAttached),
+                            AttachedSurface);
+      ODIN_FS_END
+
+      if(rc>=0)
       {
         AttachedSurface->Vtbl.AddRef(AttachedSurface);
@@ -1687 +1711 @@
   #endif
 
+  ODIN_FS_BEGIN
+
   if (NULL!=lpDestRect)
   {
@@ -1734 +1760 @@
         WriteLog("Blt: Dest Surface partly locked\n");
       #endif
+      {ODIN_FS_END
       return(DDERR_SURFACEBUSY);
     }
   }
+
+  ODIN_FS_END
 
   DestSurfaceDesc.dwSize = sizeof(DDSURFACEDESC2);
@@ -1824 +1853 @@
   }
 
+  ODIN_FS_BEGIN
+
   if (NULL!=lpSrcRect)
   {
@@ -1872 +1903 @@
         WriteLog("Blt: Src Surface partly locked\n");
       #endif
+      {ODIN_FS_END
       return(DDERR_SURFACEBUSY);
     }
   }
+
+  ODIN_FS_END
 
   if( ( (NULL==lpDestRect) && (NULL!=lpSrcRect) ) ||
@@ -1957 +1991 @@
         #else
         // Solid Blit
+        ODIN_FS_BEGIN
         while(1)
         {
@@ -1965 +2000 @@
             break;
         }
+        ODIN_FS_END
         #endif
       }
@@ -1972 +2008 @@
         if( (dwFlags &DDBLT_KEYSRC) || (dwFlags & DDBLT_KEYSRCOVERRIDE) )
         {
+          WriteLog("Transparent src blit not done yet for primary!!");
         }
         else
@@ -2018 +2055 @@
           #else
           // Solid Blit
+          ODIN_FS_BEGIN
           while(1)
           {
@@ -2026 +2064 @@
               break;
           }
+          ODIN_FS_END
           #endif
         }
         else
         {
+          WriteLog("Transblt not done yet");
           if(dwFlags & DDBLT_KEYSRC)
           {
@@ -2088 +2128 @@
         #else
         // Solid Blit
+        ODIN_FS_BEGIN
         while(1)
         {
@@ -2096 +2137 @@
             break;
         }
+        ODIN_FS_END
         #endif
       }
@@ -2502 +2544 @@
 {
   #ifdef DEBUG
-    WriteLog("SurfBltFast\n");
+    WriteLog("SurfBltFast NIY\n");
   #endif
 
@@ -2534 +2576 @@
     return DDERR_INVALIDPARAMS;
   }
+
+  ODIN_FS_BEGIN
 
   if (NULL!=lpSrcRect)
@@ -2835 +2879 @@
   dest->lpVtbl->ChangeUniquenessValue(dest);
 
+  ODIN_FS_END
+
   return(DD_OK);
 }
@@ -2954 +3000 @@
   }
 
+  ODIN_FS_BEGIN
+
   if ( (!Found) && (AttachedSurface->DDSurfaceDesc.ddsCaps.dwCaps &  DDSCAPS_MIPMAP ) )
   {
@@ -2992 +3040 @@
   }
 
+  ODIN_FS_END
+
   return(Found?DD_OK:DDERR_SURFACENOTATTACHED);
 }
@@ -3012 +3062 @@
   OS2IDirectDrawSurface *EnumSurface;
   DDSURFACEDESC2         EnumDesc;
-  int i;
+  int i,count;
   HRESULT rc;
 
@@ -3023 +3073 @@
   rc = DDENUMRET_OK;
 
+
   if(me->BackBuffer != NULL)
   {
-    memcpy(&EnumDesc,&(me->DDSurfaceDesc),sizeof(DDSURFACEDESC2));
+    ODIN_FS_BEGIN
+      memcpy(&EnumDesc,&(me->DDSurfaceDesc),sizeof(DDSURFACEDESC2));
+    ODIN_FS_END
     rc = lpCallBack((LPDIRECTDRAWSURFACE4)me->BackBuffer,&EnumDesc,lpContext);
   }
 
-  if(DPA_GetPtrCount(me->DPA_SurfaceMipMaps)>0)
+  ODIN_FS_BEGIN
+    count = DPA_GetPtrCount(me->DPA_SurfaceMipMaps);
+  ODIN_FS_END
+
+  if(count>0)
   {
     i=0;
-    while( (DDENUMRET_OK == rc) && i<DPA_GetPtrCount(me->DPA_SurfaceMipMaps) )
-    {
-      EnumSurface = (OS2IDirectDrawSurface*) DPA_FastGetPtr(me->DPA_SurfaceMipMaps,i);
-      memcpy(&EnumDesc,&(EnumSurface->DDSurfaceDesc),sizeof(DDSURFACEDESC2));
+    while( (DDENUMRET_OK == rc) && i<count )
+    {
+      ODIN_FS_BEGIN
+        EnumSurface = (OS2IDirectDrawSurface*) DPA_FastGetPtr(me->DPA_SurfaceMipMaps,i);
+        memcpy( &EnumDesc,
+                &(EnumSurface->DDSurfaceDesc),
+                sizeof(DDSURFACEDESC2));
+      ODIN_FS_END
+      // Calling back into WIN32 app so we had to reset FS
       rc = lpCallBack((LPDIRECTDRAWSURFACE4)EnumSurface,&EnumDesc,lpContext);
       i++;
@@ -3041 +3103 @@
   }
 
-  if(DPA_GetPtrCount(me->DPA_SurfaceAttached)>0)
+  ODIN_FS_BEGIN
+    count = DPA_GetPtrCount(me->DPA_SurfaceAttached);
+  ODIN_FS_END
+
+  if(count>0)
   {
     i=0;
-    while( (DDENUMRET_OK == rc) && i<DPA_GetPtrCount(me->DPA_SurfaceAttached) )
-    {
-      EnumSurface = (OS2IDirectDrawSurface*) DPA_FastGetPtr(me->DPA_SurfaceAttached,i);
-      memcpy(&EnumDesc,&(EnumSurface->DDSurfaceDesc),sizeof(DDSURFACEDESC2));
+    while( (DDENUMRET_OK == rc) && i<count )
+    {
+      ODIN_FS_BEGIN
+        EnumSurface = (OS2IDirectDrawSurface*) DPA_FastGetPtr(me->DPA_SurfaceAttached,i);
+        memcpy( &EnumDesc,
+                &(EnumSurface->DDSurfaceDesc),
+                sizeof(DDSURFACEDESC2));
+      ODIN_FS_END
       rc = lpCallBack((LPDIRECTDRAWSURFACE4)EnumSurface,&EnumDesc,lpContext);
       i++;
@@ -3220 +3290 @@
   OS2IDirectDrawSurface *EnumSurface = NULL;
   OS2IDirectDrawSurface *AttachedSurface = NULL;
+  HRESULT rc;
   int i;
 
@@ -3234 +3305 @@
   }
 
-  if( (me->BackBuffer!=NULL) && (me->BackBuffer->DDSurfaceDesc.ddsCaps.dwCaps & lpDDCaps->dwCaps) )
+  ODIN_FS_BEGIN
+
+  rc = DD_OK;
+
+  if( (me->BackBuffer!=NULL) &&
+      (me->BackBuffer->DDSurfaceDesc.ddsCaps.dwCaps & lpDDCaps->dwCaps) )
   {
     WriteLog("Return Backbuffer\n");
@@ -3251 +3327 @@
           AttachedSurface = EnumSurface;
         else
-          return(DDERR_NOTFOUND); // Not sure if this is the right return value,
+          rc = DDERR_NOTFOUND; // Not sure if this is the right return value,
                                   // but function must fail if more then one surface fits
 
@@ -3270 +3346 @@
           AttachedSurface = EnumSurface;
         else
-          return(DDERR_NOTFOUND); // Not sure if this is the right return value,
+          rc = DDERR_NOTFOUND; // Not sure if this is the right return value,
                                   // but function must fail if more then one surface fits
 
@@ -3278 +3354 @@
   }
 
-  if(NULL!=AttachedSurface)
+  if( (DD_OK==rc) &&
+      (NULL!=AttachedSurface) )
   {
     *lpDDSurf = (IDirectDrawSurface4*)AttachedSurface;
     // not sure but as we returned an reference rains usage count
     AttachedSurface->lpVtbl->AddRef(AttachedSurface);
-    return(DD_OK);
   }
   else
+  {
     *lpDDSurf = NULL;
-
-  return(DDERR_NOTFOUND);
+    rc = DDERR_NOTFOUND;
+  }
+
+  ODIN_FS_END
+
+  return rc;
 }
 //******************************************************************************
@@ -3329 +3410 @@
     return(DDERR_INVALIDPARAMS);
 
-  memcpy(lpDDCaps, &(me->DDSurfaceDesc.ddsCaps), sizeof(DDSCAPS2) );
+  ODIN_FS_BEGIN
+    memcpy(lpDDCaps, &(me->DDSurfaceDesc.ddsCaps), sizeof(DDSCAPS2) );
+  ODIN_FS_END
 
   return(DD_OK);
@@ -3372 +3455 @@
     if(DDCKEY_SRCBLT & dwFlags)
     {
-      memcpy(lpDDColKey,&(me->DDSurfaceDesc.ddckCKSrcBlt),sizeof(DDCOLORKEY) );
+      ODIN_FS_BEGIN
+        memcpy(lpDDColKey,&(me->DDSurfaceDesc.ddckCKSrcBlt),sizeof(DDCOLORKEY) );
+      ODIN_FS_END
     }
     else
@@ -3388 +3473 @@
  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
  DDSURFACEDESC2        LockedSurfaceDesc;
-
+ HRESULT rc;
  struct
  {
@@ -3409 +3494 @@
   }
 
+  ODIN_FS_BEGIN
+
+  rc = DD_OK;
+
   if(me->hdcImage == NULL)
   {
@@ -3419 +3508 @@
       #endif
       me->Vtbl.Unlock(me,NULL);
-      return(DDERR_GENERIC);
-    }
-  }
-
-  if(me->hbmImage == NULL)
+      rc = DDERR_GENERIC;
+    }
+  }
+
+  if( (DD_OK==rc) &&
+      (me->hbmImage == NULL) )
   {
     memset(&BitmapInfo, 0, sizeof(BitmapInfo));
@@ -3475 +3565 @@
       me->hdcImage = NULL;
       me->Vtbl.Unlock(me,NULL);
-      return(DDERR_GENERIC);
+      rc = DDERR_GENERIC;
     }
   }
   else
   {
-    if(me->dwLastDCUnique != me->dwUniqueValue)
+    if( (DD_OK==rc) &&
+        (me->dwLastDCUnique != me->dwUniqueValue) )
     {
       #ifdef DEBUG
@@ -3528 +3619 @@
   }
 
-  // Allways selct the bitmap into the DC! No matter if the old or a new one
-
-  if((me->hgdiOld = SelectObject(me->hdcImage, me->hbmImage)) == NULL)
-  {
-    #ifdef DEBUG
-      WriteLog("Can't select bitmap into dc!\n");
-    #endif
-    DeleteDC(me->hdcImage);
-    me->hdcImage = NULL;
-    DeleteObject(me->hbmImage);
-    me->hbmImage = NULL;
-    me->Vtbl.Unlock(me,NULL);
-    return(DDERR_GENERIC);
-  }
-
-  *hdc = me->hdcImage;
-
-  return(DD_OK);
+  // 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
+        WriteLog("Can't select bitmap into dc!\n");
+      #endif
+      DeleteDC(me->hdcImage);
+      me->hdcImage = NULL;
+      DeleteObject(me->hbmImage);
+      me->hbmImage = NULL;
+      me->Vtbl.Unlock(me,NULL);
+      rc = DDERR_GENERIC;
+    }
+    else
+    {
+      *hdc = me->hdcImage;
+    }
+  }
+
+  ODIN_FS_END
+
+  return rc;
 }
 //******************************************************************************
@@ -3619 +3717 @@
     return DDERR_INVALIDPARAMS;
 
-  memcpy((char*)lpPixelFormat,(char*)&(me->DDSurfaceDesc.ddpfPixelFormat), sizeof(DDPIXELFORMAT));
+  ODIN_FS_BEGIN
+    memcpy( (char*)lpPixelFormat,
+            (char*)&(me->DDSurfaceDesc.ddpfPixelFormat),
+            sizeof(DDPIXELFORMAT));
+  ODIN_FS_END
+
 
   return(DD_OK);
@@ -3636 +3739 @@
     return(DDERR_INVALIDPARAMS);
 
-  memcpy((char *)lpSurface, (char *)&me->DDSurfaceDesc, sizeof(DDSURFACEDESC));
+  ODIN_FS_BEGIN
+    memcpy( (char *)lpSurface,
+            (char *)&me->DDSurfaceDesc,
+            sizeof(DDSURFACEDESC));
+  ODIN_FS_END
 
   return(DD_OK);
@@ -3653 +3760 @@
     return(DDERR_INVALIDPARAMS);
 
-  memcpy((char *)lpSurface, (char *)&me->DDSurfaceDesc, sizeof(DDSURFACEDESC2));
+  ODIN_FS_BEGIN
+    memcpy( (char *)lpSurface,
+            (char *)&me->DDSurfaceDesc,
+            sizeof(DDSURFACEDESC2));
+  ODIN_FS_END
 
   return(DD_OK);
@@ -3714 +3825 @@
   SurfaceDesc4.dwSize = sizeof(DDSURFACEDESC2);
 
-  rc = SurfLock4(This, lpRect, &SurfaceDesc4, dwFlags, hEvent);
+  rc = SurfLock4( This,
+                  lpRect,
+                  &SurfaceDesc4,
+                  dwFlags,
+                  hEvent);
   if (DD_OK==rc)
   {
-    memcpy((char*)lpSurfaceDesc,(char*)&SurfaceDesc4, sizeof(DDSURFACEDESC) );
+    ODIN_FS_BEGIN
+      memcpy( (char*)lpSurfaceDesc,
+              (char*)&SurfaceDesc4,
+              sizeof(DDSURFACEDESC) );
+    ODIN_FS_END
   }
 
@@ -3735 +3854 @@
 
   BOOL Found;
-  ULONG  nrScanLines, rc;
+  ULONG  nrScanLines;
   char *pBuffer;
   DDRectangle *pIRectCurrent,*pIRectNew;
   static int times = 0;
+  HRESULT rc;
 
   #ifdef DEBUG
@@ -3748 +3868 @@
     )
     return DDERR_INVALIDPARAMS;
+
+  ODIN_FS_BEGIN
 
   if (NULL!=lpRect)
@@ -3760 +3882 @@
             pIRectNew->Bottom(),
             pIRectNew->Right() );
+
+  rc = DD_OK;
 
   if(me->fLocked)
@@ -3799 +3923 @@
         WriteLog("SurfLock4: Surface already locked\n\n");
       #endif
-      return(DDERR_SURFACEBUSY);
-    }
-  }
-
-  memcpy((char *)lpSurfaceDesc, (char *)&me->DDSurfaceDesc, sizeof(DDSURFACEDESC2));
-
-  if(lpRect != NULL)
-  {
-    lpSurfaceDesc->lpSurface =  (LPVOID)((char*)me->pFrameBuffer +
-                                (lpRect->top * me->dwPitchFB) +
-                                (lpRect->left * (lpSurfaceDesc->ddpfPixelFormat.dwRGBBitCount>>3)));
-    #ifdef DEBUG
-      WriteLog("SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left);
-    #endif
-  }
-  else
-  {
-    #ifdef DEBUG
-      WriteLog("SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface);
-    #endif
-  }
-  // Add the rectangle to the list of locked rectangles
-
-  pIRectNew->SetMemPtr(lpSurfaceDesc->lpSurface);
-
-  DPA_InsertPtr( me->DPA_LockedRects,
-                 DPA_GetPtrCount(me->DPA_LockedRects),
-                 pIRectNew);
-
-  me->fLocked = TRUE;
-
-  return(DD_OK);
+      rc = DDERR_SURFACEBUSY;
+    }
+
+  }
+
+  if(DD_OK == rc)
+  {
+    memcpy((char *)lpSurfaceDesc, (char *)&me->DDSurfaceDesc, sizeof(DDSURFACEDESC2));
+
+    if(lpRect != NULL)
+    {
+      lpSurfaceDesc->lpSurface =  (LPVOID)((char*)me->pFrameBuffer +
+                                  (lpRect->top * me->dwPitchFB) +
+                                  (lpRect->left * (lpSurfaceDesc->ddpfPixelFormat.dwRGBBitCount>>3)));
+      #ifdef DEBUG
+        WriteLog("SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left);
+      #endif
+    }
+    else
+    {
+      #ifdef DEBUG
+        WriteLog("SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface);
+      #endif
+    }
+    // Add the rectangle to the list of locked rectangles
+
+    pIRectNew->SetMemPtr(lpSurfaceDesc->lpSurface);
+
+    DPA_InsertPtr( me->DPA_LockedRects,
+                   DPA_GetPtrCount(me->DPA_LockedRects),
+                   pIRectNew);
+
+    me->fLocked = TRUE;
+  }
+
+  ODIN_FS_END
+
+  return rc;
 }
 //******************************************************************************
@@ -3850 +3980 @@
   if(hdc != me->hdcImage)
     return(DDERR_INVALIDOBJECT);
+
+  ODIN_FS_BEGIN
 
   //unselect our bitmap
@@ -3897 +4029 @@
   me->dwLastDCUnique = me->dwUniqueValue; // Store this to see if the surface was locked after we released the DC
 
+  ODIN_FS_END
+
   return(DD_OK);
 }
@@ -3951 +4085 @@
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-
+  HRESULT rc;
   #ifdef DEBUG
     WriteLog("SurfSetColorKey\n");
@@ -3963 +4097 @@
     return(DDERR_UNSUPPORTED);
 
+  ODIN_FS_BEGIN
+
   if(DDCKEY_SRCBLT & dwFlags)
   {
@@ -3978 +4114 @@
       me->DDSurfaceDesc.dwFlags &= ~DDCKEY_SRCBLT;
     }
+    rc = DD_OK;
   }
   else
-    return (DDERR_INVALIDPARAMS); // some other flags where set => error
-
-  return(DD_OK);
+    rc = DDERR_INVALIDPARAMS; // some other flags where set => error
+
+  ODIN_FS_END
+
+  return rc;
 }
 //******************************************************************************
@@ -4078 +4217 @@
   BOOL Found = FALSE;
   OS2RECTL CCRect;
+  HRESULT rc;
 
   #ifdef DEBUG
@@ -4090 +4230 @@
     return(DDERR_NOTLOCKED);
   }
+
+  ODIN_FS_BEGIN
 
   #ifdef DEBUG
@@ -4172 +4314 @@
       WriteLog("Rectangle not locked, wrong Rect!\n\n");
     #endif
-    return(DDERR_INVALIDRECT);
-  }
-
-  #ifdef DEBUG
-    WriteLog("Remove Rect %d from Seq.\n",i);
-  #endif
-
-  DPA_DeletePtr(me->DPA_LockedRects,i);
-
-  #ifdef DEBUG
-    WriteLog("Test if locked Rects main\n");
-  #endif
-
-  if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
+    rc = DDERR_INVALIDRECT;
+  }
+  else
   {
     #ifdef DEBUG
-      WriteLog("No Locked Rects left for surface\n");
+      WriteLog("Remove Rect %d from Seq.\n",i);
     #endif
-    me->fLocked = FALSE;
-  }
-  #ifdef DEBUG
-  else
-    WriteLog( "%d Rects in Seq\n",
-              DPA_GetPtrCount(me->DPA_LockedRects));
-  #endif
-
-  if(me->pFrameBuffer != me->pDiveBuffer)
-  {
+
+    DPA_DeletePtr(me->DPA_LockedRects,i);
+
     #ifdef DEBUG
-      WriteLog( "ColorConversion Needed %08X != %08X\n",
-                me->pFrameBuffer,
-                me->pDiveBuffer);
+      WriteLog("Test if locked Rects main\n");
     #endif
-    if(NULL!=lpSurfaceData)
-    {
-      CCRect.yTop    = pIRectEnum->Top();
-      CCRect.xLeft   = pIRectEnum->Left();
-      CCRect.xRight  = pIRectEnum->Right();
-      CCRect.yBottom = pIRectEnum->Bottom();
-
-      me->ColorConversion( (LPRECT)&CCRect);
-    }
+
+    if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
+    {
+      #ifdef DEBUG
+        WriteLog("No Locked Rects left for surface\n");
+      #endif
+      me->fLocked = FALSE;
+    }
+    #ifdef DEBUG
     else
-    {
-      me->ColorConversion(NULL);
-    }
-  }
-  #ifdef DEBUG
-  else
-    WriteLog( "No ColorConversion Needed");
-  #endif
-
-  // delete tne DDRectobject of the found rectangle
-  delete pIRectEnum;
-
-  me->lpVtbl->ChangeUniquenessValue(me);
-
-  WriteLog("Unlock OK\n\n");
-
-  return(DD_OK);
+      WriteLog( "%d Rects in Seq\n",
+                DPA_GetPtrCount(me->DPA_LockedRects));
+    #endif
+
+    if(me->pFrameBuffer != me->pDiveBuffer)
+    {
+      #ifdef DEBUG
+        WriteLog( "ColorConversion Needed %08X != %08X\n",
+                  me->pFrameBuffer,
+                  me->pDiveBuffer);
+      #endif
+      if(NULL!=lpSurfaceData)
+      {
+        CCRect.yTop    = pIRectEnum->Top();
+        CCRect.xLeft   = pIRectEnum->Left();
+        CCRect.xRight  = pIRectEnum->Right();
+        CCRect.yBottom = pIRectEnum->Bottom();
+
+        me->ColorConversion( (LPRECT)&CCRect);
+      }
+      else
+      {
+        me->ColorConversion(NULL);
+      }
+    }
+    #ifdef DEBUG
+    else
+      WriteLog( "No ColorConversion Needed");
+    #endif
+
+    // delete tne DDRectobject of the found rectangle
+    delete pIRectEnum;
+
+    me->lpVtbl->ChangeUniquenessValue(me);
+
+    WriteLog("Unlock OK\n\n");
+
+    rc = DD_OK;
+  }
+
+  ODIN_FS_END
+
+  return rc;
 }
 //******************************************************************************
@@ -4249 +4397 @@
   DDRectangle *pIRectUnlock, *pIRectEnum;
   BOOL Found = FALSE;
+  HRESULT rc;
 
   #ifdef DEBUG
@@ -4261 +4410 @@
     return(DDERR_NOTLOCKED);
   }
+
+  ODIN_FS_BEGIN
 
   if(NULL!=lpSurfaceRect)
@@ -4323 +4474 @@
     }
     else
-      return SurfUnlock(This, (LPVOID)lpSurfaceRect);
-  }
-
-  #ifdef DEBUG
-    WriteLog("Remove Rect from Seq.\n");
-  #endif
-
-  DPA_DeletePtr(me->DPA_LockedRects,i);
-
-  if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
+      rc = SurfUnlock(This, (LPVOID)lpSurfaceRect);
+  }
+  else
   {
     #ifdef DEBUG
-      WriteLog("No Locked Rects left for surface\n");
+      WriteLog("Remove Rect from Seq.\n");
     #endif
-    me->fLocked = FALSE;
-  }
-
-  if(me->pFrameBuffer != me->pDiveBuffer)
-  {
-    #ifdef DEBUG
-      WriteLog( "ColorConversion Needed %08X != %08X\n",
-                me->pFrameBuffer,
-                me->pDiveBuffer);
-    #endif
-    me->ColorConversion(lpSurfaceRect);
-  }
-
-  me->lpVtbl->ChangeUniquenessValue(me);
-
-  WriteLog("Unlock OK\n\n");
-
-  return(DD_OK);
+
+    DPA_DeletePtr(me->DPA_LockedRects,i);
+
+    if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
+    {
+      #ifdef DEBUG
+        WriteLog("No Locked Rects left for surface\n");
+      #endif
+      me->fLocked = FALSE;
+    }
+
+    if(me->pFrameBuffer != me->pDiveBuffer)
+    {
+      #ifdef DEBUG
+        WriteLog( "ColorConversion Needed %08X != %08X\n",
+                  me->pFrameBuffer,
+                  me->pDiveBuffer);
+      #endif
+      me->ColorConversion(lpSurfaceRect);
+    }
+
+    me->lpVtbl->ChangeUniquenessValue(me);
+
+    WriteLog("Unlock OK\n\n");
+    rc = DD_OK;
+  }
+
+  ODIN_FS_END
+
+  return rc;
 }
 //******************************************************************************
@@ -4455 +4611 @@
     return DDERR_INVALIDSURFACETYPE; // only work for system alloced surfaces
 
+  ODIN_FS_BEGIN
+
   if (!me->Updated)
   {
@@ -4465 +4623 @@
   memcpy((char *)&(me->DDSurfaceDesc), (char *)lpSurfDesc, sizeof(DDSURFACEDESC));
 
+  ODIN_FS_END
 
   return DD_OK;
@@ -4487 +4646 @@
     return DDERR_INVALIDSURFACETYPE; // only work for system alloced surfaces
 
+  ODIN_FS_BEGIN
+
   if (!me->Updated)
   {
@@ -4496 +4657 @@
   me->lpVtbl->ChangeUniquenessValue(me);
   memcpy((char *)&(me->DDSurfaceDesc), (char *)lpSurfDesc, sizeof(DDSURFACEDESC2));
+
+  ODIN_FS_END
 
   return DD_OK;
@@ -4511 +4674 @@
   void *pBuffer;
   BOOL bFound = FALSE;
+  HRESULT rc;
 
   #ifdef DEBUG
@@ -4522 +4686 @@
      (dwFlags & ~(DDSPD_IUNKNOWNPOINTER|DDSPD_VOLATILE)))
     return(DDERR_INVALIDPARAMS);
+
+  ODIN_FS_BEGIN
 
   // first check if the refGUID is stored as then the content will be updated
@@ -4567 +4733 @@
         {
           delete pSData;
-          return (DDERR_OUTOFMEMORY);
+          rc = DDERR_OUTOFMEMORY;
         }
       }
@@ -4600 +4766 @@
           }
           else
-            return(DDERR_OUTOFMEMORY);
+            rc = DDERR_OUTOFMEMORY;
         }
       }
@@ -4631 +4797 @@
           }
           else
-            return(DDERR_OUTOFMEMORY);
+            rc = DDERR_OUTOFMEMORY;
         }
       }
@@ -4662 +4828 @@
           pSData->dwFlags = dwFlags;
           pSData->isValid = TRUE;
+
+          if( DPA_InsertPtr( me->DPA_SurfacePrivateData,
+                             DPA_GetPtrCount(me->DPA_SurfacePrivateData),
+                             pSData) <0)
+          {
+            delete(pSData);
+            rc = DDERR_OUTOFMEMORY;
+          }
         }
         else
         {
-          delete pSData;
-          return (DDERR_OUTOFMEMORY);
+          delete(pSData);
+          rc = DDERR_OUTOFMEMORY;
         }
       }
 
-      if( DPA_InsertPtr( me->DPA_SurfacePrivateData,
-                         DPA_GetPtrCount(me->DPA_SurfacePrivateData),
-                         pSData) <0)
-      {
-        delete pSData;
-        return (DDERR_OUTOFMEMORY);
-      }
-
     }
     else
-      return (DDERR_OUTOFMEMORY);
-  }
-  return(DD_OK);
+      rc = DDERR_OUTOFMEMORY;
+  }
+
+  ODIN_FS_END
+
+  return rc;
 }
 //******************************************************************************
 //******************************************************************************
 HRESULT __stdcall SurfGetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData, LPDWORD lpDataSize)
+{
+  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
+  int i;
+  PSURFPRIVATEDATA pSData;
+  HRESULT rc;
+  BOOL bFound = FALSE;
+
+  #ifdef DEBUG
+    WriteLog("SurfGetPrivateData\n");
+  #endif
+
+  if(NULL==me)
+    return(DDERR_INVALIDOBJECT);
+
+  if((NULL==lpData)||(NULL==lpDataSize))
+    return(DDERR_INVALIDPARAMS);
+
+  ODIN_FS_BEGIN
+
+  if(DPA_GetPtrCount(me->DPA_SurfacePrivateData)>0)
+  {
+    i=0;
+    while(i<DPA_GetPtrCount(me->DPA_SurfacePrivateData) && !bFound)
+    {
+      pSData = (PSURFPRIVATEDATA) DPA_FastGetPtr(me->DPA_SurfacePrivateData,i);
+
+      if (IsEqualGUID(pSData->guidTag,refGUID))
+        bFound = TRUE;
+
+      i++;
+    }
+  }
+
+  if(bFound)
+  {
+    if(!pSData->isValid)
+    {
+      rc =DDERR_EXPIRED;
+    }
+    else
+    {
+      if(pSData->dwSize > *lpDataSize)
+      {
+        // Buffer to small return needed Size
+        *lpDataSize = pSData->dwSize;
+        rc = DDERR_MOREDATA;
+      }
+      else
+      {
+        memcpy(lpData,pSData->pData,pSData->dwSize);
+        rc = DD_OK;
+      }
+    }
+  }
+  else
+   rc = DDERR_NOTFOUND;
+
+  ODIN_FS_END
+
+  return rc;
+}
+//******************************************************************************
+//******************************************************************************
+HRESULT __stdcall SurfFreePrivateData(THIS This, REFGUID refGUID)
 {
   OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
@@ -4694 +4927 @@
 
   #ifdef DEBUG
-    WriteLog("SurfGetPrivateData\n");
+    WriteLog("SurfFreePrivateData\n");
   #endif
 
@@ -4700 +4933 @@
     return(DDERR_INVALIDOBJECT);
 
-  if((NULL==lpData)||(NULL==lpDataSize))
-    return(DDERR_INVALIDPARAMS);
-
-  if(DPA_GetPtrCount(me->DPA_SurfacePrivateData)>0)
-  {
-    i=0;
-    while(i<DPA_GetPtrCount(me->DPA_SurfacePrivateData) && !bFound)
-    {
-      pSData = (PSURFPRIVATEDATA) DPA_FastGetPtr(me->DPA_SurfacePrivateData,i);
-
-      if (IsEqualGUID(pSData->guidTag,refGUID))
-        bFound = TRUE;
-
-      i++;
-    }
-  }
-
-  if(bFound)
-  {
-    if(!pSData->isValid)
-      return(DDERR_EXPIRED);
-
-    if(pSData->dwSize > *lpDataSize)
-    {
-      // Buffer to small return needed Size
-      *lpDataSize = pSData->dwSize;
-      return(DDERR_MOREDATA);
-    }
-
-    memcpy(lpData,pSData->pData,pSData->dwSize);
-    return(DD_OK);
-  }
-
-  return (DDERR_NOTFOUND);
-}
-//******************************************************************************
-//******************************************************************************
-HRESULT __stdcall SurfFreePrivateData(THIS This, REFGUID refGUID)
-{
-  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
-  int i;
-  PSURFPRIVATEDATA pSData;
-  BOOL bFound = FALSE;
-
-  #ifdef DEBUG
-    WriteLog("SurfFreePrivateData\n");
-  #endif
-
-  if(NULL==me)
-    return(DDERR_INVALIDOBJECT);
+  ODIN_FS_BEGIN
 
   if(DPA_GetPtrCount(me->DPA_SurfacePrivateData)>0)
@@ -4782 +4966 @@
     }
   }
+
+  ODIN_FS_END
+
   return (bFound?DD_OK:DDERR_NOTFOUND);
 }
@@ -4806 +4993 @@
   PSURFPRIVATEDATA pSData;
 
+  ODIN_FS_BEGIN
+
   #ifdef DEBUG
     WriteLog("SurfChangeUniquenessValue\n");
@@ -4822 +5011 @@
         if (pSData->dwFlags & DDSPD_IUNKNOWNPOINTER)
         {
-          // pointer to com stored so calll its release
+          // pointer to com stored so call its release
           ((OS2IDirectDrawSurface *) pSData->pData)->lpVtbl->Release(pSData->pData);
         }
@@ -4837 +5026 @@
   }
 
+  ODIN_FS_END
+
   return (DD_OK);
 }
@@ -4848 +5039 @@
 void __cdecl MoveRects(char* pBuffer, LPRECT lpDestRect, LPRECT lpSrcRect, int bpp, LONG lPitch)
 {
+
   char *pBltPos, *pSrcPos;
   int BlitWidth,BlitHeight;
   static char Scanline[6400];  // sufficient for 1600 at 32 bit
+
+  ODIN_FS_BEGIN
+
   // Bridge, we may got a problem ;)
   // Check for Overlapping Rects
@@ -4912 +5107 @@
   }
 
+  ODIN_FS_END
 }
 

trunk/src/ddraw/OS2UTIL.CPP

@@ -1 @@
-/* $Id: OS2UTIL.CPP,v 1.3 1999-06-10 17:10:57 phaller Exp $ */
+/* $Id: OS2UTIL.CPP,v 1.4 1999-08-16 00:40:48 hugh Exp $ */
 
 /*
@@ -43 +43 @@
 void OS2MaximizeWindow(HWND hwndClient)
 {
+  ODIN_FS_BEGIN
   WinSetWindowPos(hwndClient, HWND_TOP, 0, 0, 0, 0, SWP_MAXIMIZE);
+  ODIN_FS_END
 }
 

trunk/src/ddraw/ddraw.CPP

@@ -2 +2 @@
 
 #include <builtin.h>
+#include <odincrt.h>
 #define INITGUID
 #include "os2ddraw.h"
@@ -18 +19 @@
   HRESULT         rc;
 
+  ODIN_FS_BEGIN
+
   WriteLog("DirectDrawCreate %X %X %X\n", lpGUID, lplpDD, pUnkOuter);
+
   newdraw = new OS2IDirectDraw(lpGUID);
 
   if(newdraw == NULL)
-    return(DDERR_NODIRECTDRAWHW);
-
-//  newdraw->Vtbl.AddRef((IDirectDraw *)newdraw);
-  rc = newdraw->GetLastError();
-  if(rc != DD_OK)
   {
-    *lplpDD = NULL;
-    delete newdraw;
+    rc = DDERR_NODIRECTDRAWHW;
   }
   else
-    *lplpDD = (LPDIRECTDRAW)newdraw;
+  {
+    //  newdraw->Vtbl.AddRef((IDirectDraw *)newdraw);
+    rc = newdraw->GetLastError();
+    if(rc != DD_OK)
+    {
+      *lplpDD = NULL;
+
+      delete newdraw;
+    }
+    else
+      *lplpDD = (LPDIRECTDRAW)newdraw;
+  }
+  ODIN_FS_END
 
   return(rc);
@@ -45 +55 @@
   //call it twice for the DirectDraw & Direct3D classes
  if(lpCallback(NULL, "DIVE DirectDraw for OS/2",
-                "DirectDraw/2 v0.1", lpContext) == DDENUMRET_CANCEL)
+                "DirectDraw/2 v0.2", lpContext) == DDENUMRET_CANCEL)
   {
     WriteLog("Cancel Callback\n");
@@ -54 +64 @@
     WriteLog("Callback for 3Dfx Voodoo");
     if(lpCallback((GUID *)&IID_IDirect3D, "3Dfx Voodoo Direct3D/2",
-      "Direct3D/2 v0.1", lpContext) == DDENUMRET_CANCEL)
+      "Direct3D/2 v0.2", lpContext) == DDENUMRET_CANCEL)
     {
       WriteLog("Cancel Callback\n");
@@ -64 +74 @@
   return(DD_OK);
 }
+
 //******************************************************************************
 typedef struct

trunk/src/ddraw/makefile

@@ -13 +13 @@
 ASFLAGS = -Sc -Sv:ALP
 
-CFLAGS = $(CFLAGS) -I$(PDWIN32_INCLUDE);
-CXXFLAGS = $(CXXFLAGS) -I$(PDWIN32_INCLUDE);
+CFLAGS = $(CFLAGS) /Gn+-I$(PDWIN32_INCLUDE);
+CXXFLAGS = $(CXXFLAGS) /Gn+ -I$(PDWIN32_INCLUDE);
 
 TARGET = ddraw
@@ -20 +20 @@
 OBJS =  ddraw.obj os2ddraw.obj os2clipper.obj os2d3d.obj iccio1.obj asmutil.obj\
         os2surface.obj os2palette.obj os2palset.obj misc.obj rectangle.obj initterm.obj
+        
 
 LIBS =  ..\..\lib\pmwinx.lib mmpm2.lib ..\..\lib\comctl32.lib $(PDWIN32_LIB)\advapi32.lib $(PDWIN32_LIB)\kernel32.lib $(PDWIN32_LIB)\gdi32.lib $(PDWIN32_LIB)\comctl32.lib $(PDWIN32_LIB)/odincrt.lib OS2386.LIB

trunk/src/ddraw/os2DDWindow.cpp

@@ -1 +1 @@
 #define INCL_WIN
 #include <os2wrap.h>
+#include <odincrt.h>
+#include <odinwrap.h>
 #include "os2DDWindow.h"
 
@@ -8 +10 @@
 extern VOID SwitchDisplay(HWND hwnd);
 
-BOOL OS2DdSubClassWindow(HWND hwndClient)
+ODINFUNCTION1(BOOL , OS2DdSubClassWindow ,HWND, hwndClient)
 {
   HWND hwndParent;
@@ -35 +37 @@
 {
   USHORT usFlags;
+
+  ODIN_FS_BEGIN
+
   switch(ulMsg)
   {
@@ -59 +64 @@
       break;
   }
+
+  ODIN_FS_END
+
   return pfnOrgClientProc(hwnd, ulMsg, mp1,mp2);
 }