#define _WIN32_WINNT 0x0600 #define WIN32_LEAN_AND_MEAN #define _CRT_SECURE_NO_DEPRECATE 1 // comment defines to get rid of some proxy logs.... #define TRACECOMMETHODS YES #define HOOKDDRAW YES #define HOOKCLIPPER YES #define HOOKSURFACE YES #define HOOKPALETTE YES #include #include #include #include "dxwnd.h" #include "dxwcore.hpp" #include "dxhook.h" #include "syslibs.h" #include "dxhelper.h" #include "hddraw.h" #include "hddproxy.h" static void HookDDSessionProxy(LPDIRECTDRAW *, int); static void HookDDSurfaceProxy(LPDIRECTDRAWSURFACE *, int); static void HookDDClipperProxy(LPDIRECTDRAWCLIPPER FAR*); static void HookDDPaletteProxy(LPDIRECTDRAWPALETTE FAR*); extern FARPROC WINAPI extGetProcAddress(HMODULE, LPCSTR); // DirectDraw APIs extern DirectDrawCreate_Type pDirectDrawCreate; extern DirectDrawCreateEx_Type pDirectDrawCreateEx; extern DirectDrawEnumerate_Type pDirectDrawEnumerate; extern DirectDrawEnumerateEx_Type pDirectDrawEnumerateEx; // DIrectDraw object // COM object extern QueryInterface_Type pQueryInterfaceD; extern AddRefD_Type pAddRefD; extern ReleaseD_Type pReleaseD; // v1 interface extern Compact_Type pCompact; extern CreateClipper_Type pCreateClipper; extern CreatePalette_Type pCreatePalette; extern CreateSurface1_Type pCreateSurface1; extern CreateSurface1_Type pCreateSurface2; extern CreateSurface1_Type pCreateSurface3; extern CreateSurface2_Type pCreateSurface4; extern CreateSurface2_Type pCreateSurface7; extern DuplicateSurface_Type pDuplicateSurface; extern EnumDisplayModes1_Type pEnumDisplayModes1; extern EnumDisplayModes4_Type pEnumDisplayModes4; extern EnumSurfaces1_Type pEnumSurfaces1; extern EnumSurfaces4_Type pEnumSurfaces4; extern FlipToGDISurface_Type pFlipToGDISurface; extern GetCapsD_Type pGetCapsD; extern GetDisplayMode_Type pGetDisplayMode; extern GetFourCCCodes_Type pGetFourCCCodes; extern GetGDISurface_Type pGetGDISurface; extern GetMonitorFrequency_Type pGetMonitorFrequency; extern GetScanLine_Type pGetScanLine; extern GetVerticalBlankStatus_Type pGetVerticalBlankStatus; // missing Initialize ... extern RestoreDisplayMode_Type pRestoreDisplayMode; extern SetCooperativeLevel_Type pSetCooperativeLevel; extern SetDisplayMode1_Type pSetDisplayMode1; extern SetDisplayMode2_Type pSetDisplayMode2; // missing WaitForVerticalBlank ... // v2 interface extern GetAvailableVidMem_Type pGetAvailableVidMem; // v4 interface extern GetSurfaceFromDC_Type pGetSurfaceFromDC; extern RestoreAllSurfaces_Type pRestoreAllSurfaces; // v7 interface extern TestCooperativeLevel_Type pTestCooperativeLevel; extern GetDeviceIdentifier_Type pGetDeviceIdentifier; // DIrectDrawSurface object // COM object extern QueryInterface_Type pQueryInterfaceS; extern AddRefS_Type pAddRefS; extern ReleaseS_Type pReleaseS; // v1 interface extern AddAttachedSurface_Type pAddAttachedSurface; extern AddOverlayDirtyRect_Type pAddOverlayDirtyRect; extern Blt_Type pBlt; extern BltBatch_Type pBltBatch; extern BltFast_Type pBltFast; extern DeleteAttachedSurface_Type pDeleteAttachedSurface; extern EnumAttachedSurfaces_Type pEnumAttachedSurfaces; extern EnumOverlayZOrders_Type pEnumOverlayZOrders; extern Flip_Type pFlip; extern GetAttachedSurface_Type pGetAttachedSurface1; extern GetAttachedSurface_Type pGetAttachedSurface3; extern GetAttachedSurface_Type pGetAttachedSurface4; extern GetAttachedSurface_Type pGetAttachedSurface7; extern GetBltStatus_Type pGetBltStatus; extern GetCapsS_Type pGetCaps1S; extern GetCapsS_Type pGetCaps2S; extern GetCapsS_Type pGetCaps3S; extern GetCaps2S_Type pGetCaps4S; extern GetCaps2S_Type pGetCaps7S; extern GetClipper_Type pGetClipper; extern GetColorKey_Type pGetColorKey; extern GetDC_Type pGetDC; extern GetFlipStatus_Type pGetFlipStatus; extern GetOverlayPosition_Type pGetOverlayPosition; extern GetPalette_Type pGetPalette; extern GetPixelFormat_Type pGetPixelFormat; extern GetSurfaceDesc_Type pGetSurfaceDesc1; extern GetSurfaceDesc2_Type pGetSurfaceDesc4; // missing Initialize ... extern IsLost_Type pIsLost; extern Lock_Type pLock; extern ReleaseDC_Type pReleaseDC; extern Restore_Type pRestore; extern SetClipper_Type pSetClipper; extern SetColorKey_Type pSetColorKey; extern SetOverlayPosition_Type pSetOverlayPosition; extern SetPalette_Type pSetPalette; extern Unlock1_Type pUnlock1; extern Unlock4_Type pUnlock4; extern UpdateOverlay_Type pUpdateOverlay; extern UpdateOverlayDisplay_Type pUpdateOverlayDisplay; extern UpdateOverlayZOrder_Type pUpdateOverlayZOrder; // v2 interface // missing GetDDInterface // missing PageLock // missing PageUnlock // v3 interface // missing SetSurfaceDesc // v4 interface // missing SetPrivateData // missing GetPrivateData // missing FreePrivateData // missing GetUniquenessValue // missing ChangeUniquenessValue // Texture7 methods // missing SetPriority // missing GetPriority // missing SetLOD // missing GetLOD // DIrectDrawClipper object // COM object extern QueryInterface_Type pQueryInterfaceC; extern AddRefC_Type pAddRefC; extern ReleaseC_Type pReleaseC; // v1 interface extern GetClipList_Type pGetClipList; extern GetHWnd_Type pGetHWnd; extern InitializeC_Type pInitializeC; extern IsClipListChanged_Type pIsClipListChanged; extern SetClipList_Type pSetClipList; extern SetHWnd_Type pSetHWnd; // DIrectDrawPalette object // COM object extern QueryInterface_Type pQueryInterfaceP; extern AddRefP_Type pAddRefP; extern ReleaseP_Type pReleaseP; // v1 interface extern GetCapsP_Type pGetCapsP; extern GetEntries_Type pGetEntries; // missing Initialize ... extern SetEntries_Type pSetEntries; extern GDIGetDC_Type pGDIGetDC; extern GDIGetDC_Type pGDIGetWindowDC; extern GDIReleaseDC_Type pGDIReleaseDC; extern CreateDC_Type pGDICreateDC; extern CreateCompatibleDC_Type pGDICreateCompatibleDC; extern BitBlt_Type pGDIBitBlt; extern PatBlt_Type pGDIPatBlt; extern StretchBlt_Type pGDIStretchBlt; extern DeleteDC_Type pGDIDeleteDC; SaveDC_Type pSaveDC; RestoreDC_Type pRestoreDC; extern BeginPaint_Type pBeginPaint; HDC WINAPI extGDIGetDCProxy(HWND); HDC WINAPI extGetWindowDCProxy(HWND); int WINAPI extGDIReleaseDCProxy(HWND, HDC); HDC WINAPI extCreateDCProxy(LPSTR, LPSTR, LPSTR, CONST DEVMODE *); HDC WINAPI extCreateCompatibleDCProxy(HDC); BOOL WINAPI extBitBltProxy(HDC, int, int, int, int, HDC, int, int, DWORD); BOOL WINAPI extPatBltProxy(HDC, int, int, int, int, DWORD); BOOL WINAPI extStretchBltProxy(HDC, int, int, int, int, HDC, int, int, int, int, DWORD); BOOL WINAPI extDeleteDCProxy(HDC); int WINAPI extSaveDCProxy(HDC); BOOL WINAPI extRestoreDCProxy(HDC, int); HPALETTE WINAPI extSelectPaletteProxy(HDC, HPALETTE, BOOL); UINT WINAPI extRealizePaletteProxy(HDC); HDC WINAPI extBeginPaintProxy(HWND, LPPAINTSTRUCT); UINT WINAPI extGetSystemPaletteEntriesProxy(HDC, UINT, UINT, LPPALETTEENTRY); // ------------------------------------------------------------------------------------------ // // // auxiliary calls // // ------------------------------------------------------------------------------------------ // static void DumpSurfaceAttributesProxy(LPDDSURFACEDESC lpddsd, char *label) { OutTraceP("%s: Flags=%x(%s)", label, lpddsd->dwFlags, ExplainFlags(lpddsd->dwFlags)); if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) OutTraceP(" BackBufferCount=%d", lpddsd->dwBackBufferCount); if (lpddsd->dwFlags & DDSD_WIDTH) OutTraceP(" Width=%d", lpddsd->dwWidth); if (lpddsd->dwFlags & DDSD_HEIGHT) OutTraceP(" Height=%d", lpddsd->dwHeight); if (lpddsd->dwFlags & DDSD_CAPS) OutTraceP(" Caps=%x(%s)", lpddsd->ddsCaps.dwCaps, ExplainDDSCaps(lpddsd->ddsCaps.dwCaps)); if (lpddsd->dwFlags & DDSD_CKDESTBLT ) OutTraceP(" CKDestBlt=(%x,%x)", lpddsd->ddckCKDestBlt.dwColorSpaceLowValue, lpddsd->ddckCKDestBlt.dwColorSpaceHighValue); if (lpddsd->dwFlags & DDSD_CKDESTOVERLAY ) OutTraceP(" CKDestOverlay=(%x,%x)", lpddsd->ddckCKDestOverlay.dwColorSpaceLowValue, lpddsd->ddckCKDestOverlay.dwColorSpaceHighValue); if (lpddsd->dwFlags & DDSD_CKSRCBLT ) OutTraceP(" CKSrcBlt=(%x,%x)", lpddsd->ddckCKSrcBlt.dwColorSpaceLowValue, lpddsd->ddckCKSrcBlt.dwColorSpaceHighValue); if (lpddsd->dwFlags & DDSD_CKSRCOVERLAY ) OutTraceP(" CKSrcOverlay=(%x,%x)", lpddsd->ddckCKSrcOverlay.dwColorSpaceLowValue, lpddsd->ddckCKSrcOverlay.dwColorSpaceHighValue); if (lpddsd->dwFlags & DDSD_PIXELFORMAT ) OutTraceP(" PixelFormat BPP=%d RGBA=(%x,%x,%x,%x)", lpddsd->ddpfPixelFormat.dwRGBBitCount, lpddsd->ddpfPixelFormat.dwRBitMask, lpddsd->ddpfPixelFormat.dwGBitMask, lpddsd->ddpfPixelFormat.dwBBitMask, lpddsd->ddpfPixelFormat.dwRGBAlphaBitMask); OutTraceP("\n"); } // ------------------------------------------------------------------------------------------ // // // DirectDraw API hooking functions // // ------------------------------------------------------------------------------------------ // FARPROC WINAPI extGetProcAddressProxy(HMODULE hModule, LPCSTR proc) { FARPROC ret; // WARNING: seems to be called with bad LPCSTR value.... __try { OutTraceP("GetProcAddress: PROXED hModule=%x proc=%s\n", hModule, proc); // should check for both hModule from ddraw.dll & apiname, but.... if(proc){ if (!strcmp(proc,"DirectDrawCreate")){ pDirectDrawCreate=(DirectDrawCreate_Type)(*pGetProcAddress)(hModule, proc); OutTraceP("GetProcAddress: hooking proc=%s at addr=%x\n", proc, pDirectDrawCreate); return (FARPROC)extDirectDrawCreateProxy; } if (!strcmp(proc,"DirectDrawCreateEx")){ pDirectDrawCreateEx=(DirectDrawCreateEx_Type)(*pGetProcAddress)(hModule, proc); OutTraceP("GetProcAddress: hooking proc=%s at addr=%x\n", proc, pDirectDrawCreateEx); return (FARPROC)extDirectDrawCreateExProxy; } if (!strcmp(proc,"DirectDrawEnumerateA")){ pDirectDrawEnumerate=(DirectDrawEnumerate_Type)(*pGetProcAddress)(hModule, proc); OutTraceP("GetProcAddress: hooking proc=%s at addr=%x\n", proc, pDirectDrawEnumerate); return (FARPROC)extDirectDrawEnumerateProxy; } if (!strcmp(proc,"DirectDrawEnumerateExA")){ pDirectDrawEnumerateEx=(DirectDrawEnumerateEx_Type)(*pGetProcAddress)(hModule, proc); OutTraceP("GetProcAddress: hooking proc=%s at addr=%x\n", proc, pDirectDrawEnumerateEx); return (FARPROC)extDirectDrawEnumerateExProxy; } } } __except(EXCEPTION_EXECUTE_HANDLER) { OutTraceP("GetProcAddress: EXCEPTION\n"); } ret=(*pGetProcAddress)(hModule, proc); OutTraceP("GetProcAddress: ret=%x\n", ret); return ret; } // ------------------------------------------------------------------------------------------ // // // COM methods hooking functions // // ------------------------------------------------------------------------------------------ // int HookDDProxy(HMODULE module, int dxVersion) { HINSTANCE hinst; void *tmp; const GUID dd7 = {0x15e65ec0,0x3b9c,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b}; // LPDIRECTDRAW lpdd; // BOOL res; dxw.dwFlags1 |= OUTDDRAWTRACE; pGDICreateCompatibleDC=CreateCompatibleDC; pGDIGetDC=GetDC; pGDIGetWindowDC=GetWindowDC; pGDIReleaseDC=ReleaseDC; pGDICreateDC=CreateDC; pGDIBitBlt=BitBlt; pGDIPatBlt=PatBlt; pGDIStretchBlt=StretchBlt; pGDIDeleteDC=DeleteDC; pSaveDC=SaveDC; pRestoreDC=RestoreDC; pGDISelectPalette=SelectPalette; tmp = HookAPI(module, "GDI32.dll", CreateCompatibleDC, "CreateCompatibleDC", extCreateCompatibleDCProxy); if(tmp) pGDICreateCompatibleDC = (CreateCompatibleDC_Type)tmp; tmp = HookAPI(module, "user32.dll", GetDC, "GetDC", extGDIGetDCProxy); if(tmp) pGDIGetDC = (GDIGetDC_Type)tmp; tmp = HookAPI(module, "user32.dll", GetWindowDC, "GetWindowDC", extGetWindowDCProxy); if(tmp) pGDIGetWindowDC = (GDIGetDC_Type)tmp; tmp = HookAPI(module, "user32.dll", ReleaseDC, "ReleaseDC", extGDIReleaseDCProxy); if(tmp) pGDIReleaseDC = (GDIReleaseDC_Type)tmp; tmp = HookAPI(module, "GDI32.dll", CreateDCA, "CreateDCA", extCreateDCProxy); if(tmp) pGDICreateDC = (CreateDC_Type)tmp; tmp = HookAPI(module, "GDI32.dll", BitBlt, "BitBlt", extBitBltProxy); if(tmp) pGDIBitBlt = (BitBlt_Type)tmp; tmp = HookAPI(module, "GDI32.dll", StretchBlt, "StretchBlt", extStretchBltProxy); if(tmp) pGDIStretchBlt = (StretchBlt_Type)tmp; tmp = HookAPI(module, "GDI32.dll", PatBlt, "PatBlt", extPatBltProxy); if(tmp) pGDIPatBlt = (PatBlt_Type)tmp; tmp = HookAPI(module, "GDI32.dll", DeleteDC, "DeleteDC", extDeleteDCProxy); if(tmp) pGDIDeleteDC = (DeleteDC_Type)tmp; tmp = HookAPI(module, "GDI32.dll", SaveDC, "SaveDC", extSaveDCProxy); if(tmp) pGDISaveDC = (SaveDC_Type)tmp; tmp = HookAPI(module, "GDI32.dll", RestoreDC, "RestoreDC", extRestoreDCProxy); if(tmp) pGDIRestoreDC = (RestoreDC_Type)tmp; tmp = HookAPI(module, "GDI32.dll", SelectPalette, "SelectPalette", extSelectPaletteProxy); if(tmp) pGDISelectPalette = (SelectPalette_Type)tmp; tmp = HookAPI(module, "GDI32.dll", RealizePalette, "RealizePalette", extRealizePaletteProxy); if(tmp) pGDIRealizePalette = (RealizePalette_Type)tmp; tmp = HookAPI(module, "GDI32.dll", GetSystemPaletteEntries, "GetSystemPaletteEntries", extGetSystemPaletteEntriesProxy); if(tmp) pGDIGetSystemPaletteEntries = (GetSystemPaletteEntries_Type)tmp; tmp = HookAPI(module, "user32.dll", BeginPaint, "BeginPaint", extBeginPaintProxy); if(tmp) pBeginPaint = (BeginPaint_Type)tmp; pGetProcAddress = (GetProcAddress_Type)GetProcAddress; tmp = HookAPI(module, "KERNEL32.dll", GetProcAddress, "GetProcAddress", extGetProcAddressProxy); if(tmp) pGetProcAddress = (GetProcAddress_Type)tmp; switch(dxVersion){ case 0: // automatic tmp = HookAPI(module, "ddraw.dll", NULL, "DirectDrawCreate", extDirectDrawCreateProxy); if(tmp) pDirectDrawCreate = (DirectDrawCreate_Type)tmp; tmp = HookAPI(module, "ddraw.dll", NULL, "DirectDrawCreateEx", extDirectDrawCreateExProxy); if(tmp) pDirectDrawCreateEx = (DirectDrawCreateEx_Type)tmp; tmp = HookAPI(module, "ddraw.dll", NULL, "DirectDrawEnumerateA", extDirectDrawEnumerateProxy); if(tmp) pDirectDrawEnumerate = (DirectDrawEnumerate_Type)tmp; tmp = HookAPI(module, "ddraw.dll", NULL, "DirectDrawEnumerateExA", extDirectDrawEnumerateExProxy); if(tmp) pDirectDrawEnumerateEx = (DirectDrawEnumerateEx_Type)tmp; break; case 1: case 2: case 3: case 5: case 6: hinst = LoadLibrary("ddraw.dll"); pDirectDrawEnumerate = (DirectDrawEnumerate_Type)GetProcAddress(hinst, "DirectDrawEnumerateA"); pDirectDrawCreate = (DirectDrawCreate_Type)GetProcAddress(hinst, "DirectDrawCreate"); if(pDirectDrawCreate){ LPDIRECTDRAW lpdd; BOOL res; HookAPI(module, "ddraw.dll", pDirectDrawCreate, "DirectDrawCreate", extDirectDrawCreateProxy); HookAPI(module, "ddraw.dll", pDirectDrawEnumerate, "DirectDrawEnumerateA", extDirectDrawEnumerateProxy); res=extDirectDrawCreateProxy(0, &lpdd, 0); if (res){ OutTraceP("DirectDrawCreate: ERROR res=%x(%s)\n", res, ExplainDDError(res)); } lpdd->Release(); } break; case 7: hinst = LoadLibrary("ddraw.dll"); pDirectDrawEnumerate = (DirectDrawEnumerate_Type)GetProcAddress(hinst, "DirectDrawEnumerateA"); pDirectDrawEnumerateEx = (DirectDrawEnumerateEx_Type)GetProcAddress(hinst, "DirectDrawEnumerateExA"); pDirectDrawCreate = (DirectDrawCreate_Type)GetProcAddress(hinst, "DirectDrawCreate"); if(pDirectDrawCreate){ LPDIRECTDRAW lpdd; BOOL res; HookAPI(module, "ddraw.dll", pDirectDrawCreate, "DirectDrawCreate", extDirectDrawCreateProxy); HookAPI(module, "ddraw.dll", pDirectDrawEnumerate, "DirectDrawEnumerateA", extDirectDrawEnumerateProxy); HookAPI(module, "ddraw.dll", pDirectDrawEnumerateEx, "DirectDrawEnumerateExA", extDirectDrawEnumerateExProxy); res=extDirectDrawCreateProxy(0, &lpdd, 0); if (res){ OutTraceP("DirectDrawCreate: ERROR res=%x(%s)\n", res, ExplainDDError(res)); } lpdd->Release(); } pDirectDrawCreateEx = (DirectDrawCreateEx_Type)GetProcAddress(hinst, "DirectDrawCreateEx"); if(pDirectDrawCreateEx){ LPDIRECTDRAW lpdd; BOOL res; HookAPI(module, "ddraw.dll", pDirectDrawCreateEx, "DirectDrawCreateEx", extDirectDrawCreateExProxy); res=extDirectDrawCreateExProxy(0, &lpdd, dd7, 0); if (res) OutTraceP("DirectDrawCreateEx: ERROR res=%x(%s)\n", res, ExplainDDError(res)); lpdd->Release(); } break; } if(pDirectDrawCreate || pDirectDrawCreateEx) return 1; return 0; } static void HookDDClipperProxy(LPDIRECTDRAWCLIPPER FAR* lplpDDClipper) { // IDirectDrawClipper::QueryInterface SetHook((void *)(**(DWORD **)lplpDDClipper + 0), extQueryInterfaceCProxy, (void **)&pQueryInterfaceC, "QueryInterface(C)"); #ifdef TRACECOMMETHODS // IDirectDrawClipper::AddRef SetHook((void *)(**(DWORD **)lplpDDClipper + 4), extAddRefCProxy, (void **)&pAddRefC, "AddRef(C)"); // IDirectDrawClipper::Release SetHook((void *)(**(DWORD **)lplpDDClipper + 8), extReleaseCProxy, (void **)&pReleaseC, "Release(C)"); #endif // IDirectDrawClipper::GetClipList SetHook((void *)(**(DWORD **)lplpDDClipper + 12), extGetClipListProxy, (void **)&pGetClipList, "GetClipList(C)"); // IDirectDrawClipper::GetHWnd SetHook((void *)(**(DWORD **)lplpDDClipper + 16), extGetHWndProxy, (void **)&pGetHWnd, "GetHWnd(C)"); // IDirectDrawClipper::Initialize SetHook((void *)(**(DWORD **)lplpDDClipper + 20), extInitializeCProxy, (void **)&pInitializeC, "Initialize(C)"); // IDirectDrawClipper::IsClipListChanged SetHook((void *)(**(DWORD **)lplpDDClipper + 24), extIsClipListChangedProxy, (void **)&pIsClipListChanged, "IsClipListChanged(C)"); // IDirectDrawClipper::SetClipList SetHook((void *)(**(DWORD **)lplpDDClipper + 28), extSetClipListProxy, (void **)&pSetClipList, "SetClipList(C)"); // IDirectDrawClipper::SetHWnd SetHook((void *)(**(DWORD **)lplpDDClipper + 32), extSetHWndProxy, (void **)&pSetHWnd, "SetHWnd(C)"); return; } static void HookDDPaletteProxy(LPDIRECTDRAWPALETTE FAR* lplpDDPalette) { // IDirectDrawPalette::QueryInterface SetHook((void *)(**(DWORD **)lplpDDPalette + 0), extQueryInterfacePProxy, (void **)&pQueryInterfaceP, "QueryInterface(P)"); #ifdef TRACECOMMETHODS // IDirectDrawPalette::AddRef SetHook((void *)(**(DWORD **)lplpDDPalette + 4), extAddRefPProxy, (void **)&pAddRefP, "AddRef(P)"); // IDirectDrawPalette::Release SetHook((void *)(**(DWORD **)lplpDDPalette + 8), extReleasePProxy, (void **)&pReleaseP, "Release(P)"); #endif // IDirectDrawPalette::GetCaps SetHook((void *)(**(DWORD **)lplpDDPalette + 12), extGetCapsPProxy, (void **)&pGetCapsP, "GetCaps(P)"); // IDirectDrawPalette::GetEntries SetHook((void *)(**(DWORD **)lplpDDPalette + 16), extGetEntriesProxy, (void **)&pGetEntries, "GetEntries(P)"); // IDirectDrawPalette::SetEntries SetHook((void *)(**(DWORD **)lplpDDPalette + 24), extSetEntriesProxy, (void **)&pSetEntries, "SetEntries(P)"); return; } static void HookDDSurfaceProxy(LPDIRECTDRAWSURFACE *lplpdds, int dxVersion) { OutTraceP("Hooking surface dds=%x version=%d thread_id=%x\n", *lplpdds, dxVersion, GetCurrentThreadId()); // IDirectDrawSurface::Query SetHook((void *)(**(DWORD **)lplpdds + 0), extQueryInterfaceSProxy, (void **)&pQueryInterfaceS, "QueryInterface(S)"); #ifdef TRACECOMMETHODS // IDirectDrawSurface::AddRef SetHook((void *)(**(DWORD **)lplpdds + 4), extAddRefSProxy, (void **)&pAddRefS, "AddRef(S)"); // IDirectDrawSurface::Release SetHook((void *)(**(DWORD **)lplpdds + 8), extReleaseSProxy, (void **)&pReleaseS, "Release(S)"); #endif // IDirectDrawSurface::AddAttachedSurface SetHook((void *)(**(DWORD **)lplpdds + 12), extAddAttachedSurfaceProxy, (void **)&pAddAttachedSurface, "AddAttachedSurface(S)"); // IDirectDrawSurface::AddOverlayDirtyRect SetHook((void *)(**(DWORD **)lplpdds + 16), extAddOverlayDirtyRectProxy, (void **)&pAddOverlayDirtyRect, "AddOverlayDirtyRect(S)"); // IDirectDrawSurface::Blt SetHook((void *)(**(DWORD **)lplpdds + 20), extBltProxy, (void **)&pBlt, "Blt(S)"); // IDirectDrawSurface::BltBatch SetHook((void *)(**(DWORD **)lplpdds + 24), extBltBatchProxy, (void **)&pBltBatch, "BltBatch(S)"); // IDirectDrawSurface::BltFast SetHook((void *)(**(DWORD **)lplpdds + 28), extBltFastProxy, (void **)&pBltFast, "BltFast(S)"); // IDirectDrawSurface::DeleteAttachedSurface SetHook((void *)(**(DWORD **)lplpdds + 32), extDeleteAttachedSurfaceProxy, (void **)&pDeleteAttachedSurface, "DeleteAttachedSurface(S)"); // IDirectDrawSurface::EnumAttachedSurfaces SetHook((void *)(**(DWORD **)lplpdds + 36), extEnumAttachedSurfacesProxy, (void **)&pEnumAttachedSurfaces, "EnumAttachedSurfaces(S)"); // IDirectDrawSurface::EnumOverlayZOrders SetHook((void *)(**(DWORD **)lplpdds + 40), extEnumOverlayZOrdersProxy, (void **)&pEnumOverlayZOrders, "EnumOverlayZOrders(S)"); // IDirectDrawSurface::Flip SetHook((void *)(**(DWORD **)lplpdds + 44), extFlipProxy, (void **)&pFlip, "Flip(S)"); // IDirectDrawSurface::GetAttachedSurface switch(dxVersion) { case 1: case 2: SetHook((void *)(**(DWORD **)lplpdds + 48), extGetAttachedSurface1Proxy, (void **)&pGetAttachedSurface1, "GetAttachedSurface(S1)"); break; case 3: SetHook((void *)(**(DWORD **)lplpdds + 48), extGetAttachedSurface3Proxy, (void **)&pGetAttachedSurface3, "GetAttachedSurface(S3)"); break; case 4: SetHook((void *)(**(DWORD **)lplpdds + 48), extGetAttachedSurface4Proxy, (void **)&pGetAttachedSurface4, "GetAttachedSurface(S4)"); break; case 7: SetHook((void *)(**(DWORD **)lplpdds + 48), extGetAttachedSurface7Proxy, (void **)&pGetAttachedSurface7, "GetAttachedSurface(S7)"); break; } // IDirectDrawSurface::GetBltStatus SetHook((void *)(**(DWORD **)lplpdds + 52), extGetBltStatusProxy, (void **)&pGetBltStatus, "GetBltStatus(S)"); // IDirectDrawSurface::GetCaps switch(dxVersion) { case 1: SetHook((void *)(**(DWORD **)lplpdds + 56), extGetCaps1SProxy, (void **)&pGetCaps1S, "GetCaps(S1)"); break; case 2: SetHook((void *)(**(DWORD **)lplpdds + 56), extGetCaps2SProxy, (void **)&pGetCaps2S, "GetCaps(S2)"); break; case 3: SetHook((void *)(**(DWORD **)lplpdds + 56), extGetCaps3SProxy, (void **)&pGetCaps3S, "GetCaps(S3)"); break; case 4: SetHook((void *)(**(DWORD **)lplpdds + 56), extGetCaps4SProxy, (void **)&pGetCaps4S, "GetCaps(S4)"); break; case 7: SetHook((void *)(**(DWORD **)lplpdds + 56), extGetCaps7SProxy, (void **)&pGetCaps7S, "GetCaps(S7)"); break; } // IDirectDrawSurface::GetClipper SetHook((void *)(**(DWORD **)lplpdds + 60), extGetClipperProxy, (void **)&pGetClipper, "GetClipper(S)"); // IDirectDrawSurface::GetColorKey SetHook((void *)(**(DWORD **)lplpdds + 64), extGetColorKeyProxy, (void **)&pGetColorKey, "GetColorKey(S)"); // IDirectDrawSurface::GetDC SetHook((void *)(**(DWORD **)lplpdds + 68), extGetDCProxy, (void **)&pGetDC, "GetDC(S)"); // IDirectDrawSurface::GetFlipStatus SetHook((void *)(**(DWORD **)lplpdds + 72), extGetFlipStatusProxy, (void **)&pGetFlipStatus, "GetFlipStatus(S)"); // IDirectDrawSurface::GetOverlayPosition SetHook((void *)(**(DWORD **)lplpdds + 76), extGetOverlayPositionProxy, (void **)&pGetOverlayPosition, "GetOverlayPosition(S)"); // IDirectDrawSurface::GetPalette SetHook((void *)(**(DWORD **)lplpdds + 80), extGetPaletteProxy, (void **)&pGetPalette, "GetPalette(S)"); // IDirectDrawSurface::GetPixelFormat SetHook((void *)(**(DWORD **)lplpdds + 84), extGetPixelFormatProxy, (void **)&pGetPixelFormat, "GetPixelFormat(S)"); // IDirectDrawSurface::GetSurfaceDesc switch(dxVersion){ case 1: case 2: case 3: SetHook((void *)(**(DWORD **)lplpdds + 88), extGetSurfaceDesc1Proxy, (void **)&pGetSurfaceDesc1, "pGetSurfaceDesc(S1)"); break; case 4: case 7: SetHook((void *)(**(DWORD **)lplpdds + 88), extGetSurfaceDesc4Proxy, (void **)&pGetSurfaceDesc4, "pGetSurfaceDesc(S4)"); break; } // IDirectDrawSurface::IsLost SetHook((void *)(**(DWORD **)lplpdds + 96), extIsLostProxy, (void **)&pIsLost, "IsLost(S)"); // IDirectDrawSurface::Lock SetHook((void *)(**(DWORD **)lplpdds + 100), extLockProxy, (void **)&pLock, "Lock(S)"); // IDirectDrawSurface::ReleaseDC SetHook((void *)(**(DWORD **)lplpdds + 104), extReleaseDCProxy, (void **)&pReleaseDC, "ReleaseDC(S)"); // IDirectDrawSurface::Restore SetHook((void *)(**(DWORD **)lplpdds + 108), extRestoreProxy, (void **)&pRestore, "Restore(S)"); // IDirectDrawSurface::SetClipper SetHook((void *)(**(DWORD **)lplpdds + 112), extSetClipperProxy, (void **)&pSetClipper, "SetClipper(S)"); // IDirectDrawSurface::SetColorKey SetHook((void *)(**(DWORD **)lplpdds + 116), extSetColorKeyProxy, (void **)&pSetColorKey, "SetColorKey(S)"); // IDirectDrawSurface::SetOverlayPosition SetHook((void *)(**(DWORD **)lplpdds + 120), extSetOverlayPositionProxy, (void **)&pSetOverlayPosition, "SetOverlayPosition(S)"); // IDirectDrawSurface::SetPalette SetHook((void *)(**(DWORD **)lplpdds + 124), extSetPaletteProxy, (void **)&pSetPalette, "SetPalette(S)"); // IDirectDrawSurface::Unlock if (dxVersion >= 4) SetHook((void *)(**(DWORD **)lplpdds + 128), extUnlock4Proxy, (void **)&pUnlock4, "Unlock(S4)"); else SetHook((void *)(**(DWORD **)lplpdds + 128), extUnlock1Proxy, (void **)&pUnlock1, "Unlock(S1)"); // IDirectDrawSurface::UpdateOverlay SetHook((void *)(**(DWORD **)lplpdds + 132), extUpdateOverlayProxy, (void **)&pUpdateOverlay, "UpdateOverlay(S)"); // IDirectDrawSurface::UpdateOverlayDisplay SetHook((void *)(**(DWORD **)lplpdds + 136), extUpdateOverlayDisplayProxy, (void **)&pUpdateOverlayDisplay, "UpdateOverlayDisplay(S)"); // IDirectDrawSurface::UpdateOverlayZOrder SetHook((void *)(**(DWORD **)lplpdds + 140), extUpdateOverlayZOrderProxy, (void **)&pUpdateOverlayZOrder, "UpdateOverlayZOrder(S)"); #if 0 /*** Added in the v2 interface ***/ if (dxVersion >= 2) { // missing GetDDInterface)(THIS_ LPVOID FAR *) PURE; // missing PageLock)(THIS_ DWORD) PURE; // missing PageUnlock)(THIS_ DWORD) PURE; } /*** Added in the v3 interface ***/ if (dxVersion >= 3) { // missing SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE; } /*** Added in the v4 interface ***/ if (dxVersion >= 4) { // missing SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE; // missing GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE; // missing FreePrivateData)(THIS_ REFGUID) PURE; // missing GetUniquenessValue)(THIS_ LPDWORD) PURE; // missing ChangeUniquenessValue)(THIS) PURE; } /*** Moved Texture7 methods here ***/ if (dxVersion >= 7) { // missing SetPriority)(THIS_ DWORD) PURE; // missing GetPriority)(THIS_ LPDWORD) PURE; // missing SetLOD)(THIS_ DWORD) PURE; // missing GetLOD)(THIS_ LPDWORD) PURE; } #endif } // ------------------------------------------------------------------------------------------ // // // DirectDraw proxed methods // // ------------------------------------------------------------------------------------------ // HRESULT WINAPI extQueryInterfaceDProxy(void *lpdd, REFIID riid, LPVOID *obp) { HRESULT res; unsigned int dxVersion; OutTraceP("QueryInterface(D): PROXED lpdd=%x REFIID=%x(%s)\n", lpdd, riid.Data1, ExplainGUID((GUID *)&riid.Data1)); res = (*pQueryInterfaceD)(lpdd, riid, obp); if(res) { OutTraceP("QueryInterface(D): ret=%x(%s)\n", res, ExplainDDError(res)); return res; } dxVersion=0; switch(riid.Data1){ case 0x6C14DB80: //DirectDraw1 dxVersion = 1; break; case 0xB3A6F3E0: //DirectDraw2 dxVersion = 2; break; case 0x9c59509a: //DirectDraw4 dxVersion = 4; break; case 0x15e65ec0: //DirectDraw7 dxVersion = 7; break; } if (! *obp) { OutTraceP("QueryInterface(D): Interface for DX version %d not found\n", dxVersion); return(0); } OutTraceP("QueryInterface(D): obp=%x interface=%d\n", *obp, dxVersion); switch (dxVersion){ case 1: case 2: case 4: case 7: #ifdef HOOKDDRAW HookDDSessionProxy((LPDIRECTDRAW *)obp, dxVersion); #endif break; } return res; } ULONG WINAPI extAddRefDProxy(LPDIRECTDRAW lpdd) { ULONG ref; ref=(*pAddRefD)(lpdd); OutTraceP("AddRef(D): PROXED lpdd=%x ref=%x\n", lpdd, ref); return ref; } ULONG WINAPI extReleaseDProxy(LPDIRECTDRAW lpdd) { ULONG ref; ref=(*pReleaseD)(lpdd); OutTraceP("Release(D): PROXED lpdd=%x ref=%x\n", lpdd, ref); return ref; } HRESULT WINAPI extCreateClipperProxy(LPDIRECTDRAW lpdd, DWORD dwflags, LPDIRECTDRAWCLIPPER FAR* lplpDDClipper, IUnknown FAR* pUnkOuter) { HRESULT res; OutTraceP("CreateClipper(D): PROXED lpdd=%x flags=%x\n", lpdd, dwflags); res=(*pCreateClipper)(lpdd, dwflags, lplpDDClipper, pUnkOuter); if(res) { OutTraceP("CreateClipper(D): ERROR res=%x(%s)\n", lpdd, res, ExplainDDError(res)); return res; } else OutTraceP("CreateClipper(D): lpddc=%x\n", *lplpDDClipper); #ifdef HOOKCLIPPER HookDDClipperProxy(lplpDDClipper); #endif return res; } HRESULT WINAPI extCreatePaletteProxy(LPDIRECTDRAW lpdd, DWORD dwflags, LPPALETTEENTRY lpddpa, LPDIRECTDRAWPALETTE *lplpddp, IUnknown *pu) { HRESULT res; OutTraceP("CreatePalette(D): PROXED lpdd=%x dwFlags=%x(%s)\n", lpdd, dwflags, ExplainCreatePaletteFlags(dwflags)); res = (*pCreatePalette)(lpdd, dwflags, lpddpa, lplpddp, pu); if (res) { OutTraceP("CreatePalette(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } else OutTraceP("CreatePalette(D): lpddp=%x\n", *lplpddp); #ifdef HOOKPALETTE HookDDPaletteProxy(lplpddp); #endif return res; } HRESULT WINAPI extGetCapsDProxy(LPDIRECTDRAW lpdd, LPDDCAPS c1, LPDDCAPS c2) { HRESULT res; OutTraceP("GetCaps(D): PROXED lpdd=%x c1=%x c2=%x\n", lpdd, c1, c2); res=(*pGetCapsD)(lpdd, c1, c2); if(res) OutTraceP("GetCaps(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else { // to do: a full Caps dump! OutTraceP("GetCaps(D): "); if (c1) OutTraceP("hwcaps size=%x ", c1->dwSize); if (c2) OutTraceP("swcaps size=%x ", c2->dwSize); OutTraceP("\n"); } return res; } HRESULT WINAPI extGetSurfaceFromDCProxy(LPDIRECTDRAW lpdd, HDC hdc, LPDIRECTDRAWSURFACE* lpDDS) { HRESULT res; OutTraceP("GetSurfaceFromDC(D): PROXED lpdd=%x hdc=%x\n", lpdd, hdc); res=(*pGetSurfaceFromDC)(lpdd, hdc, lpDDS); if(res) OutTraceP("GetSurfaceFromDC(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetSurfaceFromDC(D): lpDDS=%x(%s)\n", res, *lpDDS); return res; } HRESULT WINAPI extGetMonitorFrequencyProxy(LPDIRECTDRAW lpdd, LPDWORD lpdwFrequency) { HRESULT res; OutTraceP("GetMonitorFrequency(D): PROXED lpdd=%x freq=%d\n", lpdd, *lpdwFrequency); res=(*pGetMonitorFrequency)(lpdd, lpdwFrequency); if(res) OutTraceP("GetMonitorFrequency(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetScanLineProxy(LPDIRECTDRAW lpdd, LPDWORD lpdwScanLine) { HRESULT res; res=(*pGetScanLine)(lpdd, lpdwScanLine); OutTraceP("GetScanLine(D): PROXED lpdd=%x line=%x\n", lpdd, *lpdwScanLine); return res; } HRESULT WINAPI extGetVerticalBlankStatusProxy(LPDIRECTDRAW lpdd, LPBOOL lpbIsInVB) { HRESULT res; OutTraceP("GetVerticalBlankStatus(D): PROXED lpdd=%x\n", lpdd); res=(*pGetVerticalBlankStatus)(lpdd, lpbIsInVB); if (res) OutTraceP("GetVerticalBlankStatus(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetVerticalBlankStatus(D): status=%x\n", *lpbIsInVB); return res; } HRESULT WINAPI extRestoreDisplayModeProxy(LPDIRECTDRAW lpdd) { HRESULT res; OutTraceP("RestoreDisplayMode(D): PROXED lpdd=%x\n", lpdd); res=(*pRestoreDisplayMode)(lpdd); if(res) OutTraceP("RestoreDisplayMode(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetAvailableVidMemProxy(LPDIRECTDRAW lpdd, LPDDSCAPS lpDDSCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree) { HRESULT res; OutTraceP("GetAvailableVidMem(D): PROXED lpdd=%x\n", lpdd); res=(*pGetAvailableVidMem)(lpdd, lpDDSCaps, lpdwTotal, lpdwFree); if(res) OutTraceP("GetAvailableVidMem(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetAvailableVidMem(D): DDSCaps=%x(%s) Total=%x Free=%x res=%x\n", *lpDDSCaps, ExplainDDSCaps(lpDDSCaps->dwCaps), *lpdwTotal, *lpdwFree, res); return res; } HRESULT WINAPI extRestoreAllSurfacesProxy(LPDIRECTDRAW lpdd) { HRESULT res; OutTraceP("RestoreAllSurfaces(D): PROXED lpdd=%x\n", lpdd); res=(*pRestoreAllSurfaces)(lpdd); if(res) OutTraceP("RestoreAllSurfaces(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetDeviceIdentifierProxy(LPDIRECTDRAW lpdd, LPDDDEVICEIDENTIFIER lpDevId, DWORD dw) { HRESULT res; OutTraceP("GetDeviceIdentifier(D): PROXED lpdd=%x DevId=%x dw=%x\n", lpdd, lpDevId, dw); res=(*pGetDeviceIdentifier)(lpdd, lpDevId, dw); if(res) OutTraceP("GetDeviceIdentifier(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetDeviceIdentifier(D): Id=%x Driver=\"%s\" Description=\"%s\" Version=%d rev.=%x\n", lpDevId->dwDeviceId, lpDevId->szDriver, lpDevId->szDescription, lpDevId->liDriverVersion, lpDevId->dwRevision); return res; } ULONG WINAPI extCompactProxy(LPDIRECTDRAW lpdd) { ULONG res; res=(*pCompact)(lpdd); OutTraceP("Compact(D): PROXED lpdd=%x res=%x\n", lpdd, res); return res; } HRESULT WINAPI extEnumDisplayModesProxy(EnumDisplayModes1_Type pEnumDisplayModes, LPDIRECTDRAW lpdd, DWORD dwflags, LPDDSURFACEDESC lpddsd, LPVOID lpContext, LPDDENUMMODESCALLBACK cb) { HRESULT res; OutTraceP("EnumDisplayModes(D): PROXED lpdd=%x flags=%x lpddsd=%x callback=%x\n", lpdd, dwflags, lpddsd, cb); res=(*pEnumDisplayModes)(lpdd, dwflags, lpddsd, lpContext, cb); if(res) OutTraceP("EnumDisplayModes(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extEnumDisplayModes1Proxy(LPDIRECTDRAW lpdd, DWORD dwflags, LPDDSURFACEDESC lpddsd, LPVOID lpContext, LPDDENUMMODESCALLBACK cb) { return extEnumDisplayModesProxy(pEnumDisplayModes1, lpdd, dwflags, lpddsd, lpContext, cb); } HRESULT WINAPI extEnumDisplayModes4Proxy(LPDIRECTDRAW lpdd, DWORD dwflags, LPDDSURFACEDESC2 lpddsd, LPVOID lpContext, LPDDENUMMODESCALLBACK2 cb) { return extEnumDisplayModesProxy((EnumDisplayModes1_Type)pEnumDisplayModes4, lpdd, dwflags, (LPDDSURFACEDESC)lpddsd, lpContext, (LPDDENUMMODESCALLBACK)cb); } HRESULT WINAPI extGetFourCCCodesProxy(LPDIRECTDRAW lpdd, LPDWORD nc, LPDWORD cc) { int res; unsigned int i; OutTraceP("GetFourCCCodes(D): PROXED lpdd=%x\n", lpdd); res=(*pGetFourCCCodes)(lpdd, nc, cc); if (res) OutTraceP("GetFourCCCodes(D): res=%x(%s)\n", res, ExplainDDError(res)); else { OutTraceP("GetFourCCCodes(D): CCCodes(%d)=",*nc); if (cc) for(i=0;i<*nc;i++) OutTraceP("%x,",cc[i]); else OutTraceP("(NULL)"); OutTraceP("\n"); } return res; } HRESULT WINAPI extCreateSurfaceProxy(int dxVersion, CreateSurface_Type pCreateSurface, LPDIRECTDRAW lpdd, DDSURFACEDESC2 *lpddsd, LPDIRECTDRAWSURFACE *lplpdds, void *pu) { HRESULT res; OutTraceP("CreateSurface(D): PROXED version=%d lpdd=%x Flags=%x(%s)", dxVersion, lpdd, lpddsd->dwFlags, ExplainFlags(lpddsd->dwFlags)); if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) OutTraceP(" BackBufferCount=%d", lpddsd->dwBackBufferCount); if (lpddsd->dwFlags & DDSD_WIDTH) OutTraceP(" Width=%d", lpddsd->dwWidth); if (lpddsd->dwFlags & DDSD_HEIGHT) OutTraceP(" Height=%d", lpddsd->dwHeight); if (lpddsd->dwFlags & DDSD_CAPS) OutTraceP(" Caps=%x(%s)", lpddsd->ddsCaps.dwCaps, ExplainDDSCaps(lpddsd->ddsCaps.dwCaps)); if (lpddsd->dwFlags & DDSD_CKDESTBLT ) OutTraceP(" CKDestBlt=(%x,%x)", lpddsd->ddckCKDestBlt.dwColorSpaceLowValue, lpddsd->ddckCKDestBlt.dwColorSpaceHighValue); if (lpddsd->dwFlags & DDSD_CKDESTOVERLAY ) OutTraceP(" CKDestOverlay=(%x,%x)", lpddsd->ddckCKDestOverlay.dwColorSpaceLowValue, lpddsd->ddckCKDestOverlay.dwColorSpaceHighValue); if (lpddsd->dwFlags & DDSD_CKSRCBLT ) OutTraceP(" CKSrcBlt=(%x,%x)", lpddsd->ddckCKSrcBlt.dwColorSpaceLowValue, lpddsd->ddckCKSrcBlt.dwColorSpaceHighValue); if (lpddsd->dwFlags & DDSD_CKSRCOVERLAY ) OutTraceP(" CKSrcOverlay=(%x,%x)", lpddsd->ddckCKSrcOverlay.dwColorSpaceLowValue, lpddsd->ddckCKSrcOverlay.dwColorSpaceHighValue); OutTraceP("\n"); res= pCreateSurface(lpdd, lpddsd, lplpdds, pu); if (res) { OutTraceP("CreateSurface(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } OutTraceP("CreateSurface(D): lpdds=%x\n", *lplpdds); #ifdef HOOKSURFACE HookDDSurfaceProxy(lplpdds, dxVersion); #endif return res; } HRESULT WINAPI extCreateSurface1Proxy(LPDIRECTDRAW lpdd, DDSURFACEDESC *lpddsd, LPDIRECTDRAWSURFACE *lplpdds, void *pu) { return extCreateSurfaceProxy(1, (CreateSurface_Type)pCreateSurface1, lpdd, (DDSURFACEDESC2 *)lpddsd, lplpdds, pu); } HRESULT WINAPI extCreateSurface2Proxy(LPDIRECTDRAW lpdd, DDSURFACEDESC *lpddsd, LPDIRECTDRAWSURFACE *lplpdds, void *pu) { return extCreateSurfaceProxy(2, (CreateSurface_Type)pCreateSurface2, lpdd, (DDSURFACEDESC2 *)lpddsd, lplpdds, pu); } HRESULT WINAPI extCreateSurface4Proxy(LPDIRECTDRAW lpdd, DDSURFACEDESC2 *lpddsd, LPDIRECTDRAWSURFACE *lplpdds, void *pu) { return extCreateSurfaceProxy(4, (CreateSurface_Type)pCreateSurface4, lpdd, (DDSURFACEDESC2 *)lpddsd, lplpdds, pu); } HRESULT WINAPI extCreateSurface7Proxy(LPDIRECTDRAW lpdd, DDSURFACEDESC2 *lpddsd, LPDIRECTDRAWSURFACE *lplpdds, void *pu) { return extCreateSurfaceProxy(7, (CreateSurface_Type)pCreateSurface7, lpdd, (DDSURFACEDESC2 *)lpddsd, lplpdds, pu); } HRESULT WINAPI extEnumSurfacesProxy1(LPDIRECTDRAW lpdd, DWORD dwflags, LPDDSURFACEDESC lpddsd, LPVOID lpContext, LPDDENUMSURFACESCALLBACK cb) { HRESULT res; OutTraceP("EnumSurfaces(D1): PROXED lpdd=%x flags=%x lpddsd=%x callback=%x\n", lpdd, dwflags, lpddsd, cb); res=(*pEnumSurfaces1)(lpdd, dwflags, lpddsd, lpContext, cb); if(res) OutTraceP("EnumSurfaces(D1): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extEnumSurfacesProxy4(LPDIRECTDRAW lpdd, DWORD dwflags, LPDDSURFACEDESC2 lpddsd, LPVOID lpContext, LPDDENUMSURFACESCALLBACK2 cb) { HRESULT res; OutTraceP("EnumSurfaces(D4): PROXED lpdd=%x flags=%x lpddsd=%x callback=%x\n", lpdd, dwflags, lpddsd, cb); res=(*pEnumSurfaces4)(lpdd, dwflags, lpddsd, lpContext, cb); if(res) OutTraceP("EnumSurfaces(D4): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extDuplicateSurfaceProxy(LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE s, LPDIRECTDRAWSURFACE *sp) { int res; OutTraceP("DuplicateSurface(D): PROXED lpdd=%x dds=%x\n", lpdd, s); res=(*pDuplicateSurface)(lpdd, s, sp); if (res) OutTraceP("DuplicateSurface(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("DuplicateSurface: pdds=%x\n", *sp); return res; } HRESULT WINAPI extFlipToGDISurfaceProxy(LPDIRECTDRAW lpdd) { HRESULT res; OutTraceP("FlipToGDISurface(D): lpdd=%x\n", lpdd); res=(*pFlipToGDISurface)(lpdd); if (res) OutTraceP("FlipToGDISurface(D): ERROR res=%x(%s), skipping\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetDisplayModeProxy(LPDIRECTDRAW lpdd, LPDDSURFACEDESC lpddsd) { HRESULT res; OutTraceP("GetDisplayMode(D): PROXED lpdd=%x\n"); res=(*pGetDisplayMode)(lpdd, lpddsd); if(res) OutTraceP("GetDisplayMode(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else{ OutTraceP("GetDisplayMode(D): WxH=(%dx%d) PixelFormat Flags=%x(%s) RGBBitCount=%d RGBAmask=(%x,%x,%x,%x) Caps=%x(%s)\n", lpddsd->dwWidth, lpddsd->dwHeight, lpddsd->ddpfPixelFormat.dwFlags, ExplainPixelFormatFlags(lpddsd->ddpfPixelFormat.dwFlags), lpddsd->ddpfPixelFormat.dwRGBBitCount, lpddsd->ddpfPixelFormat.dwRBitMask, lpddsd->ddpfPixelFormat.dwGBitMask, lpddsd->ddpfPixelFormat.dwBBitMask, lpddsd->ddpfPixelFormat.dwRGBAlphaBitMask, lpddsd->ddsCaps.dwCaps, ExplainDDSCaps(lpddsd->ddsCaps.dwCaps)); } return res; } HRESULT WINAPI extGetGDISurfaceProxy(LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w) { int res; OutTraceP("GetGDISurface(D): PROXED lpdd=%x\n", lpdd); res=(*pGetGDISurface)(lpdd, w); if (res) OutTraceP("GetGDISurface(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetGDISurface(D): lpdds=%x\n", *w); return res; } HRESULT WINAPI extSetCooperativeLevelProxy(void *lpdd, HWND hwnd, DWORD dwflags) { HRESULT res; OutTraceP("SetCooperativeLevel(D): PROXED lpdd=%x hwnd=%x dwFlags=%x(%s)\n", lpdd, hwnd, dwflags,ExplainCoopFlags(dwflags)); res=(*pSetCooperativeLevel)(lpdd, hwnd, dwflags); if (res) OutTraceP("SetCooperativeLevel(D): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extSetDisplayMode2Proxy(LPDIRECTDRAW lpdd, DWORD dwwidth, DWORD dwheight, DWORD dwbpp, DWORD dwrefreshrate, DWORD dwflags) { HRESULT res; OutTraceP("SetDisplayMode(2): PROXED lpdd=%x WxH=(%dx%d) bpp=%d refresh=%x dwFlags=%x\n", lpdd, dwwidth, dwheight, dwbpp, dwrefreshrate, dwflags); res=(pSetDisplayMode2)(lpdd, dwwidth, dwheight, dwbpp, dwrefreshrate, dwflags); if (res) OutTraceP("SetDisplayMode(2): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extSetDisplayMode1Proxy(LPDIRECTDRAW lpdd, DWORD dwwidth, DWORD dwheight, DWORD dwbpp) { HRESULT res; OutTraceP("SetDisplayMode(1): PROXED lpdd=%x WxH=(%dx%d) bpp=%d\n", lpdd, dwwidth, dwheight, dwbpp); res=(pSetDisplayMode1)(lpdd, dwwidth, dwheight, dwbpp); if (res) OutTraceP("SetDisplayMode(1): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extTestCooperativeLevelProxy(LPDIRECTDRAW lpdd) { HRESULT res; OutTraceP("TestCooperativeLevel: PROXED lpdd=%x\n", lpdd); res=(*pTestCooperativeLevel)(lpdd); if (res) OutTraceP("TestCooperativeLevel: ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } // ------------------------------------------------------------------------------------------ // // // DirectDrawClipper proxed methods // // ------------------------------------------------------------------------------------------ // HRESULT WINAPI extQueryInterfaceCProxy(void *lpddclip, REFIID riid, LPVOID *obp) { HRESULT res; OutTraceP("QueryInterface(C): PROXED lpddClip=%x REFIID=%x(%s)\n", lpddclip, riid.Data1, ExplainGUID((GUID *)&riid.Data1)); res = (*pQueryInterfaceC)(lpddclip, riid, obp); if(res) OutTraceP("QueryInterface(C): ERROR err=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("QueryInterface(C): obp=%x\n", *obp); return res; } HRESULT WINAPI extAddRefCProxy(LPDIRECTDRAWCLIPPER lpddClip) { ULONG ref; ref=(*pAddRefC)(lpddClip); OutTraceP("AddRef(C): PROXED lpddClip=%x ref=%x\n", lpddClip, ref); return ref; } HRESULT WINAPI extGetClipListProxy(LPDIRECTDRAWCLIPPER lpddClip, LPRECT lpRect, LPRGNDATA lpRgnData, LPDWORD lpw) { HRESULT res; OutTraceP("GetClipList(C): PROXED lpddClip=%x ", lpddClip); if (lpRect) OutTraceP("rect=(%d,%d)-(%d,%d) ", lpRect->left, lpRect->top, lpRect->right, lpRect->bottom); else OutTraceP("rect=(NULL) "); res=(*pGetClipList)(lpddClip, lpRect, lpRgnData, lpw); if(res) OutTraceP("GeGetClipListtHWnd(C): ERROR err=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetClipList(C): w=%x\n", *lpw); return res; } HRESULT WINAPI extGetHWndProxy(LPDIRECTDRAWCLIPPER lpddClip, HWND FAR *lphwnd) { HRESULT res; OutTraceP("GetHWnd(C): PROXED lpddClip=%x\n", lpddClip); res=(*pGetHWnd)(lpddClip, lphwnd); if(res) OutTraceP("GetHWnd(C): ERROR err=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetHWnd(C): hwnd=%x\n", *lphwnd); return res; } HRESULT WINAPI extInitializeCProxy(LPDIRECTDRAWCLIPPER lpddClip, LPDIRECTDRAW lpdd, DWORD w) { HRESULT res; OutTraceP("Initialize(C): PROXED lpddClip=%x w=%x\n", lpddClip, w); res=(*pInitializeC)(lpddClip, lpdd, w); if(res) OutTraceP("Initialize(C): ERROR err=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extIsClipListChangedProxy(LPDIRECTDRAWCLIPPER lpddClip, BOOL FAR *w) { HRESULT res; OutTraceP("IsClipListChanged(C): PROXED lpddClip=%x\n", lpddClip); res=(*pIsClipListChanged)(lpddClip, w); if(res) OutTraceP("IsClipListChanged(C): ERROR err=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("IsClipListChanged(C): w=%x\n", *w); return res; } HRESULT WINAPI extSetClipListProxy(LPDIRECTDRAWCLIPPER lpddClip, LPRGNDATA lpRegnData, DWORD flags) { // to complete .... HRESULT res; OutTraceP("SetClipList(C): PROXED lpddClip=%x RgnData=??? flags=%x\n", lpddClip, flags); res=(*pSetClipList)(lpddClip, lpRegnData, flags); if(res) OutTraceP("SetClipList(C): ERROR err=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extSetHWndProxy(LPDIRECTDRAWCLIPPER lpddClip, DWORD w, HWND hwnd) { HRESULT res; OutTraceP("SetHWnd(C): PROXED lpddClip=%x w=%x hwnd=%x\n", lpddClip, w, hwnd); res=(*pSetHWnd)(lpddClip, w, hwnd); if(res) OutTraceP("SetHWnd(C): ERROR err=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extReleaseCProxy(LPDIRECTDRAWCLIPPER lpddClip) { ULONG ref; ref=(*pReleaseC)(lpddClip); OutTraceP("Release(C): PROXED lpddClip=%x ref=%x\n", lpddClip, ref); return ref; } // ------------------------------------------------------------------------------------------ // // // DirectDrawPalette proxed methods // // ------------------------------------------------------------------------------------------ // HRESULT WINAPI extQueryInterfacePProxy(void *lpddp, REFIID riid, LPVOID *obp) { HRESULT res; OutTraceP("QueryInterface(P): PROXED lpddp=%x REFIID=%x(%s)\n", lpddp, riid.Data1, ExplainGUID((GUID *)&riid.Data1)); res = (*pQueryInterfaceP)(lpddp, riid, obp); if(res) OutTraceP("QueryInterface(P): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("QueryInterface(P): obp=%x\n", *obp); return res; } HRESULT WINAPI extAddRefPProxy(LPDIRECTDRAWPALETTE lpddPalette) { ULONG ref; ref=(*pAddRefP)(lpddPalette); OutTraceP("AddRef(P): PROXED lpddPalette=%x ref=%x\n", lpddPalette, ref); return ref; } HRESULT WINAPI extReleasePProxy(LPDIRECTDRAWPALETTE lpddPalette) { ULONG ref; //OutTraceP("Release(P): lpddPalette=%x\n", lpddPalette); ref=(*pReleaseP)(lpddPalette); OutTraceP("Release(P): PROXED lpddPalette=%x ref=%x\n", lpddPalette, ref); return ref; } HRESULT WINAPI extGetCapsPProxy(LPDIRECTDRAWPALETTE lpddp, LPDWORD w) { HRESULT res; OutTraceP("GetCaps(P): PROXED lpddp=%x\n", lpddp); res=(*pGetCapsP)(lpddp, w); if(res) OutTraceP("GetCaps(P): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetCaps(P): caps=%x\n", *w); return res; } HRESULT WINAPI extGetEntriesProxy(LPDIRECTDRAWPALETTE lpddp, DWORD dwflags, DWORD dwstart, DWORD dwcount, LPPALETTEENTRY lpentries) { HRESULT res; OutTraceP("GetEntries(P): PROXED lpddp=%x flags=%x start=%x, count=%d\n", lpddp, dwflags, dwstart, dwcount); res=(*pGetEntries)(lpddp, dwflags, dwstart, dwcount, lpentries); if (res) OutTraceP("GetEntries(P): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extSetEntriesProxy(LPDIRECTDRAWPALETTE lpddp, DWORD dwflags, DWORD dwstart, DWORD dwcount, LPPALETTEENTRY lpentries) { HRESULT res; OutTraceP("SetEntries(P): PROXED lpddp=%x flags=%x start=%x, count=%d\n", lpddp, dwflags, dwstart, dwcount); res=(*pSetEntries)(lpddp, dwflags, dwstart, dwcount, lpentries); if (res) OutTraceP("SetEntries(P): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } // ------------------------------------------------------------------------------------------ // // // DirectDrawSurface proxed methods // // ------------------------------------------------------------------------------------------ // HRESULT WINAPI extSetOverlayPositionProxy(LPDIRECTDRAWSURFACE lpdds, LONG l1, LONG l2) { HRESULT res; OutTraceP("SetOverlayPosition(S): PROXED lpdds=%x l1=%x l2=%x\n", lpdds, l1, l2); res=(*pSetOverlayPosition)(lpdds, l1, l2); if (res) OutTraceP("SetOverlayPosition(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extEnumOverlayZOrdersProxy(LPDIRECTDRAWSURFACE lpdds, DWORD w, LPVOID v, LPDDENUMSURFACESCALLBACK eozCBack) { HRESULT res; OutTraceP("EnumOverlayZOrders(S): PROXED lpdds=%x w=%x v=%x\n", lpdds, w, v); res=(*pEnumOverlayZOrders)(lpdds, w, v, eozCBack); if(res) OutTraceP("EnumOverlayZOrders(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetBltStatusProxy(LPDIRECTDRAWSURFACE lpdds, DWORD flags) { HRESULT res; res=(*pGetBltStatus)(lpdds, flags); OutTraceP("GetBltStatus(S): PROXED lpdds=%x flags=%x(%s) res=%x(%s)\n", lpdds, flags, ExplainBltStatus(flags), res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetClipperProxy(LPDIRECTDRAWSURFACE lpdds, LPDIRECTDRAWCLIPPER FAR*lpddc) { HRESULT res; OutTraceP("GetClipper(P): PROXED lpdds=%x\n", lpdds); res=(*pGetClipper)(lpdds, lpddc); if(res) OutTraceP("GetClipper(P): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetClipper(P): ddc=%x\n", *lpddc); return res; } HRESULT WINAPI extGetFlipStatusProxy(LPDIRECTDRAWSURFACE lpdds, DWORD flags) { HRESULT res; OutTraceP("GetFlipStatus(S): PROXED lpdds=%x flags=%x(%s)\n", lpdds, flags, ExplainFlipStatusFlags(flags)); res=(*pGetFlipStatus)(lpdds, flags); if(res==DDERR_WASSTILLDRAWING) OutTraceP("GetFlipStatus(S): res=%x(%s)\n", res, ExplainDDError(res)); else if(res) OutTraceP("GetFlipStatus(S): ERROR err=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetOverlayPositionProxy(LPDIRECTDRAWSURFACE lpdds, LPLONG lpl1, LPLONG lpl2) { HRESULT res; OutTraceP("GetOverlayPosition(S): PROXED lpdds=%x\n", lpdds); res=(*pGetOverlayPosition)(lpdds, lpl1, lpl2); if(res) OutTraceP("GetOverlayPosition(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetOverlayPosition(S): p1=%x p2=%x\n", *lpl1, *lpl2); return res; } // ----------------- DirectDraw Surface proxy methods ------------------------// HRESULT WINAPI extBltBatchProxy(LPDIRECTDRAWSURFACE lpdds, LPDDBLTBATCH lpDDBltBatch , DWORD dwCount, DWORD dwflags) { HRESULT res; OutTraceP("BltBatch(S): PROXED lpdds=%x lpddsadd=%x DDBltBatch=%x count=%d flags=%x\n", lpdds, lpDDBltBatch, dwCount, dwflags); res=(*pBltBatch)(lpdds, lpDDBltBatch, dwCount, dwflags); if(res) OutTraceP("BltBatch(S): ERROR %x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extQueryInterfaceSProxy(void *lpdds, REFIID riid, LPVOID *obp) { HRESULT res; unsigned int dxVersion; OutTraceP("QueryInterface(S): PROXED lpdds=%x REFIID=%x(%s)\n", lpdds, riid.Data1, ExplainGUID((GUID *)&riid.Data1)); res = (*pQueryInterfaceS)(lpdds, riid, obp); if(res){ OutTraceP("QueryInterface(S): ERROR err=%x(%s)\n", res, ExplainDDError(res)); return res; } dxVersion=0; switch(riid.Data1){ case 0x6C14DB81: dxVersion = 1; break; case 0x57805885: dxVersion = 2; break; case 0xDA044E00: dxVersion = 3; break; case 0x0B2B8630: dxVersion = 4; break; case 0x06675a80: dxVersion = 7; break; } OutTraceP("QueryInterface(S): obp=%x interface=%d\n", *obp, dxVersion); switch (dxVersion){ case 1: case 2: case 3: case 4: case 7: #ifdef HOOKSURFACE HookDDSurfaceProxy((LPDIRECTDRAWSURFACE *)obp, dxVersion); #endif break; } return res; } HRESULT WINAPI extReleaseSProxy(LPDIRECTDRAWSURFACE lpdds) { HRESULT res; res=(*pReleaseS)(lpdds); OutTraceP("Release(S): PROXED lpdds=%x res=%x\n", lpdds, res); return res; } HRESULT WINAPI extAddAttachedSurfaceProxy(LPDIRECTDRAWSURFACE lpdds, LPDIRECTDRAWSURFACE lpddsadd) { HRESULT res; OutTraceP("AddAttachedSurface(S): PROXED lpdds=%x lpddsadd=%x\n", lpdds, lpddsadd); res=(*pAddAttachedSurface)(lpdds, lpddsadd); if(res) OutTraceP("AddAttachedSurface(S): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extBltProxy(LPDIRECTDRAWSURFACE lpdds, LPRECT lpdestrect, LPDIRECTDRAWSURFACE lpddssrc, LPRECT lpsrcrect, DWORD dwflags, LPDDBLTFX lpddbltfx) { HRESULT res; OutTraceP("Blt(S): PROXED dest=%x src=%x dwFlags=%x(%s)", lpdds, lpddssrc, dwflags, ExplainBltFlags(dwflags)); if (lpdestrect) OutTraceP(" destrect=(%d,%d)-(%d,%d)", lpdestrect->left, lpdestrect->top, lpdestrect->right, lpdestrect->bottom); else OutTraceP(" destrect=(NULL)"); if (lpsrcrect) OutTraceP(" srcrect=(%d,%d)-(%d,%d)\n", lpsrcrect->left, lpsrcrect->top, lpsrcrect->right, lpsrcrect->bottom); else OutTraceP(" srcrect=(NULL)\n"); res=(*pBlt)(lpdds, lpdestrect, lpddssrc, lpsrcrect, dwflags, lpddbltfx); if(res) OutTraceP("Blt(S): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extBltFastProxy(LPDIRECTDRAWSURFACE lpdds, DWORD dwx, DWORD dwy, LPDIRECTDRAWSURFACE lpddssrc, LPRECT lpsrcrect, DWORD dwtrans) { HRESULT res; OutTraceP("BltFast(S): PROXED lpdds=%x xy=(%d,%d) src=%x dwtrans=%x(%s)", lpdds, dwx, dwy, lpddssrc, dwtrans, ExplainBltFastFlags(dwtrans)); if (lpsrcrect) OutTraceP(" srcrect=(%d,%d)-(%d,%d)\n", lpsrcrect->left, lpsrcrect->top, lpsrcrect->right, lpsrcrect->bottom); else OutTraceP(" srcrect=(NULL)\n"); res=(*pBltFast)(lpdds, dwx, dwy, lpddssrc, lpsrcrect, dwtrans); if(res) OutTraceP("BltFast(S): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extEnumAttachedSurfacesProxy(LPDIRECTDRAWSURFACE lpdds, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback) { HRESULT res; OutTraceP("EnumAttachedSurfaces(S): PROXED lpdds=%x Context=%x Callback=%x\n", lpdds, lpContext, lpEnumSurfacesCallback); res=(*pEnumAttachedSurfaces)(lpdds, lpContext, lpEnumSurfacesCallback); if(res) OutTraceP("EnumAttachedSurfaces(S): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetAttachedSurface1Proxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS lpddsc, LPDIRECTDRAWSURFACE *lplpddas) { HRESULT res; OutTraceP("GetAttachedSurface(S1): PROXED lpdds=%x caps=%x(%s)\n", lpdds, lpddsc->dwCaps, ExplainDDSCaps(lpddsc->dwCaps)); res=(*pGetAttachedSurface1)(lpdds, lpddsc, lplpddas); if(res) OutTraceP("GetAttachedSurface(S1): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetAttachedSurface(S1): lpddas=%x\n", *lplpddas); return res; } HRESULT WINAPI extGetAttachedSurface3Proxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS lpddsc, LPDIRECTDRAWSURFACE *lplpddas) { HRESULT res; OutTraceP("GetAttachedSurface(S3): PROXED lpdds=%x caps=%x(%s)\n", lpdds, lpddsc->dwCaps, ExplainDDSCaps(lpddsc->dwCaps)); res=(*pGetAttachedSurface3)(lpdds, lpddsc, lplpddas); if(res) OutTraceP("GetAttachedSurface(S3): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetAttachedSurface(S3): lpddas=%x\n", *lplpddas); return res; } HRESULT WINAPI extGetAttachedSurface4Proxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS lpddsc, LPDIRECTDRAWSURFACE *lplpddas) { HRESULT res; OutTraceP("GetAttachedSurface(S4): PROXED lpdds=%x caps=%x(%s)\n", lpdds, lpddsc->dwCaps, ExplainDDSCaps(lpddsc->dwCaps)); res=(*pGetAttachedSurface4)(lpdds, lpddsc, lplpddas); if(res) OutTraceP("GetAttachedSurface(S4): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetAttachedSurface(S4): lpddas=%x\n", *lplpddas); return res; } HRESULT WINAPI extGetAttachedSurface7Proxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS lpddsc, LPDIRECTDRAWSURFACE *lplpddas) { HRESULT res; OutTraceP("GetAttachedSurface(S7): PROXED lpdds=%x caps=%x(%s)\n", lpdds, lpddsc->dwCaps, ExplainDDSCaps(lpddsc->dwCaps)); res=(*pGetAttachedSurface7)(lpdds, lpddsc, lplpddas); if(res) OutTraceP("GetAttachedSurface(S7): ERROR ret=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetAttachedSurface(S7): lpddas=%x\n", *lplpddas); return res; } HRESULT WINAPI extGetCaps1SProxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS caps) { HRESULT res; OutTraceP("GetCaps(S1): PROXED lpdds=%x\n", lpdds); res=(*pGetCaps1S)(lpdds, caps); if(res) OutTraceP("GetCaps(S1): ERROR %x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetCaps(S1): caps=%x(%s)\n", caps->dwCaps, ExplainDDSCaps(caps->dwCaps)); return res; } HRESULT WINAPI extGetCaps2SProxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS caps) { HRESULT res; OutTraceP("GetCaps(S2): PROXED lpdds=%x\n", lpdds); res=(*pGetCaps2S)(lpdds, caps); if(res) OutTraceP("GetCaps(S2): ERROR %x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetCaps(S2): caps=%x(%s)\n", caps->dwCaps, ExplainDDSCaps(caps->dwCaps)); return res; } HRESULT WINAPI extGetCaps3SProxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS caps) { HRESULT res; OutTraceP("GetCaps(S3): PROXED lpdds=%x\n", lpdds); res=(*pGetCaps3S)(lpdds, caps); if(res) OutTraceP("GetCaps(S3): ERROR %x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetCaps(S3): caps=%x(%s)\n", caps->dwCaps, ExplainDDSCaps(caps->dwCaps)); return res; } HRESULT WINAPI extGetCaps4SProxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS2 caps) { HRESULT res; OutTraceP("GetCaps(S4): PROXED lpdds=%x\n", lpdds); res=(*pGetCaps4S)(lpdds, caps); if(res) OutTraceP("GetCaps(S4): ERROR %x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetCaps(S4): caps=%x(%s)\n", caps->dwCaps, ExplainDDSCaps(caps->dwCaps)); return res; } HRESULT WINAPI extGetCaps7SProxy(LPDIRECTDRAWSURFACE lpdds, LPDDSCAPS2 caps) { HRESULT res; OutTraceP("GetCaps(S7): PROXED lpdds=%x\n", lpdds); res=(*pGetCaps7S)(lpdds, caps); if(res) OutTraceP("GetCaps(S7): ERROR %x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetCaps(S7): caps=%x(%s)\n", caps->dwCaps, ExplainDDSCaps(caps->dwCaps)); return res; } HRESULT WINAPI extGetColorKeyProxy(LPDIRECTDRAWSURFACE lpdds, DWORD flags, LPDDCOLORKEY lpDDColorKey) { HRESULT res; OutTraceP("GetColorKey(S): PROXED lpdds=%x flags=%x(%s)\n", lpdds, flags, ExplainColorKeyFlag(flags)); res=(*pGetColorKey)(lpdds, flags, lpDDColorKey); if(res) OutTraceP("GetColorKey(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetColorKey(S): colors=(L:%x,H:%x)\n", lpDDColorKey->dwColorSpaceLowValue, lpDDColorKey->dwColorSpaceHighValue); return res; } HRESULT WINAPI extGetPaletteProxy(LPDIRECTDRAWSURFACE lpdds, LPDIRECTDRAWPALETTE *lplpddp) { HRESULT res; OutTraceP("GetPalette(S): PROXED lpdds=%x\n", lpdds); res=(*pGetPalette)(lpdds, lplpddp); if(res)OutTraceP("GetPalette(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extGetPixelFormatProxy(LPDIRECTDRAWSURFACE lpdds, LPDDPIXELFORMAT p) { DWORD res; OutTraceP("GetPixelFormat(S): PROXED lpdds=%x\n", lpdds); res=(*pGetPixelFormat)(lpdds, p); if(res) OutTraceP("GetPixelFormat(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else OutTraceP("GetPixelFormat(S): Flags=%x(%s) FourCC=%x BitCount=%d RGBA=(%x,%x,%x,%x)\n", p->dwFlags, ExplainPixelFormatFlags(p->dwFlags), p->dwFourCC, p->dwRGBBitCount, p->dwRBitMask, p->dwGBitMask, p->dwBBitMask, p->dwRGBAlphaBitMask ); return res; } static char *sdtype(int dwSize) { switch(dwSize){ case sizeof(DDSURFACEDESC): return "type1"; break; case sizeof(DDSURFACEDESC2): return "type2"; break; default: return "unknown"; break; } return ""; } HRESULT WINAPI extSetClipperProxy(LPDIRECTDRAWSURFACE lpdds, LPDIRECTDRAWCLIPPER lpddc) { HRESULT res; OutTraceP("SetClipper(S): PROXED lpdds=%x lpddc=%x\n", lpdds, lpddc); res=(*pSetClipper)(lpdds, lpddc); if (res)OutTraceP("SetClipper(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extSetColorKeyProxy(LPDIRECTDRAWSURFACE lpdds, DWORD flags, LPDDCOLORKEY lpDDColorKey) { HRESULT res; OutTraceP("SetColorKey(S): PROXED lpdds=%x flags=%x ", lpdds, flags); if (lpDDColorKey) OutTraceP("colors=(L:%x,H:%x)\n",lpDDColorKey->dwColorSpaceLowValue, lpDDColorKey->dwColorSpaceHighValue); else OutTraceP("colors=(NULL)\n"); res=(*pSetColorKey)(lpdds, flags, lpDDColorKey); if(res) OutTraceP("SetColorKey(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extSetPaletteProxy(LPDIRECTDRAWSURFACE lpdds, LPDIRECTDRAWPALETTE lpddp) { HRESULT res; OutTraceP("SetPalette(S): PROXED lpdds=%x lpddp=%x\n", lpdds, lpddp); res=(*pSetPalette)(lpdds, lpddp); if(res)OutTraceP("SetPalette(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extLockProxy(LPDIRECTDRAWSURFACE lpdds, LPRECT lprect, LPDIRECTDRAWSURFACE lpdds2, DWORD flags, HANDLE hEvent) { HRESULT res; OutTraceP("Lock(S): PROXED lpdds=%x flags=%x(%s) lpdds2=%x", lpdds, flags, ExplainLockFlags(flags), lpdds2); if (lprect) OutTraceP(" rect=(%d,%d)-(%d,%d)\n", lprect->left, lprect->top, lprect->right, lprect->bottom); else OutTraceP(" rect=(NULL)\n"); res=(*pLock)(lpdds, lprect, lpdds2, flags, hEvent); if (res) OutTraceP("Lock(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extUnlock1Proxy(LPDIRECTDRAWSURFACE lpdds, LPVOID lpvoid) { HRESULT res; OutTraceP("Unlock(S): PROXED lpdds=%x ", lpdds); if (lpvoid) OutTraceP("lpvoid=%x->%x\n", lpvoid, *(DWORD *)lpvoid); else OutTraceP("lpvoid=(NULL)\n"); res=(*pUnlock1)(lpdds, lpvoid); if(res)OutTraceP("Unlock(S): ERROR res=%x(%s)\n",res,ExplainDDError(res)); return res; } HRESULT WINAPI extUnlock4Proxy(LPDIRECTDRAWSURFACE lpdds, LPRECT lprect) { HRESULT res; OutTraceP("Unlock(S): PROXED lpdds=%x ", lpdds); if (lprect) OutTraceP("rect=(%d,%d)-(%d,%d)\n", lprect->left, lprect->top, lprect->right, lprect->bottom); else OutTraceP("rect=(NULL)\n"); res=(*pUnlock4)(lpdds, lprect); if(res)OutTraceP("Unlock(S): ERROR res=%x(%s)\n",res,ExplainDDError(res)); return res; } HRESULT WINAPI extGetDCProxy(LPDIRECTDRAWSURFACE lpdds, HDC FAR *pHDC) { HRESULT res; OutTraceP("GetDC(S): PROXED lpdss=%x\n",lpdds); res=(*pGetDC)(lpdds,pHDC); if(res) OutTraceP("GetDC(S): ERROR res=%x(%s)\n",res,ExplainDDError(res)); else OutTraceP("GetDC(S): hdc=%x\n",*pHDC); return res; } HRESULT WINAPI extReleaseDCProxy(LPDIRECTDRAWSURFACE lpdds, HDC FAR hdc) { HRESULT res; OutTraceP("ReleaseDC(S): lpdds=%x hdc=%x\n", lpdds, hdc); res=(*pReleaseDC)(lpdds,hdc); if(res) OutTraceP("ReleaseDC(S): ERROR res=%x(%s)\n",res,ExplainDDError(res)); return res; } HRESULT WINAPI extDeleteAttachedSurfaceProxy(LPDIRECTDRAWSURFACE lpdds, DWORD dwflags, LPDIRECTDRAWSURFACE lpddsdel) { HRESULT res; OutTraceP("DeleteAttachedSurface(S): lpdds=%x flags=%x lpddsdel=%x\n", lpdds, dwflags, lpddsdel); res=(*pDeleteAttachedSurface)(lpdds, dwflags, lpddsdel); if(res) OutTraceP("DeleteAttachedSurface(S): ERROR %x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extIsLostProxy(LPDIRECTDRAWSURFACE lpdds) { HRESULT res; //OutTraceP("IsLost: PROXED lpdds=%x\n", lpdds); res=(*pIsLost)(lpdds); OutTraceP("IsLost(S): PROXED lpdds=%x res=%x\n", lpdds, res); return res; } HRESULT WINAPI extRestoreProxy(LPDIRECTDRAWSURFACE lpdds) { HRESULT res; OutTraceP("Restore(S): PROXED lpdds=%x\n", lpdds); res=(*pRestore)(lpdds); if(res) OutTraceP("Restore(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extUpdateOverlayDisplayProxy(LPDIRECTDRAWSURFACE lpdds, DWORD dwflags) { HRESULT res; OutTraceP("UpdateOverlayDisplay(S): PROXED lpdds=%x flags=%x\n", lpdds, dwflags); res=(*pUpdateOverlayDisplay)(lpdds, dwflags); if(res) OutTraceP("UpdateOverlayDisplay(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extFlipProxy(LPDIRECTDRAWSURFACE lpdds, LPDIRECTDRAWSURFACE lpddst, DWORD dwflags) { HRESULT res; OutTraceP("Flip(S): PROXED target=%x, src=%x, flags=%x(%s)\n", lpdds, lpddst, dwflags, ExplainFlipFlags(dwflags)); res=(*pFlip)(lpdds, lpddst, dwflags); if(res) OutTraceP("Flip(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extAddOverlayDirtyRectProxy(LPDIRECTDRAWSURFACE lpdds, LPRECT drect) { HRESULT res; OutTraceP("AddOverlayDirtyRect(S): PROXED lpdds=%x ", lpdds); if (drect) OutTraceP(" drect=(%d,%d)-(%d,%d)\n",drect->left, drect->top, drect->right, drect->bottom); else OutTraceP(" drect=(NULL)\n"); res=(*pAddOverlayDirtyRect)(lpdds, drect); if(res) OutTraceP("AddOverlayDirtyRect(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extUpdateOverlayProxy(LPDIRECTDRAWSURFACE lpdds, LPRECT lpSrcRect, LPDIRECTDRAWSURFACE lpddsdest, LPRECT lpDestRect, DWORD dwflags, LPDDOVERLAYFX f) { HRESULT res; OutTraceP("UpdateOverlay(S): PROXED lpdds=%x lpddsdest=%x dwflags=%x", lpdds, lpddsdest, dwflags); if (lpSrcRect) OutTraceP(" src=(%d,%d)-(%d,%d)",lpSrcRect->left, lpSrcRect->top, lpSrcRect->right, lpSrcRect->bottom); else OutTraceP(" src=(NULL)"); if (lpDestRect) OutTraceP(" dest=(%d,%d)-(%d,%d)\n",lpDestRect->left, lpDestRect->top, lpDestRect->right, lpDestRect->bottom); else OutTraceP(" dest=(NULL)\n"); res=(*pUpdateOverlay)(lpdds, lpSrcRect, lpddsdest, lpDestRect, dwflags, f); if(res) OutTraceP("UpdateOverlay(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } HRESULT WINAPI extUpdateOverlayZOrderProxy(LPDIRECTDRAWSURFACE lpdds, DWORD flags, LPDIRECTDRAWSURFACE lpDDSReference) { HRESULT res; OutTraceP("UpdateOverlayZOrder(S): PROXED lpdds=%x lpddsref=%x flags=%x\n",lpdds, lpDDSReference, flags); res=(*pUpdateOverlayZOrder)(lpdds, flags, lpDDSReference); if(res) OutTraceP("UpdateOverlayZOrder(S): ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } ULONG WINAPI extAddRefSProxy(LPDIRECTDRAWSURFACE lpdds) { ULONG ref; ref=(*pAddRefS)(lpdds); OutTraceP("AddRef(S): PROXED lpdds=%x ref=%x\n", lpdds, ref); return ref; } static void HookDDSessionProxy(LPDIRECTDRAW *lplpdd, int dxVersion) { OutTraceP("Hooking directdraw session dd=%x dxVersion=%d thread_id=%x\n", *lplpdd, dxVersion, GetCurrentThreadId()); // IDIrectDraw::QueryInterface SetHook((void *)(**(DWORD **)lplpdd + 0), extQueryInterfaceDProxy, (void **)&pQueryInterfaceD, "QueryInterface(D)"); #ifdef TRACECOMMETHODS // IDIrectDraw::AddRef SetHook((void *)(**(DWORD **)lplpdd + 4), extAddRefDProxy, (void **)&pAddRefD, "AddRef(D)"); // IDIrectDraw::Release SetHook((void *)(**(DWORD **)lplpdd + 8), extReleaseDProxy, (void **)&pReleaseD, "Release(D)"); #endif // IDIrectDraw::Compact SetHook((void *)(**(DWORD **)lplpdd + 12), extCompactProxy, (void **)&pCompact, "Compact(D)"); // IDIrectDraw::CreateClipper SetHook((void *)(**(DWORD **)lplpdd + 16), extCreateClipperProxy, (void **)&pCreateClipper, "CreateClipper(D)"); // IDIrectDraw::CreatePalette SetHook((void *)(**(DWORD **)lplpdd + 20), extCreatePaletteProxy, (void **)&pCreatePalette, "CreatePalette(D)"); switch(dxVersion) { case 1: SetHook((void *)(**(DWORD **)lplpdd + 24), extCreateSurface1Proxy, (void **)&pCreateSurface1, "CreateSurface(D1)"); break; case 2: SetHook((void *)(**(DWORD **)lplpdd + 24), extCreateSurface2Proxy, (void **)&pCreateSurface2, "CreateSurface(D2)"); break; case 4: SetHook((void *)(**(DWORD **)lplpdd + 24), extCreateSurface4Proxy, (void **)&pCreateSurface4, "CreateSurface(D4)"); break; case 7: SetHook((void *)(**(DWORD **)lplpdd + 24), extCreateSurface7Proxy, (void **)&pCreateSurface7, "CreateSurface(D7)"); break; } // IDIrectDraw::DuplicateSurface SetHook((void *)(**(DWORD **)lplpdd + 28), extDuplicateSurfaceProxy, (void **)&pDuplicateSurface, "DuplicateSurface(D)"); // IDIrectDraw::EnumDisplayModes switch(dxVersion) { case 1: case 2: SetHook((void *)(**(DWORD **)lplpdd + 32), extEnumDisplayModes1Proxy, (void **)&pEnumDisplayModes1, "EnumDisplayModes(D1)"); break; case 4: case 7: SetHook((void *)(**(DWORD **)lplpdd + 32), extEnumDisplayModes4Proxy, (void **)&pEnumDisplayModes4, "EnumDisplayModes(D4)"); break; } // IDIrectDraw::EnumSurfaces if (dxVersion < 4) SetHook((void *)(**(DWORD **)lplpdd + 36), extEnumSurfacesProxy1, (void **)&pEnumSurfaces1, "EnumSurfaces(D1)"); else SetHook((void *)(**(DWORD **)lplpdd + 36), extEnumSurfacesProxy4, (void **)&pEnumSurfaces4, "EnumSurfaces(D4)"); // IDIrectDraw::FlipToGDISurface SetHook((void *)(**(DWORD **)lplpdd + 40), extFlipToGDISurfaceProxy, (void **)&pFlipToGDISurface, "FlipToGDISurface(D)"); // IDIrectDraw::GetCaps SetHook((void *)(**(DWORD **)lplpdd + 44), extGetCapsDProxy, (void **)&pGetCapsD, "GetCaps(D)"); // IDIrectDraw::GetDisplayMode SetHook((void *)(**(DWORD **)lplpdd + 48), extGetDisplayModeProxy, (void **)&pGetDisplayMode, "GetDisplayMode(D)"); // IDIrectDraw::GetFourCCCodes SetHook((void *)(**(DWORD **)lplpdd + 52), extGetFourCCCodesProxy, (void **)&pGetFourCCCodes, "GetFourCCCodes(D)"); // IDIrectDraw::GetGDISurface SetHook((void *)(**(DWORD **)lplpdd + 56), extGetGDISurfaceProxy, (void **)&pGetGDISurface, "GetGDISurface(D)"); // IDIrectDraw::GetMonitorFrequency SetHook((void *)(**(DWORD **)lplpdd + 60), extGetMonitorFrequencyProxy, (void **)&pGetMonitorFrequency, "GetMonitorFrequency(D)"); // IDIrectDraw::GetScanLine SetHook((void *)(**(DWORD **)lplpdd + 64), extGetScanLineProxy, (void **)&pGetScanLine, "GetScanLine(D)"); // IDIrectDraw::GetVerticalBlankStatus SetHook((void *)(**(DWORD **)lplpdd + 68), extGetVerticalBlankStatusProxy, (void **)&pGetVerticalBlankStatus, "GetVerticalBlankStatus(D)"); // IDIrectDraw::Initialize // offset 72: Undocumented // IDIrectDraw::RestoreDisplayMode SetHook((void *)(**(DWORD **)lplpdd + 76), extRestoreDisplayModeProxy, (void **)&pRestoreDisplayMode, "RestoreDisplayMode(D)"); if (dxVersion >= 2){ // IDIrectDraw::GetAvailableVidMem SetHook((void *)(**(DWORD **)lplpdd + 92), extGetAvailableVidMemProxy, (void **)&pGetAvailableVidMem, "GetAvailableVidMem(D)"); } if (dxVersion >= 4){ // IDIrectDraw::GetSurfaceFromDC SetHook((void *)(**(DWORD **)lplpdd + 96), extGetSurfaceFromDCProxy, (void **)&pGetSurfaceFromDC, "GetSurfaceFromDC(D)"); // IDIrectDraw::RestoreAllSurfaces SetHook((void *)(**(DWORD **)lplpdd + 100), extRestoreAllSurfacesProxy, (void **)&pRestoreAllSurfaces, "RestoreAllSurfaces(D)"); // IDIrectDraw::GetDeviceIdentifier SetHook((void *)(**(DWORD **)lplpdd + 108), extGetDeviceIdentifierProxy, (void **)&pGetDeviceIdentifier, "GetDeviceIdentifier(D)"); } // IDIrectDraw::SetCooperativeLevel SetHook((void *)(**(DWORD **)lplpdd + 80), extSetCooperativeLevelProxy, (void **)&pSetCooperativeLevel, "SetCooperativeLevel(D)"); // IDIrectDraw::SetDisplayMode if (dxVersion > 1){ SetHook((void *)(**(DWORD **)lplpdd + 84), extSetDisplayMode2Proxy, (void **)&pSetDisplayMode2, "SetDisplayMode(D2)"); } else { SetHook((void *)(**(DWORD **)lplpdd + 84), extSetDisplayMode1Proxy, (void **)&pSetDisplayMode1, "SetDisplayMode(D1)"); } #if 0 // IDIrectDraw::WaitForVerticalBlank SetHook((void *)(**(DWORD **)lplpdd + 88), extWaitForVerticalBlankProxy, (void **)&pWaitForVerticalBlank, "WaitForVerticalBlank(D)"); #endif if (dxVersion >= 4){ // IDIrectDraw::TestCooperativeLevel SetHook((void *)(**(DWORD **)lplpdd + 104), extTestCooperativeLevelProxy, (void **)&pTestCooperativeLevel, "TestCooperativeLevel(D)"); } } HRESULT WINAPI extDirectDrawCreateProxy(GUID FAR *lpguid, LPDIRECTDRAW FAR *lplpdd, IUnknown FAR *pu) { HRESULT res; int DDVersion; OutTraceP("DirectDrawCreate: PROXED guid=%x(%s)\n", lpguid, ExplainGUID(lpguid)); res = (*pDirectDrawCreate)(lpguid, lplpdd, pu); if(res) { OutTraceP("DirectDrawCreate: ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } DDVersion=1; if (lpguid) switch (*(DWORD *)lpguid){ case 0x6C14DB80: DDVersion=1; break; case 0xB3A6F3E0: DDVersion=2; break; case 0x9c59509a: DDVersion=4; break; case 0x15e65ec0: DDVersion=7; break; } OutTraceP("DirectDrawCreate: lpdd=%x guid=%x DDVersion=%d\n", *lplpdd, (lpguid ? *(DWORD *)lpguid:0), DDVersion); #ifdef HOOKDDRAW HookDDSessionProxy(lplpdd, DDVersion); #endif return 0; } HRESULT WINAPI extDirectDrawCreateExProxy(GUID FAR *lpguid, LPDIRECTDRAW FAR *lplpdd, REFIID RefIid, IUnknown FAR *pu) { HRESULT res; int DDVersion; OutTraceP("DirectDrawCreateEx: PROXED guid=%x(%s) refiid=%x\n", lpguid, ExplainGUID(lpguid), RefIid); res = (*pDirectDrawCreate)(lpguid, lplpdd, pu); if(res) { OutTraceP("DirectDrawCreateEx: ERROR res=%x(%s)\n", res, ExplainDDError(res)); return res; } DDVersion=1; if (lpguid) switch (*(DWORD *)lpguid){ case 0x6C14DB80: DDVersion=1; break; case 0xB3A6F3E0: DDVersion=2; break; case 0x9c59509a: DDVersion=4; break; case 0x15e65ec0: DDVersion=7; break; } OutTraceP("DirectDrawCreateEx: lpdd=%x guid=%x DDVersion=%d\n", *lplpdd, (lpguid ? *(DWORD *)lpguid:0), DDVersion); #ifdef HOOKDDRAW HookDDSessionProxy(lplpdd, DDVersion); #endif return 0; } HRESULT WINAPI extGetSurfaceDesc1Proxy(LPDIRECTDRAWSURFACE lpdds, LPDDSURFACEDESC lpddsd) { HRESULT res; OutTraceP("GetSurfaceDesc(1): PROXED lpdds=%x lpddsd=%x size=%x\n", lpdds, lpddsd, lpddsd->dwSize); res=(*pGetSurfaceDesc1)(lpdds, lpddsd); if (res) OutTraceP("GetSurfaceDesc(1): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else DumpSurfaceAttributesProxy(lpddsd, "GetSurfaceDesc(1)"); return res; } HRESULT WINAPI extGetSurfaceDesc4Proxy(LPDIRECTDRAWSURFACE2 lpdds, LPDDSURFACEDESC2 lpddsd) { HRESULT res; OutTraceP("GetSurfaceDesc(4): PROXED lpdds=%x lpddsd=%x size=%x\n", lpdds, lpddsd, lpddsd->dwSize); res=(*pGetSurfaceDesc4)(lpdds, lpddsd); if (res) OutTraceP("GetSurfaceDesc(4): ERROR res=%x(%s)\n", res, ExplainDDError(res)); else DumpSurfaceAttributesProxy((LPDDSURFACEDESC)lpddsd, "GetSurfaceDesc(4)"); return res; } BOOL WINAPI DDEnumerateCallback(GUID *lpGuid, LPSTR lpDriverDescription, LPSTR lpDriverName, LPVOID lpContext) { OutTrace("DDEnumerateCallback: guid=%x DriverDescription=\"%s\" DriverName=\"%s\" Context=%x\n", lpGuid, lpDriverDescription, lpDriverName, lpContext); return TRUE; } BOOL WINAPI DDEnumerateCallbackEx(GUID *lpGuid, LPSTR lpDriverDescription, LPSTR lpDriverName, LPVOID lpContext, HMONITOR hm) { OutTrace("DDEnumerateCallbackEx: guid=%x DriverDescription=\"%s\" DriverName=\"%s\" Context=%x hm=%x\n", lpGuid, lpDriverDescription, lpDriverName, lpContext, hm); return TRUE; } HRESULT WINAPI extDirectDrawEnumerateProxy(LPDDENUMCALLBACK lpCallback, LPVOID lpContext) { HRESULT ret; OutTraceP("DirectDrawEnumerate: PROXED lpCallback=%x lpContext=%x\n", lpCallback, lpContext); if(IsDebug) (*pDirectDrawEnumerate)(DDEnumerateCallback, lpContext); ret=(*pDirectDrawEnumerate)(lpCallback, lpContext); if(ret) OutTraceP("DirectDrawEnumerate: ERROR res=%x(%s)\n", ret, ExplainDDError(ret)); return ret; } HRESULT WINAPI extDirectDrawEnumerateExProxy(LPDDENUMCALLBACKEX lpCallback, LPVOID lpContext, DWORD dwFlags) { HRESULT ret; OutTraceP("DirectDrawEnumerateEx: PROXED lpCallback=%x lpContext=%x Flags=%x(%s)\n", lpCallback, lpContext, dxw.dwFlags1, ExplainDDEnumerateFlags(dwFlags)); (*pDirectDrawEnumerateEx)(DDEnumerateCallbackEx, lpContext, dwFlags); ret=(*pDirectDrawEnumerateEx)(lpCallback, lpContext, dwFlags); if(ret) OutTraceP("DirectDrawEnumerateEx: ERROR res=%x(%s)\n", ret, ExplainDDError(ret)); return ret; } // GDI calls proxy extern GDIGetDC_Type pGDIGetDC; //GDIGetDC_Type pGDIGetWinDC; extern GDIReleaseDC_Type pGDIReleaseDC; extern CreateDC_Type pGDICreateDC; extern CreateCompatibleDC_Type pGDICreateCompatibleDC; extern BitBlt_Type pGDIBitBlt; extern PatBlt_Type pGDIPatBlt; extern StretchBlt_Type pGDIStretchBlt; extern DeleteDC_Type pGDIDeleteDC; extern SaveDC_Type pSaveDC; extern RestoreDC_Type pRestoreDC; HDC WINAPI extGDIGetDCProxy(HWND hwnd) { HDC ret; ret=(*pGDIGetDC)(hwnd); OutTraceP("GDI.GetDC: PROXED hwnd=%x ret=%x\n", hwnd, ret); return ret; } HDC WINAPI extGetWindowDCProxy(HWND hwnd) { HDC ret; ret=(*pGDIGetWindowDC)(hwnd); OutTraceP("GDI.GetWindowDC: PROXED hwnd=%x ret=%x\n", hwnd, ret); return ret; } int WINAPI extGDIReleaseDCProxy(HWND hwnd, HDC hDC) { int res; OutTraceP("GDI.ReleaseDC: PROXED hwnd=%x hdc=%x\n", hwnd, hDC); res=(*pGDIReleaseDC)(hwnd, hDC); if (!res) OutTraceP("GDI.ReleaseDC ERROR: err=%d\n", GetLastError()); return(res); } HDC WINAPI extCreateDCProxy(LPSTR Driver, LPSTR Device, LPSTR Output, CONST DEVMODE *InitData) { HDC RetHDC; OutTraceP("GDI.CreateDC: PROXED Driver=%s Device=%s Output=%s InitData=%x\n", Driver?Driver:"(NULL)", Device?Device:"(NULL)", Output?Output:"(NULL)", InitData); RetHDC=(*pGDICreateDC)(Driver, Device, Output, InitData); if(RetHDC) OutTraceP("GDI.CreateDC: returning HDC=%x\n", RetHDC); else OutTraceP("GDI.CreateDC ERROR: err=%d\n", GetLastError()); return RetHDC; } HDC WINAPI extCreateCompatibleDCProxy(HDC hdc) { HDC RetHdc; OutTraceP("GDI.CreateCompatibleDC: PROXED hdc=%x\n", hdc); RetHdc=(*pGDICreateCompatibleDC)(hdc); if(RetHdc) OutTraceP("GDI.CreateCompatibleDC: returning HDC=%x\n", RetHdc); else OutTraceP("GDI.CreateCompatibleDC ERROR: err=%d\n", GetLastError()); return RetHdc; } BOOL WINAPI extBitBltProxy(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, DWORD dwRop) { BOOL res; OutTraceP("GDI.BitBlt: PROXED HDC=%x nXDest=%d nYDest=%d nWidth=%d nHeight=%d hdcSrc=%x nXSrc=%d nYSrc=%d dwRop=%x(%s)\n", hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, dwRop, ExplainROP(dwRop)); res=(*pGDIBitBlt)(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, dwRop); if(!res) OutTraceP("GDI.BitBlt: ERROR err=%d\n", GetLastError()); return res; } BOOL WINAPI extPatBltProxy(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, DWORD dwRop) { BOOL res; OutTraceP("GDI.PatBlt: PROXED HDC=%x nXDest=%d nYDest=%d nWidth=%d nHeight=%d dwRop=%x(%s)\n", hdcDest, nXDest, nYDest, nWidth, nHeight, dwRop, ExplainROP(dwRop)); res=(*pGDIPatBlt)(hdcDest, nXDest, nYDest, nWidth, nHeight, dwRop); if(!res) OutTraceP("GDI.PatBlt: ERROR err=%d\n", GetLastError()); return res; } BOOL WINAPI extStretchBltProxy(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, int nWSrc, int nHSrc, DWORD dwRop) { BOOL res; OutTraceP("GDI.StretchBlt: PROXED HDC=%x nXDest=%d nYDest=%d nWidth=%d nHeight=%d hdcSrc=%x nXSrc=%d nYSrc=%d nWSrc=%d nHSrc=%d dwRop=%x(%s)\n", hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, nWSrc, nHSrc, dwRop, ExplainROP(dwRop)); res=(*pGDIStretchBlt)(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, nWSrc, nHSrc, dwRop); if(!res) OutTraceP("GDI.StretchBlt: ERROR err=%d\n", GetLastError()); return res; } BOOL WINAPI extDeleteDCProxy(HDC hdc) { BOOL res; OutTraceP("GDI.DeleteDC: PROXED hdc=%x\n", hdc); res=(*pGDIDeleteDC)(hdc); if(!res) OutTraceP("GDI.DeleteDC: ERROR err=%d\n", GetLastError()); return res; } int WINAPI extSaveDCProxy(HDC hdc) { int ret; ret=(*pGDISaveDC)(hdc); OutTraceP("GDI.SaveDC: PROXED hdc=%x ret=%x\n", hdc, ret); return ret; } BOOL WINAPI extRestoreDCProxy(HDC hdc, int nSavedDC) { BOOL ret; ret=(*pGDIRestoreDC)(hdc, nSavedDC); OutTraceP("GDI.RestoreDC: PROXED hdc=%x nSavedDC=%x ret=%x\n", hdc, nSavedDC, ret); return ret; } HPALETTE WINAPI extSelectPaletteProxy(HDC hdc, HPALETTE hpal, BOOL bForceBackground) { HPALETTE ret; ret=(*pGDISelectPalette)(hdc, hpal, bForceBackground); OutTraceP("GDI.SelectPalette: PROXED hdc=%x hpal=%x ForceBackground=%x ret=%x\n", hdc, hpal, bForceBackground, ret); return ret; } UINT WINAPI extRealizePaletteProxy(HDC hdc) { UINT ret; ret=(*pGDIRealizePalette)(hdc); OutTraceP("GDI.RealizePalette: PROXED hdc=%x ret=%x\n", hdc, ret); return ret; } UINT WINAPI extGetSystemPaletteEntriesProxy(HDC hdc, UINT iStartIndex, UINT nEntries, LPPALETTEENTRY lppe) { UINT ret; ret=(*pGDIGetSystemPaletteEntries)(hdc, iStartIndex, nEntries, lppe); OutTrace("GDI.GetSystemPaletteEntries: PROXED hdc=%x start=%d num=%d ret=%d\n", hdc, iStartIndex, nEntries, ret); if(!ret) OutTrace("GDI.GetSystemPaletteEntries: ERROR err=%d\n", GetLastError()); return ret; } HDC WINAPI extBeginPaintProxy(HWND hwnd, LPPAINTSTRUCT lpPaint) { HDC ret; OutTraceP("GDI.BeginPaint: PROXED hwnd=%x lpPaint=%x\n", hwnd, lpPaint); ret=(*pBeginPaint)(hwnd, lpPaint); OutTraceP("GDI.BeginPaint: ret=%x\n", ret); return ret; }