#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
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:
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);
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) {
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
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
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
from d3d10sdklayers import *
import d3d10misc
-import d3d10shader
-import d3d10effect
+#import d3d10shader
+#import d3d10effect
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([
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([
OpenGL
cgltrace.cpp
d2d1trace.cpp
-d3d10_1trace.cpp
-d3d10trace.cpp
-d3d11trace.cpp
d3d8trace.cpp
d3d9trace.cpp
+dxgitrace.cpp
ddrawtrace.cpp
dlltrace.cpp
egltrace.cpp
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
${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
D3D10StateBlockMaskGetSetting
D3D10StateBlockMaskIntersect
D3D10StateBlockMaskUnion
-
- CreateDXGIFactory
- CreateDXGIFactory1
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
+++ /dev/null
-##########################################################################
-#
-# 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)
--- /dev/null
+/**************************************************************************
+ *
+ * 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();
+}
+
+++ /dev/null
-##########################################################################
-#
-# 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)
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
--- /dev/null
+/**************************************************************************
+ *
+ * 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);
+}
+
+
+++ /dev/null
-##########################################################################
-#
-# 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 <d3d11_1.h>'
- print
-
- print '#include "d3dcommonshader.hpp"'
- print '#include "d3d11size.hpp"'
- print
-
- api = API()
- api.addModule(dxgi)
- api.addModule(d3d11)
- tracer = D3DCommonTracer()
- tracer.traceApi(api)
+++ /dev/null
-##########################################################################
-#
-# 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 ' }'
-
-
--- /dev/null
+/**************************************************************************
+ *
+ * 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 <assert.h>
+#include <windows.h>
+
+
+#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;
+}
+
--- /dev/null
+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
--- /dev/null
+/**************************************************************************
+ *
+ * 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 <assert.h>
+
+#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;
+}
+
+
--- /dev/null
+EXPORTS
+ CreateDXGIFactory
+ CreateDXGIFactory1
+
+ D3D10CreateDevice
+ D3D10CreateDeviceAndSwapChain
+
+ D3D10CreateDevice1
+ D3D10CreateDeviceAndSwapChain1
+
+ D3D11CreateDevice
+ D3D11CreateDeviceAndSwapChain
--- /dev/null
+##########################################################################
+#
+# 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 <d3d11_1.h>'
+ import specs.d3d11_1
+ print r'#include "d3d11size.hpp"'
+ api.addModule(d3d11)
+
+ tracer = D3DCommonTracer()
+ tracer.traceApi(api)
projects / apitrace / commitdiff