main.c

Go to the documentation of this file.

#include <stdio.h>
#include "main.h"
 
 
// TODO:
//
// - free memory
// - Check if we ran out of memory (HeapAlloc == NULL)
  HDC hdc;
  DDRAWI_DIRECTDRAW_GBL mDDrawGlobal;
  DDRAWI_DIRECTDRAW_LCL mDDrawLocal;
  DDHALINFO mHALInfo;
 
  DDHAL_CALLBACKS mCallbacks;
  DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks;
  D3DHAL_CALLBACKS mD3dCallbacks;
  D3DHAL_GLOBALDRIVERDATA mD3dDriverData;
 
  UINT mcModeInfos;
  DDHALMODEINFO *mpModeInfos;
 
  UINT mcvmList;
  VIDMEM *mpvmList;
 
  UINT mcFourCC;
  DWORD *mpFourCC;
 
  UINT mcTextures;
  DDSURFACEDESC *mpTextures;
 
  /* Surface */
  DDRAWI_DDRAWSURFACE_GBL mPrimaryGlobal;
  DDRAWI_DDRAWSURFACE_MORE mPrimaryMore;
  DDRAWI_DDRAWSURFACE_LCL mPrimaryLocal;
  DDRAWI_DDRAWSURFACE_LCL *mpPrimaryLocals[1];
  DDRAWI_DDRAWCLIPPER_LCL mPrimaryClipperLocal;
  DDRAWI_DDRAWCLIPPER_GBL mPrimaryClipperGlobal;
  //DDRAWI_DDRAWCLIPPER_INT mPrimaryClipperInterface;
  DDSURFACEDESC mddsdPrimary;
  DDSURFACEDESC mddsdOverlay;
 
  DDRAWI_DDRAWSURFACE_GBL mOverlayGlobal;
  DDRAWI_DDRAWSURFACE_LCL mOverlayLocal[6];
  DDRAWI_DDRAWSURFACE_LCL *mpOverlayLocals[6];
  DDRAWI_DDRAWSURFACE_MORE mOverlayMore[6];
 
  DDHAL_BLTDATA                mDdBlt;
 
 
typedef struct _DD_GETDRIVERINFODATA {
  VOID  *dhpdev;
  DWORD  dwSize;
  DWORD  dwFlags;
  GUID  guidInfo;
  DWORD  dwExpectedSize;
  PVOID  lpvData;
  DWORD  dwActualSize;
  HRESULT  ddRVal;
  ULONG_PTR  dwContext;
} DD_GETDRIVERINFODATA, *PDD_GETDRIVERINFODATA;
 
 
typedef struct _DD_MISCELLANEOUSCALLBACKS {
  DWORD  dwSize;
  DWORD  dwFlags;
  PVOID  GetAvailDriverMemory;
} DD_MISCELLANEOUSCALLBACKS;
 
 
int WINAPI WinMain (HINSTANCE hInst, HINSTANCE hPrevInst,
                    LPSTR lpCmdLine, int nCmdShow)
{
    /* HAL Startup process */
    DEVMODE devmode;
    HBITMAP hbmp;
    const UINT bmiSize = sizeof(BITMAPINFOHEADER) + 0x10;
    UCHAR *pbmiData;
    BITMAPINFO *pbmi;
 
    DWORD *pMasks;
    //BOOL newmode = FALSE;
    //DWORD Status; /* for create surface */
    UINT i;
    UINT j;
    UINT cSurfaces;
 
    DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface;
    DDHAL_UPDATEOVERLAYDATA mDdUpdateOverlay;
    DDRAWI_DDRAWSURFACE_LCL *pDDSurface;
    DDHAL_CREATESURFACEDATA mDdCreateSurface;
 
 
    /* get the functions we need */
//  DD_GETDRIVERINFODATA drv;
    HMODULE lib = LoadLibrary("gdi32.dll");
    DdCreateDirectDrawObject = (BOOL (APIENTRY*)(LPDDRAWI_DIRECTDRAW_GBL,   HDC))GetProcAddress(lib, "GdiEntry1");
    DdQueryDirectDrawObject  = (BOOL (APIENTRY*)(LPDDRAWI_DIRECTDRAW_GBL,   LPDDHALINFO,LPDDHAL_DDCALLBACKS,LPDDHAL_DDSURFACECALLBACKS,LPDDHAL_DDPALETTECALLBACKS,LPD3DHAL_CALLBACKS,LPD3DHAL_GLOBALDRIVERDATA,LPDDHAL_DDEXEBUFCALLBACKS,LPDDSURFACEDESC,LPDWORD,LPVIDMEM))GetProcAddress(lib, "GdiEntry2");
    DdAttachSurface          = (BOOL (APIENTRY*)(LPDDRAWI_DDRAWSURFACE_LCL, LPDDRAWI_DDRAWSURFACE_LCL))GetProcAddress(lib, "GdiEntry11");
    DdResetVisrgn            = (BOOL (APIENTRY*)(LPDDRAWI_DDRAWSURFACE_LCL, HWND))GetProcAddress(lib, "GdiEntry6");
 
    printf("This app shows how to start up a DirectDraw/Direct3D interface and some others.\n");
    printf("This code has been released to some closed applications with my permission. If any company\n");
    printf("wants to use this code, you must contact the original author to ask for permission.\n");
    printf("This code is released under many different licenses.\n");
    printf("All GPL and LGPL projects have the right to use and study this code.\n");
    printf("This code may require more comments to know how stuff works.\n");
    printf("Best regards, Magnus Olsen magnus@greatlord.com or greatlord@reactos.org\n");
    printf("Copyright 2006 by Magnus Olsen\n\n");
    printf("This demo shows how to start DirectDraw, creating a primary surface\n");
    printf("and an overlay surface, and a blt to the primary surface.\n");
 
 
    /*
       Get and Create mode info
    */
    mcModeInfos = 1;
    mpModeInfos = (DDHALMODEINFO*)HeapAlloc(GetProcessHeap(),
                                                  HEAP_ZERO_MEMORY,
                                                  mcModeInfos * sizeof(DDHALMODEINFO));
 
    if (mpModeInfos == NULL)
    {
       printf("Fail to alloc mpModeInfos\n");
       return DD_FALSE;
    }
 
 
    EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);
 
    mpModeInfos[0].dwWidth      = devmode.dmPelsWidth;
    mpModeInfos[0].dwHeight     = devmode.dmPelsHeight;
    mpModeInfos[0].dwBPP        = devmode.dmBitsPerPel;
    mpModeInfos[0].lPitch       = (devmode.dmPelsWidth*devmode.dmBitsPerPel)/8;
    mpModeInfos[0].wRefreshRate = (WORD)devmode.dmDisplayFrequency;
 
    /*
       Setup HDC and mDDrawGlobal right
    */
    hdc = CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL);
 
    if (hdc == NULL)
    {
      printf("Fail to create HDC\n");
      return DD_FALSE;
    }
 
    /*
      Dectect RGB bit mask
    */
    hbmp = CreateCompatibleBitmap(hdc, 1, 1);
    if (hbmp==NULL)
    {
       HeapFree(GetProcessHeap(), 0, mpModeInfos);
       DeleteDC(hdc);
       printf("Fail to Create Compatible Bitmap\n");
       return DD_FALSE;
    }
 
    pbmiData = (UCHAR *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bmiSize);
    pbmi = (BITMAPINFO*)pbmiData;
 
    if (pbmiData==NULL)
    {
       HeapFree(GetProcessHeap(), 0, mpModeInfos);
       free(mpModeInfos);
       DeleteDC(hdc);
       DeleteObject(hbmp);
       printf("Fail to Alloc  pbmiData\n");
       return DDERR_UNSUPPORTED;
    }
 
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    pbmi->bmiHeader.biBitCount = (WORD)devmode.dmBitsPerPel;
    pbmi->bmiHeader.biCompression = BI_BITFIELDS;
    pbmi->bmiHeader.biWidth = 1;
    pbmi->bmiHeader.biHeight = 1;
 
    GetDIBits(hdc, hbmp, 0, 0, NULL, pbmi, 0);
    DeleteObject(hbmp);
 
    pMasks = (DWORD*)(pbmiData + sizeof(BITMAPINFOHEADER));
    mpModeInfos[0].dwRBitMask = pMasks[0];
    mpModeInfos[0].dwGBitMask = pMasks[1];
    mpModeInfos[0].dwBBitMask = pMasks[2];
    mpModeInfos[0].dwAlphaBitMask = pMasks[3];
 
    HeapFree(GetProcessHeap(), 0, pbmiData);
 
    /*
      prepare start up the DX Draw HAL interface now
    */
 
    memset(&mDDrawGlobal, 0, sizeof(DDRAWI_DIRECTDRAW_GBL));
    memset(&mHALInfo,     0, sizeof(DDHALINFO));
    memset(&mCallbacks,   0, sizeof(DDHAL_CALLBACKS));
 
    /*
      Startup DX HAL step one of three
    */
    if (!DdCreateDirectDrawObject(&mDDrawGlobal, hdc))
    {
       HeapFree(GetProcessHeap(), 0, mpModeInfos);
       DeleteDC(hdc);
       DeleteObject(hbmp);
       printf("Fail to Create Direct DrawObject\n");
       return DD_FALSE;
    }
 
    mDDrawGlobal.dwRefCnt = 1; //addref / remove ref
 
    // Do not release HDC, it has been mapped in kernel mode
    // DeleteDC(hdc);
 
    /* we need to reenable it if the screen resolution has changed, and some
       bad driver needs to be reenabled infrequently to continue */
    /*
    if (!DdReenableDirectDrawObject(&mDDrawGlobal, &newmode))
    {
      HeapFree(GetProcessHeap(), 0, mpModeInfos);
      DeleteDC(hdc);
      DeleteObject(hbmp);
      return DD_FALSE;
    }*/
 
    /*
      Setup the DirectDraw Local
    */
 
    mDDrawLocal.lpDDCB = &mCallbacks;
    mDDrawLocal.lpGbl = &mDDrawGlobal;
    mDDrawLocal.dwProcessId = GetCurrentProcessId();
 
    mDDrawGlobal.lpDDCBtmp = &mCallbacks;
    mDDrawGlobal.lpExclusiveOwner = &mDDrawLocal;
    //mDDrawLocal.dwLocalFlags = DDRAWILCL_DIRECTDRAW7;
 
 
    /*
       Startup DX HAL step two of three
    */
 
    if (!DdQueryDirectDrawObject(&mDDrawGlobal,
                                 &mHALInfo,
                                 &mCallbacks.HALDD,
                                 &mCallbacks.HALDDSurface,
                                 &mCallbacks.HALDDPalette,
                                 &mD3dCallbacks,
                                 &mD3dDriverData,
                                 &mD3dBufferCallbacks,
                                 NULL,
                                 NULL,
                                 NULL))
    {
      HeapFree(GetProcessHeap(), 0, mpModeInfos);
      DeleteDC(hdc);
      DeleteObject(hbmp);
      // FIXME Close DX first call and second call
      return DD_FALSE;
    }
 
    mcvmList = mHALInfo.vmiData.dwNumHeaps;
    mpvmList = (VIDMEM*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VIDMEM) * mcvmList);
    if (mpvmList == NULL)
    {
      HeapFree(GetProcessHeap(), 0, mpModeInfos);
      DeleteDC(hdc);
      DeleteObject(hbmp);
      // FIXME Close DX first call and second call
      printf("Fail to QueryDirect Draw Object first pass\n");
      return DD_FALSE;
    }
 
    mcFourCC = mHALInfo.ddCaps.dwNumFourCCCodes;
    mpFourCC = (DWORD *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DWORD) * mcFourCC);
    if (mpFourCC == NULL)
    {
      HeapFree(GetProcessHeap(), 0, mpvmList);
      HeapFree(GetProcessHeap(), 0, mpModeInfos);
      DeleteDC(hdc);
      DeleteObject(hbmp);
      // FIXME Close DX fristcall and second call
      return DD_FALSE;
    }
 
    mcTextures = mD3dDriverData.dwNumTextureFormats;
    mpTextures = (DDSURFACEDESC*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DDSURFACEDESC) * mcTextures);
    if (mpTextures == NULL)
    {
      HeapFree(GetProcessHeap(), 0, mpFourCC);
      HeapFree(GetProcessHeap(), 0, mpvmList);
      HeapFree(GetProcessHeap(), 0, mpModeInfos);
      DeleteDC(hdc);
      DeleteObject(hbmp);
      // FIXME Close DX first call and second call
      printf("Fail QueryDirect Draw Object to Alloc mpTextures \n");
      return DD_FALSE;
    }
 
    mHALInfo.vmiData.pvmList = mpvmList;
    mHALInfo.lpdwFourCC = mpFourCC;
    mD3dDriverData.lpTextureFormats = mpTextures;
 
    if (!DdQueryDirectDrawObject(
                                    &mDDrawGlobal,
                                    &mHALInfo,
                                    &mCallbacks.HALDD,
                                    &mCallbacks.HALDDSurface,
                                    &mCallbacks.HALDDPalette,
                                    &mD3dCallbacks,
                                    &mD3dDriverData,
                                    &mCallbacks.HALDDExeBuf,
                                    mpTextures,
                                    mpFourCC,
                                    mpvmList))
 
    {
      HeapFree(GetProcessHeap(), 0, mpTextures);
      HeapFree(GetProcessHeap(), 0, mpFourCC);
      HeapFree(GetProcessHeap(), 0, mpvmList);
      HeapFree(GetProcessHeap(), 0, mpModeInfos);
      DeleteDC(hdc);
      DeleteObject(hbmp);
      printf("Fail to QueryDirect Draw Object second pass\n");
      return DD_FALSE;
    }
 
   /*
      Copy over from HalInfo to DirectDrawGlobal
   */
 
  // this is wrong, cDriverName needs to be in ASCII not UNICODE
  //memcpy(mDDrawGlobal.cDriverName, mDisplayAdapter, sizeof(wchar)*MAX_DRIVER_NAME);
 
  memcpy(&mDDrawGlobal.vmiData, &mHALInfo.vmiData,sizeof(VIDMEMINFO));
  memcpy(&mDDrawGlobal.ddCaps,  &mHALInfo.ddCaps,sizeof(DDCORECAPS));
 
  mHALInfo.dwNumModes = mcModeInfos;
  mHALInfo.lpModeInfo = mpModeInfos;
  mHALInfo.dwMonitorFrequency = mpModeInfos[0].wRefreshRate;
 
  mDDrawGlobal.dwMonitorFrequency = mHALInfo.dwMonitorFrequency;
  mDDrawGlobal.dwModeIndex        = mHALInfo.dwModeIndex;
  mDDrawGlobal.dwNumModes         = mHALInfo.dwNumModes;
  mDDrawGlobal.lpModeInfo         = mHALInfo.lpModeInfo;
  mDDrawGlobal.hInstance          = mHALInfo.hInstance;
 
  mDDrawGlobal.lp16DD = &mDDrawGlobal;
 
 
 
  /* Hal insate is down now */
 
  /* clear surface code now */
 
  //  memset(&mGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL));
  //  memset(&mMore,   0, sizeof(DDRAWI_DDRAWSURFACE_MORE));
 
   /* mLocal.lpSurfMore = &mMore;
   memset(mMore, 0, sizeof(DDRAWI_DDRAWSURFACE_MORE));
   mMore.dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);*/
 
   mPrimaryLocal.lpSurfMore = &mPrimaryMore;
 
  /* clear surface ends now */
 
  /* create primary surface now */
 
   memset(&mddsdPrimary,   0, sizeof(DDSURFACEDESC));
   mddsdPrimary.dwSize      = sizeof(DDSURFACEDESC);
   mddsdPrimary.dwFlags     = DDSD_CAPS;
   mddsdPrimary.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE;
 
   mDdCanCreateSurface.lpDD = &mDDrawGlobal;
   mDdCanCreateSurface.CanCreateSurface = mCallbacks.HALDD.CanCreateSurface;
   mDdCanCreateSurface.bIsDifferentPixelFormat = FALSE; //isDifferentPixelFormat;
   mDdCanCreateSurface.lpDDSurfaceDesc = &mddsdPrimary; // pDDSD;
 
   if (mHALInfo.lpDDCallbacks->CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED)
   {
     printf("Fail to mDdCanCreateSurface DDHAL_DRIVER_NOTHANDLED\n");
     return DDERR_NOTINITIALIZED;
   }
 
   if (mDdCanCreateSurface.ddRVal != DD_OK)
   {
       printf("Fail to mDdCanCreateSurface mDdCanCreateSurface.ddRVal = %d:%s\n",(int)mDdCanCreateSurface.ddRVal,DDErrorString(mDdCanCreateSurface.ddRVal));
       return DDERR_NOTINITIALIZED;
   }
 
  memset(&mPrimaryGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL));
  mPrimaryGlobal.dwGlobalFlags = DDRAWISURFGBL_ISGDISURFACE;
  mPrimaryGlobal.lpDD       = &mDDrawGlobal;
  mPrimaryGlobal.lpDDHandle = &mDDrawGlobal;
  mPrimaryGlobal.wWidth  = (WORD)mpModeInfos[0].dwWidth;
  mPrimaryGlobal.wHeight = (WORD)mpModeInfos[0].dwHeight;
  mPrimaryGlobal.lPitch  = mpModeInfos[0].lPitch;
 
  memset(&mPrimaryMore,   0, sizeof(DDRAWI_DDRAWSURFACE_MORE));
  mPrimaryMore.dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
 
 
  //mPrimaryMore. = mpr
 
  memset(&mPrimaryLocal,  0, sizeof(DDRAWI_DDRAWSURFACE_LCL));
  mPrimaryLocal.lpGbl = &mPrimaryGlobal;
  mPrimaryLocal.lpSurfMore = &mPrimaryMore;
  mPrimaryLocal.dwProcessId = GetCurrentProcessId();
  mPrimaryLocal.dwFlags = DDRAWISURF_PARTOFPRIMARYCHAIN|DDRAWISURF_HASOVERLAYDATA;
  mPrimaryLocal.ddsCaps.dwCaps = mddsdPrimary.ddsCaps.dwCaps;
 
  mpPrimaryLocals[0] = &mPrimaryLocal;
 
  mDdCreateSurface.lpDD = &mDDrawGlobal;
  mDdCreateSurface.CreateSurface = mCallbacks.HALDD.CreateSurface;
  mDdCreateSurface.lpDDSurfaceDesc = &mddsdPrimary;//pDDSD;
  mDdCreateSurface.lplpSList = mpPrimaryLocals; //cSurfaces;
  mDdCreateSurface.dwSCnt = 1 ;  //ppSurfaces;
 
  if (mHALInfo.lpDDCallbacks->CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED)
  {
    printf("Fail to mDdCreateSurface  DDHAL_DRIVER_NOTHANDLED \n");
    return DDERR_NOTINITIALIZED;
  }
 
 
  if (mDdCreateSurface.ddRVal != DD_OK)
  {
    printf("Fail to mDdCanCreateSurface mDdCreateSurface.ddRVal = %d:%s\n",(int)mDdCreateSurface.ddRVal,DDErrorString(mDdCreateSurface.ddRVal));
    return mDdCreateSurface.ddRVal;
  }
 
  // -- Setup Clipper ---------------------------------------------------------
  memset(&mPrimaryClipperGlobal, 0, sizeof(DDRAWI_DDRAWCLIPPER_GBL));
  mPrimaryClipperGlobal.dwFlags = DDRAWICLIP_ISINITIALIZED;
  mPrimaryClipperGlobal.dwProcessId = GetCurrentProcessId();
  //mPrimaryClipperGlobal.hWnd = (ULONG_PTR)hwnd;
  mPrimaryClipperGlobal.hWnd = (ULONG_PTR)GetDesktopWindow();
  mPrimaryClipperGlobal.lpDD = &mDDrawGlobal;
  mPrimaryClipperGlobal.lpStaticClipList = NULL;
 
  memset(&mPrimaryClipperLocal, 0, sizeof(DDRAWI_DDRAWCLIPPER_LCL));
  mPrimaryClipperLocal.lpGbl = &mPrimaryClipperGlobal;
 
  //memset(&mPrimaryClipperInterface, 0, sizeof(DDRAWI_DDRAWCLIPPER_INT));
  //mPrimaryClipperInterface.lpLcl = &mPrimaryClipperLocal;
  //mPrimaryClipperInterface.dwIntRefCnt = 1;
  //mPrimaryClipperInterface.lpLink = null;
  //mPrimaryClipperInterface.lpVtbl = null;
 
  mPrimaryLocal.lpDDClipper = &mPrimaryClipperLocal;
  //mPrimaryMore.lpDDIClipper = &mPrimaryClipperInterface;
 
  mDdBlt.lpDDDestSurface = mpPrimaryLocals[0];
 
 
  /* create primary surface is down now */
 
  /* create overlay surface now */
 
  memset(&mddsdOverlay, 0, sizeof(DDSURFACEDESC));
  mddsdOverlay.dwSize = sizeof(DDSURFACEDESC);
  mddsdOverlay.dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_BACKBUFFERCOUNT | DDSD_WIDTH | DDSD_HEIGHT;
 
  mddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
 
  mddsdOverlay.dwWidth = 100;  //pels;
  mddsdOverlay.dwHeight = 100; // lines;
  mddsdOverlay.dwBackBufferCount = 1; //cBuffers;
 
  mddsdOverlay.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  mddsdOverlay.ddpfPixelFormat.dwFlags = DDPF_RGB;
  mddsdOverlay.ddpfPixelFormat.dwRGBBitCount = 32;
 
 
   //DDHAL_CANCREATESURFACEDATA   mDdCanCreateSurface;
   mDdCanCreateSurface.lpDD = &mDDrawGlobal;
   mDdCanCreateSurface.CanCreateSurface = mCallbacks.HALDD.CanCreateSurface;
   mDdCanCreateSurface.bIsDifferentPixelFormat = TRUE; //isDifferentPixelFormat;
   mDdCanCreateSurface.lpDDSurfaceDesc = &mddsdOverlay; // pDDSD;
 
 
   if (mHALInfo.lpDDCallbacks->CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED)
   {
    // derr(L"DirectDrawImpl[%08x]::__createPrimary Cannot create primary [%08x]", this, rv);
 
     printf("Fail to mDdCanCreateSurface DDHAL_DRIVER_NOTHANDLED \n");
    return DDERR_NOTINITIALIZED;
   }
 
   if (mDdCanCreateSurface.ddRVal != DD_OK)
   {
     printf("Fail to mDdCanCreateSurface mDdCanCreateSurface.ddRVal = %d:%s\n",(int)mDdCanCreateSurface.ddRVal,DDErrorString(mDdCanCreateSurface.ddRVal));
     return DDERR_NOTINITIALIZED;
   }
 
 
  memset(&mOverlayGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL));
  mOverlayGlobal.dwGlobalFlags = 0;
  mOverlayGlobal.lpDD       = &mDDrawGlobal;
  mOverlayGlobal.lpDDHandle = &mDDrawGlobal;
  mOverlayGlobal.wWidth  = (WORD)mddsdOverlay.dwWidth;
  mOverlayGlobal.wHeight = (WORD)mddsdOverlay.dwHeight;
  mOverlayGlobal.lPitch  = -1;
  mOverlayGlobal.ddpfSurface = mddsdOverlay.ddpfPixelFormat;
 
  // setup front- and backbuffer surfaces
  cSurfaces = mddsdOverlay.dwBackBufferCount + 1;
  for ( i = 0; i < cSurfaces; i++)
  {
     memset(&mOverlayMore[i], 0, sizeof(DDRAWI_DDRAWSURFACE_MORE));
     mOverlayMore[i].dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
 
     memset(&mOverlayLocal[i],  0, sizeof(DDRAWI_DDRAWSURFACE_LCL));
    mOverlayLocal[i].lpGbl = &mOverlayGlobal;
    mOverlayLocal[i].lpSurfMore = &mOverlayMore[i];
    mOverlayLocal[i].dwProcessId = GetCurrentProcessId();
    mOverlayLocal[i].dwFlags = (i == 0) ?
      (DDRAWISURF_IMPLICITROOT|DDRAWISURF_FRONTBUFFER):
      (DDRAWISURF_IMPLICITCREATE|DDRAWISURF_BACKBUFFER);
 
    mOverlayLocal[i].dwFlags |=
      DDRAWISURF_ATTACHED|DDRAWISURF_ATTACHED_FROM|
      DDRAWISURF_HASPIXELFORMAT|
      DDRAWISURF_HASOVERLAYDATA;
 
    mOverlayLocal[i].ddsCaps.dwCaps = mddsdOverlay.ddsCaps.dwCaps;
    mpOverlayLocals[i] = &mOverlayLocal[i];
  }
 
  for ( i = 0; i < cSurfaces; i++)
  {
    j = (i + 1) % cSurfaces;
 
 
    /*if (!mHALInfo.lpDDSurfaceCallbacks->AddAttachedSurface(mpOverlayLocals[i], mpOverlayLocals[j]))
    {
     // derr(L"DirectDrawImpl[%08x]::__setupDevice DdAttachSurface(%d, %d) failed", this, i, j);
      return DD_FALSE;
    }*/
 
    if (!DdAttachSurface(mpOverlayLocals[i], mpOverlayLocals[j]))
    {
     // derr(L"DirectDrawImpl[%08x]::__setupDevice DdAttachSurface(%d, %d) failed", this, i, j);
        printf("Fail to DdAttachSurface (%d:%d)\n", i, j);
      return DD_FALSE;
    }
 
  }
 
 
  // DDHAL_CREATESURFACEDATA      mDdCreateSurface;
  mDdCreateSurface.lpDD = &mDDrawGlobal;
  mDdCreateSurface.CreateSurface = mCallbacks.HALDD.CreateSurface;
  mDdCreateSurface.lpDDSurfaceDesc = &mddsdOverlay;//pDDSD;
  mDdCreateSurface.lplpSList = mpOverlayLocals; //cSurfaces;
  mDdCreateSurface.dwSCnt = 1 ;  //ppSurfaces;
 
 if (mHALInfo.lpDDCallbacks->CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED)
  {
    printf("Fail to mDdCreateSurface = DDHAL_DRIVER_HANDLED\n");
    return DDERR_NOTINITIALIZED;
  }
 
 
  if (mDdCreateSurface.ddRVal != DD_OK)
  {
     printf("Fail to mDdCreateSurface mDdCreateSurface.ddRVal = %d:%s\n",(int)mDdCreateSurface.ddRVal,DDErrorString(mDdCreateSurface.ddRVal));
     return mDdCreateSurface.ddRVal;
  }
 
 
  mDdUpdateOverlay.lpDD = &mDDrawGlobal;
  mDdUpdateOverlay.UpdateOverlay = mCallbacks.HALDDSurface.UpdateOverlay;
  mDdUpdateOverlay.lpDDDestSurface = mpPrimaryLocals[0];
  mDdUpdateOverlay.lpDDSrcSurface = mpOverlayLocals[0];//pDDSurface;
  mDdUpdateOverlay.dwFlags = DDOVER_SHOW;
 
 /* if (flags & DDOVER_DDFX)
    mDdUpdateOverlay.overlayFX = *pFx;
  copyRect(&mDdUpdateOverlay.rDest, pdst);
  copyRect(&mDdUpdateOverlay.rSrc, psrc);
*/
 
  mDdUpdateOverlay.rDest.top = 0;
  mDdUpdateOverlay.rDest.left = 0;
  mDdUpdateOverlay.rDest.right = 50;
  mDdUpdateOverlay.rDest.bottom = 50;
 
   mDdUpdateOverlay.rSrc.top = 0;
  mDdUpdateOverlay.rSrc.left = 0;
  mDdUpdateOverlay.rSrc.right = 50;
  mDdUpdateOverlay.rSrc.bottom = 50;
 
 
 
 
  if ( mDdUpdateOverlay.UpdateOverlay(&mDdUpdateOverlay) == DDHAL_DRIVER_NOTHANDLED)
  {
     printf("Fail to mDdBlt = DDHAL_DRIVER_HANDLED\n");
     return DDERR_NOTINITIALIZED;
  }
 
 
  if (mDdUpdateOverlay.ddRVal != DD_OK)
  {
      printf("Fail to mDdUpdateOverlay mDdUpdateOverlay.ddRVal = %d:%s\n",(int)mDdUpdateOverlay.ddRVal,DDErrorString(mDdUpdateOverlay.ddRVal));
      return mDdUpdateOverlay.ddRVal;
  }
 
  /* blt */
 
 
  pDDSurface = mpPrimaryLocals[0];
 
  if (!DdResetVisrgn(pDDSurface, NULL))
  {
   // derr(L"DirectDrawImpl[%08x]::_clear DdResetVisrgn failed", this);
  }
 
 
  memset(&mDdBlt, 0, sizeof(DDHAL_BLTDATA));
  memset(&mDdBlt.bltFX, 0, sizeof(DDBLTFX));
  mDdBlt.bltFX.dwSize = sizeof(DDBLTFX);
 
  mDdBlt.lpDD = &mDDrawGlobal;
  mDdBlt.Blt = mCallbacks.HALDDSurface.Blt;
  mDdBlt.lpDDDestSurface = mpPrimaryLocals[0];
 
  mpPrimaryLocals[0]->hDC = (ULONG_PTR)GetDC(GetDesktopWindow());
  mDdBlt.rDest.top = 50;
  mDdBlt.rDest.bottom = 100;
  mDdBlt.rDest.left = 0;
  mDdBlt.rDest.right = 100;
  mDdBlt.lpDDSrcSurface = NULL;
  mDdBlt.IsClipped = FALSE;
  mDdBlt.bltFX.dwFillColor = 0xFFFF00;
  mDdBlt.dwFlags = DDBLT_COLORFILL | DDBLT_WAIT;
 // mDdBlt.IsClipped = TRUE;
 
    if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
    {
      printf("Fail to mDdBlt = DDHAL_DRIVER_HANDLED\n");
      return DDHAL_DRIVER_HANDLED;
    }
 
 
 
    if (mDdBlt.ddRVal!=DD_OK)
    {
        printf("Fail to mDdBlt mDdBlt.ddRVal = %d:%s\n",(int)mDdBlt.ddRVal,DDErrorString(mDdBlt.ddRVal));
        return mDdBlt.ddRVal;
    }
 
  mDdUpdateOverlay.rDest.right = 100;
   if ( mDdUpdateOverlay.UpdateOverlay(&mDdUpdateOverlay) == DDHAL_DRIVER_NOTHANDLED)
  {
    printf("Fail to mDdUpdateOverlay = DDERR_NOTINITIALIZED\n");
    return DDERR_NOTINITIALIZED;
  }
 
  while(TRUE);
 
  return DD_OK;
 
 
}