From: José Fonseca Date: Fri, 23 Nov 2012 14:34:29 +0000 (+0000) Subject: dxgitrace: Merge tracing of all DXGI related APIs. X-Git-Url: https://git.cworth.org/git?p=apitrace;a=commitdiff_plain;h=20aa935d4c87e47040d2e75bf746fcf9d5d8d6b2 dxgitrace: Merge tracing of all DXGI related APIs. --- diff --git a/common/trace_tools_trace.cpp b/common/trace_tools_trace.cpp index 387e2e2..4c0082d 100644 --- a/common/trace_tools_trace.cpp +++ b/common/trace_tools_trace.cpp @@ -52,13 +52,83 @@ namespace trace { #endif +static inline bool +copyWrapper(const os::String & wrapperPath, + const char *programPath, + bool verbose) +{ + os::String wrapperFilename(wrapperPath); + wrapperFilename.trimDirectory(); + + os::String tmpWrapper(programPath); + tmpWrapper.trimFilename(); + tmpWrapper.join(wrapperFilename); + + if (verbose) { + std::cerr << wrapperPath << " -> " << tmpWrapper << "\n"; + } + + if (tmpWrapper.exists()) { + std::cerr << "error: not overwriting " << tmpWrapper << "\n"; + return false; + } + + if (!os::copyFile(wrapperPath, tmpWrapper, false)) { + std::cerr << "error: failed to copy " << wrapperPath << " into " << tmpWrapper << "\n"; + return false; + } + + return true; +} + + +static const char *glWrappers[] = { + GL_TRACE_WRAPPER, + NULL +}; + +#ifdef EGL_TRACE_WRAPPER +static const char *eglWrappers[] = { + EGL_TRACE_WRAPPER, + NULL +}; +#endif + +#ifdef _WIN32 +static const char *d3d7Wrappers[] = { + "ddraw.dll", + NULL +}; + +static const char *d3d8Wrappers[] = { + "d3d8.dll", + NULL +}; + +static const char *d3d9Wrappers[] = { + "d3d9.dll", + NULL +}; + +static const char *dxgiWrappers[] = { + "dxgitrace.dll", + //"dxgi.dll", + "d3d10.dll", + "d3d10_1.dll", + "d3d11.dll", + NULL +}; +#endif + int traceProgram(API api, char * const *argv, const char *output, bool verbose) { - const char *wrapperFilename; + const char **wrapperFilenames; + unsigned numWrappers; + int status = 1; /* * TODO: simplify code @@ -66,31 +136,27 @@ traceProgram(API api, switch (api) { case API_GL: - wrapperFilename = GL_TRACE_WRAPPER; + wrapperFilenames = glWrappers; break; #ifdef EGL_TRACE_WRAPPER case API_EGL: - wrapperFilename = EGL_TRACE_WRAPPER; + wrapperFilenames = eglWrappers; break; #endif #ifdef _WIN32 case API_D3D7: - wrapperFilename = "ddraw.dll"; + wrapperFilenames = d3d7Wrappers; break; case API_D3D8: - wrapperFilename = "d3d8.dll"; + wrapperFilenames = d3d8Wrappers; break; case API_D3D9: - wrapperFilename = "d3d9.dll"; + wrapperFilenames = d3d9Wrappers; break; case API_D3D10: - wrapperFilename = "d3d10.dll"; - break; case API_D3D10_1: - wrapperFilename = "d3d10_1.dll"; - break; case API_D3D11: - wrapperFilename = "d3d11.dll"; + wrapperFilenames = dxgiWrappers; break; #endif default: @@ -98,48 +164,45 @@ traceProgram(API api, return 1; } - os::String wrapperPath = findWrapper(wrapperFilename); - - if (!wrapperPath.length()) { - std::cerr << "error: failed to find " << wrapperFilename << "\n"; - return 1; + numWrappers = 0; + while (wrapperFilenames[numWrappers]) { + ++numWrappers; } -#if defined(_WIN32) - /* On Windows copy the wrapper to the program directory. - */ - os::String tmpWrapper(argv[0]); - tmpWrapper.trimFilename(); - tmpWrapper.join(wrapperFilename); + unsigned i; + for (i = 0; i < numWrappers; ++i) { + const char *wrapperFilename = wrapperFilenames[i]; - if (verbose) { - std::cerr << wrapperPath << " -> " << tmpWrapper << "\n"; - } + os::String wrapperPath = findWrapper(wrapperFilename); - if (tmpWrapper.exists()) { - std::cerr << "error: not overwriting " << tmpWrapper << "\n"; - return 1; - } + if (!wrapperPath.length()) { + std::cerr << "error: failed to find " << wrapperFilename << "\n"; + goto exit; + } - if (!os::copyFile(wrapperPath, tmpWrapper, false)) { - std::cerr << "error: failed to copy " << wrapperPath << " into " << tmpWrapper << "\n"; - return 1; - } +#if defined(_WIN32) + /* On Windows copy the wrapper to the program directory. + */ + if (!copyWrapper(wrapperPath, argv[0], verbose)) { + goto exit; + } #endif /* _WIN32 */ #if defined(__APPLE__) - /* On Mac OS X, using DYLD_LIBRARY_PATH, we actually set the - * directory, not the file. */ - wrapperPath.trimFilename(); + /* On Mac OS X, using DYLD_LIBRARY_PATH, we actually set the + * directory, not the file. */ + wrapperPath.trimFilename(); #endif #if defined(TRACE_VARIABLE) - if (verbose) { - std::cerr << TRACE_VARIABLE << "=" << wrapperPath.str() << "\n"; - } - /* FIXME: Don't modify the current environment */ - os::setEnvironment(TRACE_VARIABLE, wrapperPath.str()); + assert(numWrappers == 1); + if (verbose) { + std::cerr << TRACE_VARIABLE << "=" << wrapperPath.str() << "\n"; + } + /* FIXME: Don't modify the current environment */ + os::setEnvironment(TRACE_VARIABLE, wrapperPath.str()); #endif /* TRACE_VARIABLE */ + } if (output) { os::setEnvironment("TRACE_FILE", output); @@ -154,13 +217,20 @@ traceProgram(API api, std::cerr << "\n"; } - int status = os::execute(argv); + status = os::execute(argv); +exit: #if defined(TRACE_VARIABLE) os::unsetEnvironment(TRACE_VARIABLE); #endif #if defined(_WIN32) - os::removeFile(tmpWrapper); + for (unsigned j = 0; j < i; ++j) { + const char *wrapperFilename = wrapperFilenames[j]; + os::String tmpWrapper(argv[0]); + tmpWrapper.trimFilename(); + tmpWrapper.join(wrapperFilename); + os::removeFile(tmpWrapper); + } #endif if (output) { diff --git a/retrace/CMakeLists.txt b/retrace/CMakeLists.txt index 383417d..fd51c2d 100644 --- a/retrace/CMakeLists.txt +++ b/retrace/CMakeLists.txt @@ -148,10 +148,10 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) if (DirectX_D3D10_INCLUDE_DIR) include_directories (SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) - set (D3D10_MODULES d3d10) + set (DXGI_MODULES d3d10) if (DirectX_D3D10_1_INCLUDE_DIR) include_directories (SYSTEM ${DirectX_D3D10_1_INCLUDE_DIR}) - set (D3D10_MODULES ${D3D10_MODULES} d3d10_1) + set (DXGI_MODULES ${DXGI_MODULES} d3d10_1) endif () set (D3DSTATE_SOURCES ${D3DSTATE_SOURCES} d3d10state.cpp @@ -161,10 +161,10 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) if (DirectX_D3D11_INCLUDE_DIR) include_directories (SYSTEM ${DirectX_D3D11_INCLUDE_DIR}) - set (D3D10_MODULES ${D3D10_MODULES} d3d11) + set (DXGI_MODULES ${DXGI_MODULES} d3d11) if (DirectX_D3D11_1_INCLUDE_DIR) include_directories (SYSTEM ${DirectX_D3D11_1_INCLUDE_DIR}) - set (D3D10_MODULES ${D3D10_MODULES} d3d11_1) + set (DXGI_MODULES ${DXGI_MODULES} d3d11_1) endif () set (D3DSTATE_SOURCES ${D3DSTATE_SOURCES} d3d11state.cpp @@ -174,7 +174,7 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) add_custom_command ( OUTPUT d3dretrace_d3d10.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3dcommonretrace.py ${D3D10_MODULES} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d10.cpp + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3dcommonretrace.py ${DXGI_MODULES} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d10.cpp DEPENDS d3dcommonretrace.py dllretrace.py diff --git a/specs/d3d10.py b/specs/d3d10.py index 167e491..3f1a856 100644 --- a/specs/d3d10.py +++ b/specs/d3d10.py @@ -914,5 +914,5 @@ d3d10 = Module("d3d10") from d3d10sdklayers import * import d3d10misc -import d3d10shader -import d3d10effect +#import d3d10shader +#import d3d10effect diff --git a/specs/d3d10misc.py b/specs/d3d10misc.py index 2a3c55e..7ea8ef4 100644 --- a/specs/d3d10misc.py +++ b/specs/d3d10misc.py @@ -42,10 +42,6 @@ d3d10.addFunctions([ StdFunction(HRESULT, "D3D10CreateDevice", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (UINT, "SDKVersion"), Out(Pointer(ObjPointer(ID3D10Device)), "ppDevice")]), StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (UINT, "SDKVersion"), (Pointer(DXGI_SWAP_CHAIN_DESC), "pSwapChainDesc"), Out(Pointer(ObjPointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(ObjPointer(ID3D10Device)), "ppDevice")]), StdFunction(HRESULT, "D3D10CreateBlob", [(SIZE_T, "NumBytes"), Out(Pointer(LPD3D10BLOB), "ppBuffer")]), - - # Undocumented - StdFunction(DWORD, "D3D10GetVersion", [], internal=True), - StdFunction(DWORD, "D3D10RegisterLayers", [], internal=True), ]) d3d10.addInterfaces([ diff --git a/specs/d3d11.py b/specs/d3d11.py index 349349d..7d1e1d7 100644 --- a/specs/d3d11.py +++ b/specs/d3d11.py @@ -1218,12 +1218,6 @@ d3d11 = Module("d3d11") d3d11.addFunctions([ StdFunction(HRESULT, "D3D11CreateDevice", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D11_CREATE_DEVICE_FLAG, "Flags"), (Array(Const(D3D_FEATURE_LEVEL), "FeatureLevels"), "pFeatureLevels"), (UINT, "FeatureLevels"), (UINT, "SDKVersion"), Out(Pointer(ObjPointer(ID3D11Device)), "ppDevice"), Out(Pointer(D3D_FEATURE_LEVEL), "pFeatureLevel"), Out(Pointer(ObjPointer(ID3D11DeviceContext)), "ppImmediateContext")]), StdFunction(HRESULT, "D3D11CreateDeviceAndSwapChain", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D11_CREATE_DEVICE_FLAG, "Flags"), (Array(Const(D3D_FEATURE_LEVEL), "FeatureLevels"), "pFeatureLevels"), (UINT, "FeatureLevels"), (UINT, "SDKVersion"), (Pointer(Const(DXGI_SWAP_CHAIN_DESC)), "pSwapChainDesc"), Out(Pointer(ObjPointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(ObjPointer(ID3D11Device)), "ppDevice"), Out(Pointer(D3D_FEATURE_LEVEL), "pFeatureLevel"), Out(Pointer(ObjPointer(ID3D11DeviceContext)), "ppImmediateContext")]), - - # XXX: Undocumented functions, called by d3d11sdklayers.dll when D3D11_CREATE_DEVICE_DEBUG is set - StdFunction(HRESULT, "D3D11CoreRegisterLayers", [LPCVOID, DWORD], internal=True), - StdFunction(SIZE_T, "D3D11CoreGetLayeredDeviceSize", [LPCVOID, DWORD], internal=True), - StdFunction(HRESULT, "D3D11CoreCreateLayeredDevice", [LPCVOID, DWORD, LPCVOID, (REFIID, "riid"), Out(Pointer(ObjPointer(Void)), "ppvObj")], internal=True), - StdFunction(HRESULT, "D3D11CoreCreateDevice", [DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD], internal=True), ]) d3d11.addInterfaces([ diff --git a/wrappers/.gitignore b/wrappers/.gitignore index e124b5d..43ef5c8 100644 --- a/wrappers/.gitignore +++ b/wrappers/.gitignore @@ -1,11 +1,9 @@ OpenGL cgltrace.cpp d2d1trace.cpp -d3d10_1trace.cpp -d3d10trace.cpp -d3d11trace.cpp d3d8trace.cpp d3d9trace.cpp +dxgitrace.cpp ddrawtrace.cpp dlltrace.cpp egltrace.cpp diff --git a/wrappers/CMakeLists.txt b/wrappers/CMakeLists.txt index 2cdf458..be67bc0 100644 --- a/wrappers/CMakeLists.txt +++ b/wrappers/CMakeLists.txt @@ -122,18 +122,33 @@ if (WIN32) install (TARGETS d3d9trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) endif () - # d3d10.dll + # dxgi.dll, d3d10.dll, d3d10_1.dll, d3d11.dll + set (DXGI_MODULES) if (DirectX_D3D10_INCLUDE_DIR) include_directories (SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) + set (DXGI_MODULES d3d10) + if (DirectX_D3D10_1_INCLUDE_DIR) + include_directories (SYSTEM ${DirectX_D3D10_1_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d10_1) + endif () + if (DirectX_D3D11_INCLUDE_DIR) + include_directories (SYSTEM ${DirectX_D3D11_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d11) + if (DirectX_D3D11_1_INCLUDE_DIR) + include_directories (SYSTEM ${DirectX_D3D11_1_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d11_1) + endif () + endif () + add_custom_command ( - OUTPUT d3d10trace.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10trace.cpp + OUTPUT dxgitrace.cpp + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgitrace.py ${DXGI_MODULES} > ${CMAKE_CURRENT_BINARY_DIR}/dxgitrace.cpp DEPENDS - d3d10trace.py - d3dcommontrace.py + dxgitrace.py dlltrace.py trace.py ${CMAKE_SOURCE_DIR}/dispatch/dispatch.py + ${CMAKE_SOURCE_DIR}/specs/d3d10_1.py ${CMAKE_SOURCE_DIR}/specs/d3d10.py ${CMAKE_SOURCE_DIR}/specs/d3d10misc.py ${CMAKE_SOURCE_DIR}/specs/d3d10sdklayers.py @@ -146,107 +161,78 @@ if (WIN32) ${CMAKE_SOURCE_DIR}/specs/winapi.py ${CMAKE_SOURCE_DIR}/specs/stdapi.py ) - add_library (d3d10trace MODULE - d3d10.def - d3d10trace.cpp + add_library (dxgitrace SHARED + dxgitrace.def + dxgitrace.cpp d3dcommonshader.cpp ) - target_link_libraries (d3d10trace + target_link_libraries (dxgitrace common_trace common ${ZLIB_LIBRARIES} ${SNAPPY_LIBRARIES} ) - set_target_properties (d3d10trace PROPERTIES - PREFIX "" - OUTPUT_NAME d3d10 - ) - install (TARGETS d3d10trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) - endif () - - # d3d10_1.dll - if (DirectX_D3D10_1_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D10_1_INCLUDE_DIR}) - add_custom_command ( - OUTPUT d3d10_1trace.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10_1trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10_1trace.cpp - DEPENDS - d3d10_1trace.py - d3dcommontrace.py - dlltrace.py - trace.py - ${CMAKE_SOURCE_DIR}/dispatch/dispatch.py - ${CMAKE_SOURCE_DIR}/specs/d3d10_1.py - ${CMAKE_SOURCE_DIR}/specs/d3d10.py - ${CMAKE_SOURCE_DIR}/specs/d3d10sdklayers.py - ${CMAKE_SOURCE_DIR}/specs/d3dcommon.py - ${CMAKE_SOURCE_DIR}/specs/dxgi.py - ${CMAKE_SOURCE_DIR}/specs/dxgitype.py - ${CMAKE_SOURCE_DIR}/specs/dxgiformat.py - ${CMAKE_SOURCE_DIR}/specs/winapi.py - ${CMAKE_SOURCE_DIR}/specs/stdapi.py + set_target_properties (dxgitrace + PROPERTIES PREFIX "" ) - add_library (d3d10_1trace MODULE - d3d10_1.def - d3d10_1trace.cpp - d3dcommonshader.cpp + install (TARGETS dxgitrace + RUNTIME DESTINATION ${WRAPPER_INSTALL_DIR} COMPONENT RUNTIME + LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR} COMPONENT RUNTIME ) - target_link_libraries (d3d10_1trace - common_trace - common - ${ZLIB_LIBRARIES} - ${SNAPPY_LIBRARIES} + + # dxgi.dll (empty stub for dxgitrace.dll) + add_library (dxgistubs MODULE + dxgi.def + dxgistubs.cpp + d3dkmtstubs.cpp ) - set_target_properties (d3d10_1trace + target_link_libraries (dxgistubs dxgitrace) + set_target_properties (dxgistubs PROPERTIES PREFIX "" - OUTPUT_NAME d3d10_1 + OUTPUT_NAME dxgi ) - install (TARGETS d3d10_1trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) - endif () - - # d3d11.dll - if (DirectX_D3D11_INCLUDE_DIR) - if (DirectX_D3D11_1_INCLUDE_DIR) - set (HAVE_D3D11_1 1) - else () - set (HAVE_D3D11_1 0) - endif () + install (TARGETS dxgistubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) - include_directories (SYSTEM ${DirectX_D3D11_INCLUDE_DIR}) - add_custom_command ( - OUTPUT d3d11trace.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d11trace.py ${HAVE_D3D11_1} > ${CMAKE_CURRENT_BINARY_DIR}/d3d11trace.cpp - DEPENDS - d3d11trace.py - d3dcommontrace.py - dlltrace.py - trace.py - ${CMAKE_SOURCE_DIR}/specs/d3d11_1.py - ${CMAKE_SOURCE_DIR}/specs/d3d11.py - ${CMAKE_SOURCE_DIR}/specs/d3d11sdklayers.py - ${CMAKE_SOURCE_DIR}/specs/d3dcommon.py - ${CMAKE_SOURCE_DIR}/specs/dxgi.py - ${CMAKE_SOURCE_DIR}/specs/dxgitype.py - ${CMAKE_SOURCE_DIR}/specs/dxgiformat.py - ${CMAKE_SOURCE_DIR}/specs/winapi.py - ${CMAKE_SOURCE_DIR}/specs/stdapi.py - ) - add_library (d3d11trace MODULE - d3d11.def - d3d11trace.cpp - d3dcommonshader.cpp - ) - target_link_libraries (d3d11trace - common_trace - common - ${ZLIB_LIBRARIES} - ${SNAPPY_LIBRARIES} + # d3d10.dll (empty stub for dxgitrace.dll) + add_library (d3d10stubs MODULE + d3d10.def + d3d10stubs.cpp ) - set_target_properties (d3d11trace + target_link_libraries (d3d10stubs dxgitrace) + set_target_properties (d3d10stubs PROPERTIES PREFIX "" - OUTPUT_NAME d3d11 + OUTPUT_NAME d3d10 ) - install (TARGETS d3d11trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + install (TARGETS d3d10stubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + + # d3d10_1.dll (empty stub for dxgitrace.dll) + if (DirectX_D3D10_1_INCLUDE_DIR) + add_library (d3d10_1stubs MODULE + d3d10_1.def + d3d10stubs.cpp + ) + target_link_libraries (d3d10_1stubs dxgitrace) + set_target_properties (d3d10_1stubs + PROPERTIES PREFIX "" + OUTPUT_NAME d3d10_1 + ) + install (TARGETS d3d10_1stubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + endif () + + # d3d11.dll (empty stub for dxgitrace.dll) + if (DirectX_D3D11_INCLUDE_DIR) + add_library (d3d11stubs MODULE + d3d11.def + d3d11stubs.cpp + d3dkmtstubs.cpp + ) + target_link_libraries (d3d11stubs dxgitrace) + set_target_properties (d3d11stubs + PROPERTIES PREFIX "" + OUTPUT_NAME d3d11 + ) + install (TARGETS d3d11stubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + endif () endif () # d2d1.dll, dwrite.dll diff --git a/wrappers/d3d10.def b/wrappers/d3d10.def index 95dc4ef..4cf0f7d 100644 --- a/wrappers/d3d10.def +++ b/wrappers/d3d10.def @@ -29,6 +29,3 @@ EXPORTS D3D10StateBlockMaskGetSetting D3D10StateBlockMaskIntersect D3D10StateBlockMaskUnion - - CreateDXGIFactory - CreateDXGIFactory1 diff --git a/wrappers/d3d10_1.def b/wrappers/d3d10_1.def index 730cb0e..836827a 100644 --- a/wrappers/d3d10_1.def +++ b/wrappers/d3d10_1.def @@ -1,9 +1,32 @@ LIBRARY "d3d10_1" EXPORTS + D3D10CompileEffectFromMemory + D3D10CompileShader + D3D10CreateBlob D3D10CreateDevice1 D3D10CreateDeviceAndSwapChain1 - D3D10CreateBlob - - CreateDXGIFactory - CreateDXGIFactory1 + D3D10CreateEffectFromMemory + D3D10CreateEffectPoolFromMemory + D3D10CreateStateBlock + D3D10DisassembleEffect + D3D10DisassembleShader + D3D10GetGeometryShaderProfile + D3D10GetInputAndOutputSignatureBlob + D3D10GetInputSignatureBlob + D3D10GetOutputSignatureBlob + D3D10GetPixelShaderProfile + D3D10GetShaderDebugInfo + D3D10GetVersion + D3D10GetVertexShaderProfile + D3D10PreprocessShader + D3D10ReflectShader + D3D10RegisterLayers + D3D10StateBlockMaskDifference + D3D10StateBlockMaskDisableAll + D3D10StateBlockMaskDisableCapture + D3D10StateBlockMaskEnableAll + D3D10StateBlockMaskEnableCapture + D3D10StateBlockMaskGetSetting + D3D10StateBlockMaskIntersect + D3D10StateBlockMaskUnion diff --git a/wrappers/d3d10_1trace.py b/wrappers/d3d10_1trace.py deleted file mode 100644 index 08aa239..0000000 --- a/wrappers/d3d10_1trace.py +++ /dev/null @@ -1,48 +0,0 @@ -########################################################################## -# -# Copyright 2008-2009 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from d3dcommontrace import D3DCommonTracer -from specs.stdapi import API -from specs.dxgi import dxgi -from specs.d3d10_1 import d3d10_1 - - -if __name__ == '__main__': - print '#define INITGUID' - print - print '#include "trace_writer_local.hpp"' - print '#include "os.hpp"' - print - print '#include "d3d10_1imports.hpp"' - print '#include "d3dcommonshader.hpp"' - print '#include "d3d10size.hpp"' - print - - api = API() - api.addModule(dxgi) - api.addModule(d3d10_1) - tracer = D3DCommonTracer() - tracer.traceApi(api) diff --git a/wrappers/d3d10stubs.cpp b/wrappers/d3d10stubs.cpp new file mode 100644 index 0000000..7c28d28 --- /dev/null +++ b/wrappers/d3d10stubs.cpp @@ -0,0 +1,522 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + *Stubs for internal D3D10 functions. + */ + + +#include "os.hpp" + +#include "d3d10imports.hpp" + + +static HMODULE g_hD3D10Module = NULL; + + +static PROC +_getD3D10ProcAddress(LPCSTR lpProcName) { + if (!g_hD3D10Module) { + char szDll[MAX_PATH] = {0}; + if (!GetSystemDirectoryA(szDll, MAX_PATH)) { + return NULL; + } + strcat(szDll, "\\\\d3d10.dll"); + g_hD3D10Module = LoadLibraryA(szDll); + if (!g_hD3D10Module) { + return NULL; + } + } + return GetProcAddress(g_hD3D10Module, lpProcName); +} + + +#ifndef NDEBUG +#define LOG() os::log("%s\n", __FUNCTION__) +#else +#define LOG() +#endif + + +typedef HRESULT (WINAPI *PFN_D3D10COMPILESHADER)(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, const char *pFunctionName, const char *pProfile, UINT Flags, ID3D10Blob **ppShader, ID3D10Blob **ppErrorMsgs); +static PFN_D3D10COMPILESHADER _D3D10CompileShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CompileShader(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, const char *pFunctionName, const char *pProfile, UINT Flags, ID3D10Blob **ppShader, ID3D10Blob **ppErrorMsgs) { + const char *_name = "D3D10CompileShader"; + LOG(); + if (!_D3D10CompileShader_ptr) { + _D3D10CompileShader_ptr = (PFN_D3D10COMPILESHADER)_getD3D10ProcAddress(_name); + if (!_D3D10CompileShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CompileShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, pFunctionName, pProfile, Flags, ppShader, ppErrorMsgs); +} + +typedef HRESULT (WINAPI *PFN_D3D10DISASSEMBLESHADER)(const void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, const char *pComments, ID3D10Blob **ppDisassembly); +static PFN_D3D10DISASSEMBLESHADER _D3D10DisassembleShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10DisassembleShader(const void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, const char *pComments, ID3D10Blob **ppDisassembly) { + const char *_name = "D3D10DisassembleShader"; + LOG(); + if (!_D3D10DisassembleShader_ptr) { + _D3D10DisassembleShader_ptr = (PFN_D3D10DISASSEMBLESHADER)_getD3D10ProcAddress(_name); + if (!_D3D10DisassembleShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10DisassembleShader_ptr(pShader, BytecodeLength, EnableColorCode, pComments, ppDisassembly); +} + +typedef const char *(WINAPI *PFN_D3D10GETPIXELSHADERPROFILE)(ID3D10Device *pDevice); +static PFN_D3D10GETPIXELSHADERPROFILE _D3D10GetPixelShaderProfile_ptr = NULL; + +EXTERN_C const char *WINAPI +D3D10GetPixelShaderProfile(ID3D10Device *pDevice) { + const char *_name = "D3D10GetPixelShaderProfile"; + LOG(); + if (!_D3D10GetPixelShaderProfile_ptr) { + _D3D10GetPixelShaderProfile_ptr = (PFN_D3D10GETPIXELSHADERPROFILE)_getD3D10ProcAddress(_name); + if (!_D3D10GetPixelShaderProfile_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetPixelShaderProfile_ptr(pDevice); +} + +typedef const char *(WINAPI *PFN_D3D10GETVERTEXSHADERPROFILE)(ID3D10Device *pDevice); +static PFN_D3D10GETVERTEXSHADERPROFILE _D3D10GetVertexShaderProfile_ptr = NULL; + +EXTERN_C const char *WINAPI +D3D10GetVertexShaderProfile(ID3D10Device *pDevice) { + const char *_name = "D3D10GetVertexShaderProfile"; + LOG(); + if (!_D3D10GetVertexShaderProfile_ptr) { + _D3D10GetVertexShaderProfile_ptr = (PFN_D3D10GETVERTEXSHADERPROFILE)_getD3D10ProcAddress(_name); + if (!_D3D10GetVertexShaderProfile_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetVertexShaderProfile_ptr(pDevice); +} + +typedef const char *(WINAPI *PFN_D3D10GETGEOMETRYSHADERPROFILE)(ID3D10Device *pDevice); +static PFN_D3D10GETGEOMETRYSHADERPROFILE _D3D10GetGeometryShaderProfile_ptr = NULL; + +EXTERN_C const char *WINAPI +D3D10GetGeometryShaderProfile(ID3D10Device *pDevice) { + const char *_name = "D3D10GetGeometryShaderProfile"; + LOG(); + if (!_D3D10GetGeometryShaderProfile_ptr) { + _D3D10GetGeometryShaderProfile_ptr = (PFN_D3D10GETGEOMETRYSHADERPROFILE)_getD3D10ProcAddress(_name); + if (!_D3D10GetGeometryShaderProfile_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetGeometryShaderProfile_ptr(pDevice); +} + +typedef HRESULT (WINAPI *PFN_D3D10REFLECTSHADER)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector); +static PFN_D3D10REFLECTSHADER _D3D10ReflectShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10ReflectShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector) { + const char *_name = "D3D10ReflectShader"; + LOG(); + if (!_D3D10ReflectShader_ptr) { + _D3D10ReflectShader_ptr = (PFN_D3D10REFLECTSHADER)_getD3D10ProcAddress(_name); + if (!_D3D10ReflectShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10ReflectShader_ptr(pShaderBytecode, BytecodeLength, ppReflector); +} + +typedef HRESULT (WINAPI *PFN_D3D10PREPROCESSSHADER)(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, ID3D10Blob **ppShaderText, ID3D10Blob **ppErrorMsgs); +static PFN_D3D10PREPROCESSSHADER _D3D10PreprocessShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10PreprocessShader(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, ID3D10Blob **ppShaderText, ID3D10Blob **ppErrorMsgs) { + const char *_name = "D3D10PreprocessShader"; + LOG(); + if (!_D3D10PreprocessShader_ptr) { + _D3D10PreprocessShader_ptr = (PFN_D3D10PREPROCESSSHADER)_getD3D10ProcAddress(_name); + if (!_D3D10PreprocessShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10PreprocessShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, ppShaderText, ppErrorMsgs); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETINPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob); +static PFN_D3D10GETINPUTSIGNATUREBLOB _D3D10GetInputSignatureBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetInputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) { + const char *_name = "D3D10GetInputSignatureBlob"; + LOG(); + if (!_D3D10GetInputSignatureBlob_ptr) { + _D3D10GetInputSignatureBlob_ptr = (PFN_D3D10GETINPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10GetInputSignatureBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetInputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob); +static PFN_D3D10GETOUTPUTSIGNATUREBLOB _D3D10GetOutputSignatureBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) { + const char *_name = "D3D10GetOutputSignatureBlob"; + LOG(); + if (!_D3D10GetOutputSignatureBlob_ptr) { + _D3D10GetOutputSignatureBlob_ptr = (PFN_D3D10GETOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10GetOutputSignatureBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob); +static PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB _D3D10GetInputAndOutputSignatureBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetInputAndOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) { + const char *_name = "D3D10GetInputAndOutputSignatureBlob"; + LOG(); + if (!_D3D10GetInputAndOutputSignatureBlob_ptr) { + _D3D10GetInputAndOutputSignatureBlob_ptr = (PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10GetInputAndOutputSignatureBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetInputAndOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETSHADERDEBUGINFO)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo); +static PFN_D3D10GETSHADERDEBUGINFO _D3D10GetShaderDebugInfo_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetShaderDebugInfo(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo) { + const char *_name = "D3D10GetShaderDebugInfo"; + LOG(); + if (!_D3D10GetShaderDebugInfo_ptr) { + _D3D10GetShaderDebugInfo_ptr = (PFN_D3D10GETSHADERDEBUGINFO)_getD3D10ProcAddress(_name); + if (!_D3D10GetShaderDebugInfo_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetShaderDebugInfo_ptr(pShaderBytecode, BytecodeLength, ppDebugInfo); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKUNION)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult); +static PFN_D3D10STATEBLOCKMASKUNION _D3D10StateBlockMaskUnion_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskUnion(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) { + const char *_name = "D3D10StateBlockMaskUnion"; + LOG(); + if (!_D3D10StateBlockMaskUnion_ptr) { + _D3D10StateBlockMaskUnion_ptr = (PFN_D3D10STATEBLOCKMASKUNION)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskUnion_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskUnion_ptr(pA, pB, pResult); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKINTERSECT)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult); +static PFN_D3D10STATEBLOCKMASKINTERSECT _D3D10StateBlockMaskIntersect_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskIntersect(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) { + const char *_name = "D3D10StateBlockMaskIntersect"; + LOG(); + if (!_D3D10StateBlockMaskIntersect_ptr) { + _D3D10StateBlockMaskIntersect_ptr = (PFN_D3D10STATEBLOCKMASKINTERSECT)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskIntersect_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskIntersect_ptr(pA, pB, pResult); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDIFFERENCE)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult); +static PFN_D3D10STATEBLOCKMASKDIFFERENCE _D3D10StateBlockMaskDifference_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskDifference(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) { + const char *_name = "D3D10StateBlockMaskDifference"; + LOG(); + if (!_D3D10StateBlockMaskDifference_ptr) { + _D3D10StateBlockMaskDifference_ptr = (PFN_D3D10STATEBLOCKMASKDIFFERENCE)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskDifference_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskDifference_ptr(pA, pB, pResult); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKENABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength); +static PFN_D3D10STATEBLOCKMASKENABLECAPTURE _D3D10StateBlockMaskEnableCapture_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskEnableCapture(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength) { + const char *_name = "D3D10StateBlockMaskEnableCapture"; + LOG(); + if (!_D3D10StateBlockMaskEnableCapture_ptr) { + _D3D10StateBlockMaskEnableCapture_ptr = (PFN_D3D10STATEBLOCKMASKENABLECAPTURE)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskEnableCapture_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskEnableCapture_ptr(pMask, StateType, RangeStart, RangeLength); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDISABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength); +static PFN_D3D10STATEBLOCKMASKDISABLECAPTURE _D3D10StateBlockMaskDisableCapture_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskDisableCapture(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength) { + const char *_name = "D3D10StateBlockMaskDisableCapture"; + LOG(); + if (!_D3D10StateBlockMaskDisableCapture_ptr) { + _D3D10StateBlockMaskDisableCapture_ptr = (PFN_D3D10STATEBLOCKMASKDISABLECAPTURE)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskDisableCapture_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskDisableCapture_ptr(pMask, StateType, RangeStart, RangeLength); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKENABLEALL)(D3D10_STATE_BLOCK_MASK *pMask); +static PFN_D3D10STATEBLOCKMASKENABLEALL _D3D10StateBlockMaskEnableAll_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskEnableAll(D3D10_STATE_BLOCK_MASK *pMask) { + const char *_name = "D3D10StateBlockMaskEnableAll"; + LOG(); + if (!_D3D10StateBlockMaskEnableAll_ptr) { + _D3D10StateBlockMaskEnableAll_ptr = (PFN_D3D10STATEBLOCKMASKENABLEALL)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskEnableAll_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskEnableAll_ptr(pMask); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDISABLEALL)(D3D10_STATE_BLOCK_MASK *pMask); +static PFN_D3D10STATEBLOCKMASKDISABLEALL _D3D10StateBlockMaskDisableAll_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskDisableAll(D3D10_STATE_BLOCK_MASK *pMask) { + const char *_name = "D3D10StateBlockMaskDisableAll"; + LOG(); + if (!_D3D10StateBlockMaskDisableAll_ptr) { + _D3D10StateBlockMaskDisableAll_ptr = (PFN_D3D10STATEBLOCKMASKDISABLEALL)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskDisableAll_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskDisableAll_ptr(pMask); +} + +typedef BOOL (WINAPI *PFN_D3D10STATEBLOCKMASKGETSETTING)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT Entry); +static PFN_D3D10STATEBLOCKMASKGETSETTING _D3D10StateBlockMaskGetSetting_ptr = NULL; + +EXTERN_C BOOL WINAPI +D3D10StateBlockMaskGetSetting(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT Entry) { + const char *_name = "D3D10StateBlockMaskGetSetting"; + LOG(); + if (!_D3D10StateBlockMaskGetSetting_ptr) { + _D3D10StateBlockMaskGetSetting_ptr = (PFN_D3D10STATEBLOCKMASKGETSETTING)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskGetSetting_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskGetSetting_ptr(pMask, StateType, Entry); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATESTATEBLOCK)(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock); +static PFN_D3D10CREATESTATEBLOCK _D3D10CreateStateBlock_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateStateBlock(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock) { + const char *_name = "D3D10CreateStateBlock"; + LOG(); + if (!_D3D10CreateStateBlock_ptr) { + _D3D10CreateStateBlock_ptr = (PFN_D3D10CREATESTATEBLOCK)_getD3D10ProcAddress(_name); + if (!_D3D10CreateStateBlock_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateStateBlock_ptr(pDevice, pStateBlockMask, ppStateBlock); +} + +typedef HRESULT (WINAPI *PFN_D3D10COMPILEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, const char *pSrcFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, UINT HLSLFlags, UINT FXFlags, ID3D10Blob **ppCompiledEffect, ID3D10Blob **ppErrors); +static PFN_D3D10COMPILEEFFECTFROMMEMORY _D3D10CompileEffectFromMemory_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CompileEffectFromMemory(void *pData, SIZE_T DataLength, const char *pSrcFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, UINT HLSLFlags, UINT FXFlags, ID3D10Blob **ppCompiledEffect, ID3D10Blob **ppErrors) { + const char *_name = "D3D10CompileEffectFromMemory"; + LOG(); + if (!_D3D10CompileEffectFromMemory_ptr) { + _D3D10CompileEffectFromMemory_ptr = (PFN_D3D10COMPILEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name); + if (!_D3D10CompileEffectFromMemory_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CompileEffectFromMemory_ptr(pData, DataLength, pSrcFileName, pDefines, pInclude, HLSLFlags, FXFlags, ppCompiledEffect, ppErrors); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool *pEffectPool, ID3D10Effect **ppEffect); +static PFN_D3D10CREATEEFFECTFROMMEMORY _D3D10CreateEffectFromMemory_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateEffectFromMemory(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool *pEffectPool, ID3D10Effect **ppEffect) { + const char *_name = "D3D10CreateEffectFromMemory"; + LOG(); + if (!_D3D10CreateEffectFromMemory_ptr) { + _D3D10CreateEffectFromMemory_ptr = (PFN_D3D10CREATEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name); + if (!_D3D10CreateEffectFromMemory_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateEffectFromMemory_ptr(pData, DataLength, FXFlags, pDevice, pEffectPool, ppEffect); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool); +static PFN_D3D10CREATEEFFECTPOOLFROMMEMORY _D3D10CreateEffectPoolFromMemory_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateEffectPoolFromMemory(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool) { + const char *_name = "D3D10CreateEffectPoolFromMemory"; + LOG(); + if (!_D3D10CreateEffectPoolFromMemory_ptr) { + _D3D10CreateEffectPoolFromMemory_ptr = (PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)_getD3D10ProcAddress(_name); + if (!_D3D10CreateEffectPoolFromMemory_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateEffectPoolFromMemory_ptr(pData, DataLength, FXFlags, pDevice, ppEffectPool); +} + +typedef HRESULT (WINAPI *PFN_D3D10DISASSEMBLEEFFECT)(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly); +static PFN_D3D10DISASSEMBLEEFFECT _D3D10DisassembleEffect_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10DisassembleEffect(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly) { + const char *_name = "D3D10DisassembleEffect"; + LOG(); + if (!_D3D10DisassembleEffect_ptr) { + _D3D10DisassembleEffect_ptr = (PFN_D3D10DISASSEMBLEEFFECT)_getD3D10ProcAddress(_name); + if (!_D3D10DisassembleEffect_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10DisassembleEffect_ptr(pEffect, EnableColorCode, ppDisassembly); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATEBLOB)(SIZE_T NumBytes, ID3D10Blob **ppBuffer); +static PFN_D3D10CREATEBLOB _D3D10CreateBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateBlob(SIZE_T NumBytes, ID3D10Blob **ppBuffer) { + const char *_name = "D3D10CreateBlob"; + LOG(); + if (!_D3D10CreateBlob_ptr) { + _D3D10CreateBlob_ptr = (PFN_D3D10CREATEBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10CreateBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateBlob_ptr(NumBytes, ppBuffer); +} + +typedef DWORD (WINAPI *PFN_D3D10GETVERSION)(void); +static PFN_D3D10GETVERSION _D3D10GetVersion_ptr = NULL; + +EXTERN_C DWORD WINAPI +D3D10GetVersion(void) { + const char *_name = "D3D10GetVersion"; + LOG(); + if (!_D3D10GetVersion_ptr) { + _D3D10GetVersion_ptr = (PFN_D3D10GETVERSION)_getD3D10ProcAddress(_name); + if (!_D3D10GetVersion_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetVersion_ptr(); +} + +typedef DWORD (WINAPI *PFN_D3D10REGISTERLAYERS)(void); +static PFN_D3D10REGISTERLAYERS _D3D10RegisterLayers_ptr = NULL; + +EXTERN_C DWORD WINAPI +D3D10RegisterLayers(void) { + const char *_name = "D3D10RegisterLayers"; + LOG(); + if (!_D3D10RegisterLayers_ptr) { + _D3D10RegisterLayers_ptr = (PFN_D3D10REGISTERLAYERS)_getD3D10ProcAddress(_name); + if (!_D3D10RegisterLayers_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10RegisterLayers_ptr(); +} + diff --git a/wrappers/d3d10trace.py b/wrappers/d3d10trace.py deleted file mode 100644 index 1de1392..0000000 --- a/wrappers/d3d10trace.py +++ /dev/null @@ -1,48 +0,0 @@ -########################################################################## -# -# Copyright 2008-2009 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from d3dcommontrace import D3DCommonTracer -from specs.stdapi import API -from specs.dxgi import dxgi -from specs.d3d10misc import d3d10 - - -if __name__ == '__main__': - print '#define INITGUID' - print - print '#include "trace_writer_local.hpp"' - print '#include "os.hpp"' - print - print '#include "d3d10imports.hpp"' - print '#include "d3dcommonshader.hpp"' - print '#include "d3d10size.hpp"' - print - - api = API() - api.addModule(dxgi) - api.addModule(d3d10) - tracer = D3DCommonTracer() - tracer.traceApi(api) diff --git a/wrappers/d3d11.def b/wrappers/d3d11.def index a9d2d4b..af7ea8c 100644 --- a/wrappers/d3d11.def +++ b/wrappers/d3d11.def @@ -1,12 +1,44 @@ LIBRARY "d3d11" EXPORTS + D3DKMTDestroyAllocation + D3DKMTDestroyContext + D3DKMTDestroyDevice + D3DKMTDestroySynchronizationObject + D3DKMTQueryAdapterInfo + D3DKMTSetDisplayPrivateDriverFormat + D3DKMTSignalSynchronizationObject + D3DKMTUnlock + D3DKMTWaitForSynchronizationObject + OpenAdapter10 + OpenAdapter10_2 D3D11CoreCreateDevice D3D11CoreCreateLayeredDevice D3D11CoreGetLayeredDeviceSize D3D11CoreRegisterLayers D3D11CreateDevice D3D11CreateDeviceAndSwapChain - - CreateDXGIFactory - CreateDXGIFactory1 + D3DKMTCreateAllocation + D3DKMTCreateContext + D3DKMTCreateDevice + D3DKMTCreateSynchronizationObject + D3DKMTEscape + D3DKMTGetContextSchedulingPriority + D3DKMTGetDeviceState + D3DKMTGetDisplayModeList + D3DKMTGetMultisampleMethodList + D3DKMTGetRuntimeData + D3DKMTGetSharedPrimaryHandle + D3DKMTLock + D3DKMTOpenAdapterFromHdc + D3DKMTOpenResource + D3DKMTPresent + D3DKMTQueryAllocationResidency + D3DKMTQueryResourceInfo + D3DKMTRender + D3DKMTSetAllocationPriority + D3DKMTSetContextSchedulingPriority + D3DKMTSetDisplayMode + D3DKMTSetGammaRamp + D3DKMTSetVidPnSourceOwner + D3DKMTWaitForVerticalBlankEvent diff --git a/wrappers/d3d11stubs.cpp b/wrappers/d3d11stubs.cpp new file mode 100644 index 0000000..e5d9909 --- /dev/null +++ b/wrappers/d3d11stubs.cpp @@ -0,0 +1,121 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + *Stubs for internal D3D11 functions. + */ + + +#include "os.hpp" + +#include "d3d11imports.hpp" + + +static HMODULE g_hD3D11Module = NULL; + + +static PROC +_getD3D11ProcAddress(LPCSTR lpProcName) { + if (!g_hD3D11Module) { + char szDll[MAX_PATH] = {0}; + if (!GetSystemDirectoryA(szDll, MAX_PATH)) { + return NULL; + } + strcat(szDll, "\\\\d3d11.dll"); + g_hD3D11Module = LoadLibraryA(szDll); + if (!g_hD3D11Module) { + return NULL; + } + } + return GetProcAddress(g_hD3D11Module, lpProcName); +} + + +typedef HRESULT (WINAPI *PFN_D3D11COREREGISTERLAYERS)(const void *unknown0, DWORD unknown1); +static PFN_D3D11COREREGISTERLAYERS _D3D11CoreRegisterLayers_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D11CoreRegisterLayers(const void *unknown0, DWORD unknown1) { + const char *_name = "D3D11CoreRegisterLayers"; + if (!_D3D11CoreRegisterLayers_ptr) { + _D3D11CoreRegisterLayers_ptr = (PFN_D3D11COREREGISTERLAYERS)_getD3D11ProcAddress(_name); + if (!_D3D11CoreRegisterLayers_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreRegisterLayers_ptr(unknown0, unknown1); +} + +typedef SIZE_T (WINAPI *PFN_D3D11COREGETLAYEREDDEVICESIZE)(const void *unknown0, DWORD unknown1); +static PFN_D3D11COREGETLAYEREDDEVICESIZE _D3D11CoreGetLayeredDeviceSize_ptr = NULL; + +EXTERN_C SIZE_T WINAPI +D3D11CoreGetLayeredDeviceSize(const void *unknown0, DWORD unknown1) { + const char *_name = "D3D11CoreGetLayeredDeviceSize"; + if (!_D3D11CoreGetLayeredDeviceSize_ptr) { + _D3D11CoreGetLayeredDeviceSize_ptr = (PFN_D3D11COREGETLAYEREDDEVICESIZE)_getD3D11ProcAddress(_name); + if (!_D3D11CoreGetLayeredDeviceSize_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreGetLayeredDeviceSize_ptr(unknown0, unknown1); +} + +typedef HRESULT (WINAPI *PFN_D3D11CORECREATELAYEREDDEVICE)(const void *unknown0, DWORD unknown1, const void *unknown2, REFIID riid, void **ppvObj); +static PFN_D3D11CORECREATELAYEREDDEVICE _D3D11CoreCreateLayeredDevice_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D11CoreCreateLayeredDevice(const void *unknown0, DWORD unknown1, const void *unknown2, REFIID riid, void **ppvObj) { + const char *_name = "D3D11CoreCreateLayeredDevice"; + if (!_D3D11CoreCreateLayeredDevice_ptr) { + _D3D11CoreCreateLayeredDevice_ptr = (PFN_D3D11CORECREATELAYEREDDEVICE)_getD3D11ProcAddress(_name); + if (!_D3D11CoreCreateLayeredDevice_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreCreateLayeredDevice_ptr(unknown0, unknown1, unknown2, riid, ppvObj); +} + +typedef HRESULT (WINAPI *PFN_D3D11CORECREATEDEVICE)(DWORD unknown0, DWORD unknown1, DWORD unknown2, DWORD unknown3, DWORD unknown4, DWORD unknown5, DWORD unknown6, DWORD unknown7, DWORD unknown8); +static PFN_D3D11CORECREATEDEVICE _D3D11CoreCreateDevice_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D11CoreCreateDevice(DWORD unknown0, DWORD unknown1, DWORD unknown2, DWORD unknown3, DWORD unknown4, DWORD unknown5, DWORD unknown6, DWORD unknown7, DWORD unknown8) { + const char *_name = "D3D11CoreCreateDevice"; + if (!_D3D11CoreCreateDevice_ptr) { + _D3D11CoreCreateDevice_ptr = (PFN_D3D11CORECREATEDEVICE)_getD3D11ProcAddress(_name); + if (!_D3D11CoreCreateDevice_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreCreateDevice_ptr(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8); +} + + diff --git a/wrappers/d3d11trace.py b/wrappers/d3d11trace.py deleted file mode 100644 index d43f147..0000000 --- a/wrappers/d3d11trace.py +++ /dev/null @@ -1,57 +0,0 @@ -########################################################################## -# -# Copyright 2008-2012 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -import sys - -from d3dcommontrace import D3DCommonTracer -from specs.stdapi import API -from specs.dxgi import dxgi -from specs.d3d11 import d3d11 - - -if __name__ == '__main__': - print '#define INITGUID' - print - print '#include "trace_writer_local.hpp"' - print '#include "os.hpp"' - print - print '#include "d3d11imports.hpp"' - print - - if int(sys.argv[1]): - import specs.d3d11_1 - print '#include ' - print - - print '#include "d3dcommonshader.hpp"' - print '#include "d3d11size.hpp"' - print - - api = API() - api.addModule(dxgi) - api.addModule(d3d11) - tracer = D3DCommonTracer() - tracer.traceApi(api) diff --git a/wrappers/d3dcommontrace.py b/wrappers/d3dcommontrace.py deleted file mode 100644 index e0927cc..0000000 --- a/wrappers/d3dcommontrace.py +++ /dev/null @@ -1,70 +0,0 @@ -########################################################################## -# -# Copyright 2008-2009 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from dlltrace import DllTracer -from specs import stdapi - - -class D3DCommonTracer(DllTracer): - - def serializeArgValue(self, function, arg): - # Dump shaders as strings - if isinstance(arg.type, stdapi.Blob) and arg.name.startswith('pShaderBytecode'): - print ' DumpShader(trace::localWriter, %s, %s);' % (arg.name, arg.type.size) - return - - DllTracer.serializeArgValue(self, function, arg) - - def enumWrapperInterfaceVariables(self, interface): - variables = DllTracer.enumWrapperInterfaceVariables(self, interface) - - # Add additional members to track maps - if interface.getMethodByName('Map') is not None: - variables += [ - ('VOID *', '_pMappedData', '0'), - ('size_t', '_MappedSize', '0'), - ] - - return variables - - def implementWrapperInterfaceMethodBody(self, interface, base, method): - if method.name == 'Unmap': - print ' if (_MappedSize && _pMappedData) {' - self.emit_memcpy('_pMappedData', '_pMappedData', '_MappedSize') - print ' }' - - DllTracer.implementWrapperInterfaceMethodBody(self, interface, base, method) - - if method.name == 'Map': - # NOTE: recursive locks are explicitely forbidden - print ' if (SUCCEEDED(_result)) {' - print ' _getMapInfo(_this, %s, _pMappedData, _MappedSize);' % ', '.join(method.argNames()) - print ' } else {' - print ' _pMappedData = NULL;' - print ' _MappedSize = 0;' - print ' }' - - diff --git a/wrappers/d3dkmtstubs.cpp b/wrappers/d3dkmtstubs.cpp new file mode 100644 index 0000000..2d12587 --- /dev/null +++ b/wrappers/d3dkmtstubs.cpp @@ -0,0 +1,713 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + * Stubs for internal DXGI D3DKMT functions. + */ + + +#include +#include + + +#ifndef NTSTATUS +#define NTSTATUS LONG +#endif + +#ifndef STATUS_NOT_IMPLEMENTED +#define STATUS_NOT_IMPLEMENTED 0xC0000002 +#endif + +#define D3DKMT_CREATEALLOCATION void +#define D3DKMT_CREATEALLOCATION void +#define D3DKMT_QUERYRESOURCEINFO void +#define D3DKMT_OPENRESOURCE void +#define D3DKMT_OPENRESOURCE void +#define D3DKMT_DESTROYALLOCATION void +#define D3DKMT_SETALLOCATIONPRIORITY void +#define D3DKMT_QUERYALLOCATIONRESIDENCY void +#define D3DKMT_CREATEDEVICE void +#define D3DKMT_DESTROYDEVICE void +#define D3DKMT_CREATECONTEXT void +#define D3DKMT_DESTROYCONTEXT void +#define D3DKMT_CREATESYNCHRONIZATIONOBJECT void +#define D3DKMT_CREATESYNCHRONIZATIONOBJECT2 void +#define D3DKMT_OPENSYNCHRONIZATIONOBJECT void +#define D3DKMT_DESTROYSYNCHRONIZATIONOBJECT void +#define D3DKMT_WAITFORSYNCHRONIZATIONOBJECT void +#define D3DKMT_WAITFORSYNCHRONIZATIONOBJECT2 void +#define D3DKMT_SIGNALSYNCHRONIZATIONOBJECT void +#define D3DKMT_SIGNALSYNCHRONIZATIONOBJECT2 void +#define D3DKMT_LOCK void +#define D3DKMT_UNLOCK void +#define D3DKMT_GETDISPLAYMODELIST void +#define D3DKMT_SETDISPLAYMODE void +#define D3DKMT_GETMULTISAMPLEMETHODLIST void +#define D3DKMT_PRESENT void +#define D3DKMT_RENDER void +#define D3DKMT_GETRUNTIMEDATA void +#define D3DKMT_QUERYADAPTERINFO void +#define D3DKMT_OPENADAPTERFROMHDC void +#define D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME void +#define D3DKMT_OPENADAPTERFROMDEVICENAME void +#define D3DKMT_CLOSEADAPTER void +#define D3DKMT_GETSHAREDPRIMARYHANDLE void +#define D3DKMT_ESCAPE void +#define D3DKMT_SETVIDPNSOURCEOWNER void +#define D3DKMT_GETPRESENTHISTORY void +#define D3DKMT_HANDLE LONG +#define D3DKMT_CREATEOVERLAY void +#define D3DKMT_UPDATEOVERLAY void +#define D3DKMT_FLIPOVERLAY void +#define D3DKMT_DESTROYOVERLAY void +#define D3DKMT_WAITFORVERTICALBLANKEVENT void +#define D3DKMT_SETGAMMARAMP void +#define D3DKMT_GETDEVICESTATE void +#define D3DKMT_CREATEDCFROMMEMORY void +#define D3DKMT_DESTROYDCFROMMEMORY void +#define D3DKMT_SETCONTEXTSCHEDULINGPRIORITY void +#define D3DKMT_GETCONTEXTSCHEDULINGPRIORITY void +#define D3DKMT_SCHEDULINGPRIORITYCLASS INT +#define D3DKMT_GETSCANLINE void +#define D3DKMT_CHANGESURFACEPOINTER void +#define D3DKMT_SETQUEUEDLIMIT void +#define D3DKMT_POLLDISPLAYCHILDREN void +#define D3DKMT_INVALIDATEACTIVEVIDPN void +#define D3DKMT_CHECKOCCLUSION void +#define D3DKMT_WAITFORIDLE void +#define D3DKMT_CHECKMONITORPOWERSTATE void +#define D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP void +#define D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT void +#define D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION void +#define D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION void +#define D3DKMT_CREATEKEYEDMUTEX void +#define D3DKMT_OPENKEYEDMUTEX void +#define D3DKMT_DESTROYKEYEDMUTEX void +#define D3DKMT_ACQUIREKEYEDMUTEX void +#define D3DKMT_RELEASEKEYEDMUTEX void +#define D3DKMT_CONFIGURESHAREDRESOURCE void +#define D3DKMT_GETOVERLAYSTATE void +#define D3DKMT_CHECKSHAREDRESOURCEACCESS void + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateAllocation(D3DKMT_CREATEALLOCATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateAllocation2(D3DKMT_CREATEALLOCATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTQueryResourceInfo(D3DKMT_QUERYRESOURCEINFO *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenResource(D3DKMT_OPENRESOURCE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenResource2(D3DKMT_OPENRESOURCE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyAllocation(CONST D3DKMT_DESTROYALLOCATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetAllocationPriority(CONST D3DKMT_SETALLOCATIONPRIORITY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTQueryAllocationResidency(CONST D3DKMT_QUERYALLOCATIONRESIDENCY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateDevice(D3DKMT_CREATEDEVICE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyDevice(CONST D3DKMT_DESTROYDEVICE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateContext(D3DKMT_CREATECONTEXT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyContext(CONST D3DKMT_DESTROYCONTEXT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateSynchronizationObject(D3DKMT_CREATESYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateSynchronizationObject2(D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenSynchronizationObject(D3DKMT_OPENSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroySynchronizationObject(CONST D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForSynchronizationObject(CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForSynchronizationObject2(CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECT2 *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSignalSynchronizationObject(CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSignalSynchronizationObject2(CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT2 *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTLock(D3DKMT_LOCK *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTUnlock(CONST D3DKMT_UNLOCK *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetDisplayModeList(D3DKMT_GETDISPLAYMODELIST *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetDisplayMode(CONST D3DKMT_SETDISPLAYMODE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetMultisampleMethodList(D3DKMT_GETMULTISAMPLEMETHODLIST *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTPresent(CONST D3DKMT_PRESENT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTRender(D3DKMT_RENDER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetRuntimeData(CONST D3DKMT_GETRUNTIMEDATA *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTQueryAdapterInfo(CONST D3DKMT_QUERYADAPTERINFO *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenAdapterFromHdc(D3DKMT_OPENADAPTERFROMHDC *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenAdapterFromGdiDisplayName(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenAdapterFromDeviceName(D3DKMT_OPENADAPTERFROMDEVICENAME *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCloseAdapter(CONST D3DKMT_CLOSEADAPTER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetSharedPrimaryHandle(D3DKMT_GETSHAREDPRIMARYHANDLE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTEscape(CONST D3DKMT_ESCAPE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetVidPnSourceOwner(CONST D3DKMT_SETVIDPNSOURCEOWNER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetPresentHistory(D3DKMT_GETPRESENTHISTORY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetPresentQueueEvent(D3DKMT_HANDLE hAdapter, HANDLE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateOverlay(D3DKMT_CREATEOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTUpdateOverlay(CONST D3DKMT_UPDATEOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTFlipOverlay(CONST D3DKMT_FLIPOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyOverlay(CONST D3DKMT_DESTROYOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForVerticalBlankEvent(CONST D3DKMT_WAITFORVERTICALBLANKEVENT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetGammaRamp(CONST D3DKMT_SETGAMMARAMP *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetDeviceState(D3DKMT_GETDEVICESTATE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyDCFromMemory(CONST D3DKMT_DESTROYDCFROMMEMORY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetContextSchedulingPriority(CONST D3DKMT_SETCONTEXTSCHEDULINGPRIORITY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetContextSchedulingPriority(D3DKMT_GETCONTEXTSCHEDULINGPRIORITY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetProcessSchedulingPriorityClass(HANDLE hProcess, D3DKMT_SCHEDULINGPRIORITYCLASS Priority) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetProcessSchedulingPriorityClass(HANDLE hProcess, D3DKMT_SCHEDULINGPRIORITYCLASS *pPriority) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTReleaseProcessVidPnSourceOwners(HANDLE hProcess) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetScanLine(D3DKMT_GETSCANLINE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTChangeSurfacePointer(CONST D3DKMT_CHANGESURFACEPOINTER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetQueuedLimit(CONST D3DKMT_SETQUEUEDLIMIT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTPollDisplayChildren(CONST D3DKMT_POLLDISPLAYCHILDREN *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTInvalidateActiveVidPn(CONST D3DKMT_INVALIDATEACTIVEVIDPN *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckOcclusion(CONST D3DKMT_CHECKOCCLUSION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForIdle(CONST D3DKMT_WAITFORIDLE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckMonitorPowerState(CONST D3DKMT_CHECKMONITORPOWERSTATE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C BOOLEAN APIENTRY +D3DKMTCheckExclusiveOwnership(VOID) +{ + assert(0); + return FALSE; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckVidPnExclusiveOwnership(CONST D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetDisplayPrivateDriverFormat(CONST D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSharedPrimaryLockNotification(CONST D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSharedPrimaryUnLockNotification(CONST D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateKeyedMutex(D3DKMT_CREATEKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenKeyedMutex(D3DKMT_OPENKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyKeyedMutex(CONST D3DKMT_DESTROYKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTAcquireKeyedMutex(D3DKMT_ACQUIREKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTReleaseKeyedMutex(D3DKMT_RELEASEKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTConfigureSharedResource(CONST D3DKMT_CONFIGURESHAREDRESOURCE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetOverlayState(D3DKMT_GETOVERLAYSTATE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckSharedResourceAccess(CONST D3DKMT_CHECKSHAREDRESOURCEACCESS *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +#define D3D10DDIARG_OPENADAPTER void + +EXTERN_C HRESULT APIENTRY +OpenAdapter10(D3D10DDIARG_OPENADAPTER *pData) { + assert(0); + return E_NOTIMPL; +} + +EXTERN_C HRESULT APIENTRY +OpenAdapter10_2(D3D10DDIARG_OPENADAPTER *pData) { + assert(0); + return E_NOTIMPL; +} + diff --git a/wrappers/dxgi.def b/wrappers/dxgi.def new file mode 100644 index 0000000..db1db15 --- /dev/null +++ b/wrappers/dxgi.def @@ -0,0 +1,47 @@ +LIBRARY "dxgi" + +EXPORTS + D3DKMTCloseAdapter + D3DKMTDestroyAllocation + D3DKMTDestroyContext + D3DKMTDestroyDevice + D3DKMTDestroySynchronizationObject + D3DKMTQueryAdapterInfo + D3DKMTSetDisplayPrivateDriverFormat + D3DKMTSignalSynchronizationObject + D3DKMTUnlock + D3DKMTWaitForSynchronizationObject + DXGIDumpJournal + OpenAdapter10 + OpenAdapter10_2 + CreateDXGIFactory1 + CreateDXGIFactory + D3DKMTCreateAllocation + D3DKMTCreateContext + D3DKMTCreateDevice + D3DKMTCreateSynchronizationObject + D3DKMTEscape + D3DKMTGetContextSchedulingPriority + D3DKMTGetDeviceState + D3DKMTGetDisplayModeList + D3DKMTGetMultisampleMethodList + D3DKMTGetRuntimeData + D3DKMTGetSharedPrimaryHandle + D3DKMTLock + D3DKMTOpenAdapterFromHdc + D3DKMTOpenResource + D3DKMTPresent + D3DKMTQueryAllocationResidency + D3DKMTQueryResourceInfo + D3DKMTRender + D3DKMTSetAllocationPriority + D3DKMTSetContextSchedulingPriority + D3DKMTSetDisplayMode + D3DKMTSetGammaRamp + D3DKMTSetVidPnSourceOwner + D3DKMTWaitForVerticalBlankEvent + DXGID3D10CreateDevice + DXGID3D10CreateLayeredDevice + DXGID3D10GetLayeredDeviceSize + DXGID3D10RegisterLayers + DXGIReportAdapterConfiguration diff --git a/wrappers/dxgistubs.cpp b/wrappers/dxgistubs.cpp new file mode 100644 index 0000000..a4ff930 --- /dev/null +++ b/wrappers/dxgistubs.cpp @@ -0,0 +1,114 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + * Stubs for internal DXGI functions. + */ + + +#include + +#include "d3d10imports.hpp" + +#include "os.hpp" + + +static HMODULE g_hDXGIModule = NULL; + + +static PROC +_getDXGIProcAddress(LPCSTR lpProcName) { + if (!g_hDXGIModule) { + char szDll[MAX_PATH] = {0}; + if (!GetSystemDirectoryA(szDll, MAX_PATH)) { + return NULL; + } + strcat(szDll, "\\\\dxgi.dll"); + g_hDXGIModule = LoadLibraryA(szDll); + if (!g_hDXGIModule) { + return NULL; + } + } + return GetProcAddress(g_hDXGIModule, lpProcName); +} + + +#define STUB(_Ret, _Name, _ArgsDecl, _Args) \ + EXTERN_C _Ret WINAPI \ + _Name _ArgsDecl { \ + typedef _Ret (WINAPI *_PFN) _ArgsDecl; \ + static _PFN _pfn = NULL; \ + if (!_pfn) { \ + static const char *_name = #_Name; \ + _pfn = (_PFN)_getDXGIProcAddress(_name); \ + if (!_pfn) { \ + os::log("error: unavailable function %s\n", _name); \ + os::abort(); \ + } \ + } \ + return _pfn _Args; \ + } + + +STUB(HRESULT, DXGID3D10CreateDevice, + (HMODULE hModule, IDXGIFactory *pFactory, IDXGIAdapter *pAdapter, UINT Flags, void *unknown, void *ppDevice), + (hModule, pFactory, pAdapter, Flags, unknown, ppDevice) +) + +struct UNKNOWN { + BYTE unknown[20]; +}; + +STUB(HRESULT, DXGID3D10CreateLayeredDevice, + (UNKNOWN Unknown), + (Unknown) +) + +STUB(SIZE_T, DXGID3D10GetLayeredDeviceSize, + (const void *pLayers, UINT NumLayers), + (pLayers, NumLayers) +) + +STUB(HRESULT, DXGID3D10RegisterLayers, + (const void *pLayers, UINT NumLayers), + (pLayers, NumLayers) +) + +EXTERN_C HRESULT WINAPI +DXGIDumpJournal() +{ + assert(0); + return E_NOTIMPL; +} + +EXTERN_C HRESULT WINAPI +DXGIReportAdapterConfiguration() +{ + assert(0); + return E_NOTIMPL; +} + + diff --git a/wrappers/dxgitrace.def b/wrappers/dxgitrace.def new file mode 100644 index 0000000..102b659 --- /dev/null +++ b/wrappers/dxgitrace.def @@ -0,0 +1,12 @@ +EXPORTS + CreateDXGIFactory + CreateDXGIFactory1 + + D3D10CreateDevice + D3D10CreateDeviceAndSwapChain + + D3D10CreateDevice1 + D3D10CreateDeviceAndSwapChain1 + + D3D11CreateDevice + D3D11CreateDeviceAndSwapChain diff --git a/wrappers/dxgitrace.py b/wrappers/dxgitrace.py new file mode 100644 index 0000000..640f356 --- /dev/null +++ b/wrappers/dxgitrace.py @@ -0,0 +1,113 @@ +########################################################################## +# +# Copyright 2008-2009 VMware, Inc. +# All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +##########################################################################/ + + +import sys +from dlltrace import DllTracer +from specs import stdapi +from specs.stdapi import API +from specs.dxgi import dxgi +from specs.d3d10 import d3d10 +from specs.d3d10_1 import d3d10_1 +from specs.d3d11 import d3d11 + + +class D3DCommonTracer(DllTracer): + + def serializeArgValue(self, function, arg): + # Dump shaders as strings + if isinstance(arg.type, stdapi.Blob) and arg.name.startswith('pShaderBytecode'): + print ' DumpShader(trace::localWriter, %s, %s);' % (arg.name, arg.type.size) + return + + DllTracer.serializeArgValue(self, function, arg) + + def enumWrapperInterfaceVariables(self, interface): + variables = DllTracer.enumWrapperInterfaceVariables(self, interface) + + # Add additional members to track maps + if interface.getMethodByName('Map') is not None: + variables += [ + ('VOID *', '_pMappedData', '0'), + ('size_t', '_MappedSize', '0'), + ] + + return variables + + def implementWrapperInterfaceMethodBody(self, interface, base, method): + if method.name == 'Unmap': + print ' if (_MappedSize && _pMappedData) {' + self.emit_memcpy('_pMappedData', '_pMappedData', '_MappedSize') + print ' }' + + DllTracer.implementWrapperInterfaceMethodBody(self, interface, base, method) + + if method.name == 'Map': + # NOTE: recursive locks are explicitely forbidden + print ' if (SUCCEEDED(_result)) {' + print ' _getMapInfo(_this, %s, _pMappedData, _MappedSize);' % ', '.join(method.argNames()) + print ' } else {' + print ' _pMappedData = NULL;' + print ' _MappedSize = 0;' + print ' }' + + +if __name__ == '__main__': + print '#define INITGUID' + print + print '#include "trace_writer_local.hpp"' + print '#include "os.hpp"' + print + print '#include "d3dcommonshader.hpp"' + print + + moduleNames = sys.argv[1:] + + api = API() + + if moduleNames: + api.addModule(dxgi) + + if 'd3d10' in moduleNames: + if 'd3d10_1' in moduleNames: + print r'#include "d3d10_1imports.hpp"' + # D3D10CreateBlob is duplicated in d3d10 and d3d10_1 + d3d10_1.functions = [function for function in d3d10_1.functions if function.name != 'D3D10CreateBlob'] + api.addModule(d3d10_1) + else: + print r'#include "d3d10imports.hpp"' + print r'#include "d3d10size.hpp"' + api.addModule(d3d10) + + if 'd3d11' in moduleNames: + print r'#include "d3d11imports.hpp"' + if 'd3d11_1' in moduleNames: + print '#include ' + import specs.d3d11_1 + print r'#include "d3d11size.hpp"' + api.addModule(d3d11) + + tracer = D3DCommonTracer() + tracer.traceApi(api)