diff --git a/dlls/AcpHal/AcpHal.h b/dlls/AcpHal/AcpHal.h index 10ade2f..32c5b8a 100644 --- a/dlls/AcpHal/AcpHal.h +++ b/dlls/AcpHal/AcpHal.h @@ -1,10 +1,62 @@ #pragma once #include -struct ApuHeapState { -/* 0x0000 */ public: uint32_t bytesFree; -/* 0x0004 */ public: uint32_t bytesAllocated; -/* 0x0008 */ public: uint32_t bytesLost; -/* 0x000c */ public: uint32_t maximumBlockSizeAvailable; -/* 0x0010 */ public: uint32_t allocationCount; +#include "messages.h" + +struct ApuHeapState +{ + UINT32 bytesFree; // Size of all unallocated regions + UINT32 bytesAllocated; // Size of all allocated regions as visible to the title + UINT32 bytesLost; // Size of all memory lost to alignment requests and fragmented blocks too small to allocate + UINT32 maximumBlockSizeAvailable; // Largest block available (actual space available can be less due to alignment requirements) + UINT32 allocationCount; // Count all allocated blocks +}; + +enum ACP_COMMAND_TYPE +{ + ACP_COMMAND_TYPE_LOAD_SHAPE_FLOWGRAPH = 1, // Load a new flow graph and process it (data: ACP_COMMAND_LOAD_SHAPE_FLOWGRAPH) + ACP_COMMAND_TYPE_REGISTER_MESSAGE, // Registers for one or more messages (data: ACP_COMMAND_MESSAGE) + ACP_COMMAND_TYPE_UNREGISTER_MESSAGE, // Unregisters one or more messages (data: ACP_COMMAND_MESSAGE) + ACP_COMMAND_TYPE_START_FLOWGRAPH, // Start processing the flowgraph (data: none) + ACP_COMMAND_TYPE_ENABLE_XMA_CONTEXT, // Enables an XMA context (data: ACP_COMMAND_ENABLE_OR_DISABLE_XMA_CONTEXT) + ACP_COMMAND_TYPE_ENABLE_XMA_CONTEXTS, // Enables a block XMA of contexts (data: ACP_COMMAND_ENABLE_OR_DISABLE_XMA_CONTEXTS) + ACP_COMMAND_TYPE_DISABLE_XMA_CONTEXT, // Disables an XMA context (data: ACP_COMMAND_ENABLE_OR_DISABLE_XMA_CONTEXT) + ACP_COMMAND_TYPE_DISABLE_XMA_CONTEXTS, // Disables a block of XMA contexts (data: ACP_COMMAND_ENABLE_OR_DISABLE_XMA_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_SRC_CONTEXT, // Updates a SRC context (data: ACP_COMMAND_UPDATE_XMA_CONTEXT) + ACP_COMMAND_TYPE_UPDATE_EQCOMP_CONTEXT, // Updates an EQ/Comp context (data: ACP_COMMAND_UPDATE_EQCOMP_CONTEXT) + ACP_COMMAND_TYPE_UPDATE_FILTVOL_CONTEXT, // Updates a Filt/Vol context (data: ACP_COMMAND_UPDATE_FILTVOL_CONTEXT) + ACP_COMMAND_TYPE_UPDATE_DMA_CONTEXT, // Updates a DMA context (data: ACP_COMMAND_UPDATE_DMA_CONTEXT) + ACP_COMMAND_TYPE_UPDATE_PCM_CONTEXT, // Updates a PCM context (data: ACP_COMMAND_UPDATE_PCM_CONTEXT) + ACP_COMMAND_TYPE_UPDATE_XMA_CONTEXT, // Updates a XMA context (data: ACP_COMMAND_UPDATE_XMA_CONTEXT) + ACP_COMMAND_TYPE_INCREMENT_DMA_WRITE_POINTER, // Update a DMA write pointer (data: ACP_COMMAND_INCREMENT_DMA_POINTER) + ACP_COMMAND_TYPE_INCREMENT_DMA_READ_POINTER, // Updates a DMA read pointer (data: ACP_COMMAND_INCREMENT_PCM_WRITE_POINTER) + ACP_COMMAND_TYPE_INCREMENT_PCM_WRITE_POINTER, // Updates a PCM context write pointer (data: ACP_COMMAND_INCREMENT_XMA_WRITE_BUFFER_OFFSET_READ) + ACP_COMMAND_TYPE_INCREMENT_XMA_WRITE_BUFFER_OFFSET_READ, // Updates the read offset in an XMA context write buffer (data: ACP_COMMAND_INCREMENT_XMA_WRITE_BUFFER_OFFSET_READ) + ACP_COMMAND_TYPE_UPDATE_XMA_READ_BUFFER, // Updates a PCM context write pointer (data: ACP_COMMAND_UPDATE_XMA_READ_BUFFER) + ACP_COMMAND_TYPE_UPDATE_ALL_CONTEXTS, // Updates blocks of contexts (data: ACP_COMMAND_UPDATE_ALL_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_SRC_CONTEXTS, // Updates a block of SRC contexts (data: ACP_COMMAND_UPDATE_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_EQCOMP_CONTEXTS, // Updates a block of EQ/Comp contexts (data: ACP_COMMAND_UPDATE_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_FILTVOL_CONTEXTS, // Updates a block of Filt/Vol contexts (data: ACP_COMMAND_UPDATE_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_DMA_READ_CONTEXTS, // Updates a block of DMA read contexts (data: ACP_COMMAND_UPDATE_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_DMA_WRITE_CONTEXTS, // Updates a block of DMA write contexts (data: ACP_COMMAND_UPDATE_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_PCM_CONTEXTS, // Updates a block of PCM contexts (data: ACP_COMMAND_UPDATE_CONTEXTS) + ACP_COMMAND_TYPE_UPDATE_XMA_CONTEXTS, // Updates a block of XMA contexts (data: ACP_COMMAND_UPDATE_CONTEXTS) + + ACP_COMMAND_TYPE_COUNT = ACP_COMMAND_TYPE_UPDATE_XMA_CONTEXTS // Count of command types (not an actual command) +}; + +struct ACP_MESSAGE +{ + UINT32 type; // Message type + UINT32 droppedMessageCount; // Count of dropped messages prior to this message + UINT32 usec; // time when this message is constructed + union // Message data + { + ACP_MESSAGE_AUDIO_FRAME_START audioFrameStart; + ACP_MESSAGE_FLOWGRAPH_COMPLETED flowgraphCompleted; + ACP_MESSAGE_SHAPE_COMMAND_BLOCKED shapeCommandBlocked; + ACP_MESSAGE_COMMAND_COMPLETED commandCompleted; + ACP_MESSAGE_FLOWGRAPH_TERMINATED flowgraphTerminated; + ACP_MESSAGE_ERROR error; + }; }; \ No newline at end of file diff --git a/dlls/AcpHal/AcpHal.vcxproj b/dlls/AcpHal/AcpHal.vcxproj index b8592b3..07b11a6 100644 --- a/dlls/AcpHal/AcpHal.vcxproj +++ b/dlls/AcpHal/AcpHal.vcxproj @@ -146,7 +146,9 @@ + + diff --git a/dlls/AcpHal/AcpHal.vcxproj.filters b/dlls/AcpHal/AcpHal.vcxproj.filters index 618a4c3..07c7d73 100644 --- a/dlls/AcpHal/AcpHal.vcxproj.filters +++ b/dlls/AcpHal/AcpHal.vcxproj.filters @@ -24,6 +24,12 @@ Source Files + + Header Files + + + Header Files + diff --git a/dlls/AcpHal/contexts.h b/dlls/AcpHal/contexts.h new file mode 100644 index 0000000..7981948 --- /dev/null +++ b/dlls/AcpHal/contexts.h @@ -0,0 +1,209 @@ +#pragma once + +struct SHAPE_EQCOMP_CONTEXT { + UINT32 timestamp : 21; + UINT32 reserved0 : 2; + UINT32 internalSaturate : 1; + UINT32 mixBufPeakMag : 4; + UINT32 peakMag : 4; + UINT32 eqAB0 : 24; + UINT32 eqAB1_L : 8; + UINT32 eqAB1_H : 16; + UINT32 eqAB2_L : 16; + UINT32 eqAB2_H : 8; + UINT32 eqAA1 : 24; + UINT32 eqAA2 : 24; + UINT32 eqBB0_L : 8; + UINT32 eqBB0_H : 16; + UINT32 eqBB1_L : 16; + UINT32 eqBB1_H : 8; + UINT32 eqBB2 : 24; + UINT32 eqBA1 : 24; + UINT32 eqBA2_L : 8; + UINT32 eqBA2_H : 16; + UINT32 eqCB0_L : 16; + UINT32 eqCB0_H : 8; + UINT32 eqCB1 : 24; + UINT32 eqCB2 : 24; + UINT32 eqCA1_L : 8; + UINT32 eqCA1_H : 16; + UINT32 eqCA2_L : 16; + UINT32 eqCA2_H : 8; + UINT32 reserved1 : 24; + UINT32 eqAInputDelay0 : 24; + UINT32 reserved2 : 8; + UINT32 eqAInputDelay1 : 24; + UINT32 reserved3 : 8; + UINT32 eqDelayElements2 : 32; + UINT32 eqDelayElements3 : 32; + UINT32 eqDelayElements4 : 32; + UINT32 eqDelayElements5 : 32; + UINT32 eqDelayElements6 : 32; + UINT32 eqDelayElements7 : 32; + UINT32 compInputLevel : 32; + UINT32 compGainReduction : 24; + UINT32 reserved4 : 8; + UINT32 compGain : 16; + UINT32 reserved5 : 16; + UINT32 eqAB0Target : 24; + UINT32 eqAB1Target_L : 8; + UINT32 eqAB1Target_H : 16; + UINT32 eqAB2Target_L : 16; + UINT32 eqAB2Target_H : 8; + UINT32 eqAA1Target : 24; + UINT32 eqAA2Target : 24; + UINT32 eqBB0Target_L : 8; + UINT32 eqBB0Target_H : 16; + UINT32 eqBB1Target_L : 16; + UINT32 eqBB1Target_H : 8; + UINT32 eqBB2Target : 24; + UINT32 eqBA1Target : 24; + UINT32 eqBA2Target_L : 8; + UINT32 eqBA2Target_H : 16; + UINT32 eqCB0Target_L : 16; + UINT32 eqCB0Target_H : 8; + UINT32 eqCB1Target : 24; + UINT32 eqCB2Target : 24; + UINT32 eqCA1Target_L : 8; + UINT32 eqCA1Target_H : 16; + UINT32 eqCA2Target_L : 16; + UINT32 eqCA2Target_H : 8; + UINT32 reserved6 : 24; + UINT32 compRelease : 24; + UINT32 reserved7 : 2; + UINT32 compExpand : 1; + UINT32 compLogGain : 1; + UINT32 compSidechainMode : 2; + UINT32 compMode : 1; + UINT32 compEnable : 1; + UINT32 compThreshold : 24; + UINT32 reserved8 : 8; + UINT32 compAttack : 24; + UINT32 reserved9 : 8; + UINT32 compOneOverRatio : 16; + UINT32 compGainTarget : 16; +}; + +struct SHAPE_SRC_CONTEXT { + UINT32 timestamp : 21; + UINT32 blocksToSkip : 2; + UINT32 internalSaturate : 1; + UINT32 mixBufPeakMag : 4; + UINT32 peakMag : 4; + UINT32 samplingIncrement : 21; + UINT32 reserved0 : 1; + UINT32 cmd : 2; + UINT32 mixBufPeakMag2 : 4; + UINT32 peakMag2 : 4; + UINT32 sampleCount : 32; + UINT32 samplePointer : 25; + UINT32 reserved1 : 7; + UINT32 samplingIncrementTarget : 21; + UINT32 reserved2 : 11; + UINT32 reserved3[ 3 ]; +}; + +struct SHAPE_FILTVOL_CONTEXT { + UINT32 timestamp : 21; + UINT32 reserved0 : 2; + UINT32 internalSaturate : 1; + UINT32 mixBufPeakMag : 4; + UINT32 peakMag : 4; + UINT32 delay1 : 30; + UINT32 headroom : 2; + UINT32 delay2 : 30; + UINT32 svfMode : 2; + UINT32 gainTarget : 16; + UINT32 gain : 16; + UINT32 qRecip : 24; + UINT32 reserved1 : 8; + UINT32 qRecipTarget : 24; + UINT32 reserved2 : 8; + UINT32 fc : 24; + UINT32 reserved3 : 8; + UINT32 fcTarget : 24; + UINT32 reserved4 : 8; +}; + +struct SHAPE_DMA_CONTEXT { + UINT32 timestamp : 21; + UINT32 reserved0 : 3; + UINT32 mixBufPeakMag : 4; + UINT32 peakMag : 4; + UINT32 readPointer : 5; + UINT32 reserved1 : 3; + UINT32 writePointer : 5; + UINT32 reserved2 : 3; + UINT32 full : 1; + UINT32 reserved3 : 15; + UINT32 reserved4 : 9; + UINT32 address : 23; + UINT32 numFrames : 5; + UINT32 reserved5 : 3; + UINT32 floatConvert : 1; + UINT32 reserved6 : 7; + UINT32 numChannels : 3; + UINT32 reserved7 : 5; + UINT32 channel : 3; + UINT32 reserved8 : 5; +}; + +struct SHAPE_XMA_CONTEXT { + UINT32 sizeRead0 : 12; + UINT32 numLoops : 8; + UINT32 validBuffer : 2; + UINT32 sizeWrite : 5; + UINT32 offsetWrite : 5; + UINT32 sizeRead1 : 12; + UINT32 loopSubframeEnd : 2; + UINT32 reserved1 : 3; + UINT32 loopSubframeSkip : 3; + UINT32 numSubframeToDecode : 4; + UINT32 numSubframesToSkip : 3; + UINT32 sampleRate : 2; + UINT32 numChannels : 1; + UINT32 reserved2 : 1; + UINT32 validWrite : 1; + UINT32 offsetRead : 26; + UINT32 errorStatus : 5; + UINT32 errorSet : 1; + UINT32 loopStartOffset : 26; + UINT32 parserErrorStatus : 5; + UINT32 parserErrorSet : 1; + UINT32 loopEndOffset : 26; + UINT32 packetMetaData : 5; + UINT32 currentBuffer : 1; + UINT32 ptrRead0; + UINT32 ptrRead1; + UINT32 ptrWrite; + UINT32 ptrOverlapAdd; + UINT32 writeBufferOffsetRead : 5; + UINT32 reserved3 : 25; + UINT32 stopWhenDone : 1; + UINT32 interruptWhenDone : 1; + UINT32 reserved4[ 2 ]; + UINT32 reserved5[ 1 ]; +}; + +struct SHAPE_PCM_CONTEXT { + UINT32 bufferStart : 32; + UINT32 bufferLength : 21; + UINT32 reserved0 : 11; + UINT32 loopCount : 8; + UINT32 reserved1 : 8; + UINT32 full : 1; + UINT32 reserved2 : 15; + UINT32 readPointer : 21; + UINT32 reserved3 : 11; + UINT32 loopStartWritePointer : 21; + UINT32 reserved4 : 11; + UINT32 loopEnd : 21; + UINT32 reserved5 : 11; + UINT32 mode : 1; + UINT32 reserved6 : 15; + UINT32 format : 2; + UINT32 reserved7 : 14; + UINT32 reserved8; +}; + + diff --git a/dlls/AcpHal/messages.h b/dlls/AcpHal/messages.h new file mode 100644 index 0000000..1d1e002 --- /dev/null +++ b/dlls/AcpHal/messages.h @@ -0,0 +1,82 @@ +#pragma once +typedef UINT32 APU_ADDRESS; + +struct ACP_MESSAGE_AUDIO_FRAME_START +{ + UINT32 audioFrame; // Audio frame index +}; + +// Flowgraph completed message +// Used by the following messages: +// ACP_MESSAGE_TYPE_FLOWGRAPH_COMPLETED +struct ACP_MESSAGE_FLOWGRAPH_COMPLETED +{ + APU_ADDRESS flowgraph; // Flowgraph that completed +}; + +// SHAPE command is blocked +// Used by the following messages: +// ACP_MESSAGE_TYPE_SRC_BLOCKED +// ACP_MESSAGE_TYPE_DMA_BLOCKED +struct ACP_MESSAGE_SHAPE_COMMAND_BLOCKED +{ + UINT32 contextIndex; // Index of context that was blocked + APU_ADDRESS flowgraph; // Flowgraph with blocked context +}; + +// An ACP command has completed +// +// Command completed messages will only be sent for commands submitted with a non-zero commandId. +// (see IAcpHal::SubmitCommand) +// Used by the following messages: +// ACP_MESSAGE_TYPE_COMMAND_COMPLETED +struct ACP_MESSAGE_COMMAND_COMPLETED +{ + UINT32 commandType; // Command type that completed + UINT64 commandId; // Command ID of completed command + UINT32 audioFrame; // Audio frame when command completed +}; + +// Flowgraph was terminated +// Used by the following messages: +// ACP_MESSAGE_TYPE_FLOWGRAPH_TERMINATED +struct ACP_MESSAGE_FLOWGRAPH_TERMINATED +{ + APU_ADDRESS flowgraph; // Flowgraph + UINT32 numCommandsCompleted; // Number of flowgraph commands completed or queued before time ran out + UINT32 reason; // Reason the flowgraph was terminated +}; + +// Error message +// Used by the following messages: +// ACP_MESSAGE_TYPE_ERROR +// +// errorCode additionalData +// ----------------------------------- ------------------------------------------ +// ACP_E_INVALID_FLOWGRAPH Flowgraph APU_ADDRESS +// The specified flowgraph is invalid. Examine the flowgraph entry headers. +// Invalid entries will have the error bit set. +// +// ACP_E_INVALID_COMMAND 'commandId' from IAcpHal::SubmitCommand() +// The command submitted is invalid. +// +// ACP_E_MESSAGE_ALREADY_REGISTERED ACP_MESSAGE_TYPE_* +// An attempt was made to register for a message type that has already been registered. +// +// ACP_E_MESSAGE_NOT_REGISTERED ACP_MESSAGE_TYPE_* +// An attempt was made to unregister a message type that has not been registered. +// +// ACP_E_INVALID_COMMAND_TYPE ACP_COMMAND_TYPE_* +// A submitted command is not of a valid type. +// +// ACP_E_NOT_ALLOCATED 'commandId' from IAcpHal::SubmitCommand() +// A request was made to update a SHAPE flowgraph context that has not been allocated. +// +// ACP_E_XMA_PARSER_ERROR XMA context index +// The specified XMA context generated a parser error. +// +struct ACP_MESSAGE_ERROR +{ + HRESULT errorCode; // Error code + UINT32 additionalData; // Additional data relevant to the error +}; \ No newline at end of file diff --git a/dlls/d3d11_x/d3d11_x.cpp b/dlls/d3d11_x/d3d11_x.cpp index cad62cd..6be8b64 100644 --- a/dlls/d3d11_x/d3d11_x.cpp +++ b/dlls/d3d11_x/d3d11_x.cpp @@ -162,7 +162,7 @@ HRESULT __stdcall D3D11CreateDevice_X( ID3D11DeviceContext2* device_context2{}; auto flags = Flags & CREATE_DEVICE_FLAG_MASK; #ifdef _DEBUG - //flags |= D3D11_CREATE_DEVICE_DEBUG; + flags |= D3D11_CREATE_DEVICE_DEBUG; #endif HRESULT hr = D3D11CreateDevice(pAdapter, DriverType, Software, flags, featurelevels, _ARRAYSIZE(featurelevels), SDKVersion, (ID3D11Device**)ppDevice, pFeatureLevel, (ID3D11DeviceContext**)ppImmediateContext); diff --git a/dlls/d3d11_x/d3d11_x.h b/dlls/d3d11_x/d3d11_x.h index f9c183b..63752e9 100644 --- a/dlls/d3d11_x/d3d11_x.h +++ b/dlls/d3d11_x/d3d11_x.h @@ -131,19 +131,32 @@ DEFINE_GUID(DXGI_DEBUG_D3D11, 0x4b99317b, 0xac39, 0x4aa6, 0xbb, 0xb, 0xba, 0xa0, Guid5, Guid6, Guid7, Guid8, Guid9, Guid10) \ class D3DDECL_UUID(Guid0-Guid1-Guid2-Guid3##Guid4-Guid5##Guid6##Guid7##Guid8##Guid9##Guid10) Name -#define WD_WRAP(func_name, ...) \ - virtual auto func_name(__VA_ARGS__) -> decltype(wrapped_interface->func_name(__VA_ARGS__)) override { \ - return wrapped_interface->func_name(__VA_ARGS__); \ - } +#define TRACE_INTERFACE_NOT_HANDLED(class_name) \ + char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ]; \ + OLECHAR iidwstr[ sizeof(iidstr) ]; \ + StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr)); \ + WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr); \ + MessageBoxA(NULL, std::format("[{}] INTERFACE NOT HANDLED: {}", class_name, iidstr).c_str(), "WD - d3d11_x", MB_OK) \ -#define WD_STUB(return_type, func_name, args) \ - return_type func_name args override { \ - return return_type(); \ - } +#define IGU_DEFINE_REF \ + ULONG AddRef( ) override { \ + wrapped_interface->AddRef( ); \ + return InterlockedIncrement(&m_RefCount); \ + } \ + \ + ULONG Release( ) override { \ + ULONG refCount = InterlockedDecrement(&m_RefCount); \ + wrapped_interface->Release( ); \ + \ + if (refCount == 0) \ + { \ + wrapped_interface->Release( ); \ + delete this; \ + } \ + \ + return refCount; \ + } \ -#define WD_STUB_VOID(func_name, args, arg_names) \ - void func_name args override { \ - return; \ - } +#define assertm(exp, msg) assert((void(msg), exp)) #endif \ No newline at end of file diff --git a/dlls/d3d11_x/device_child_x.h b/dlls/d3d11_x/device_child_x.h index 28a37fa..74be716 100644 --- a/dlls/d3d11_x/device_child_x.h +++ b/dlls/d3d11_x/device_child_x.h @@ -1,4 +1,5 @@ #pragma once +#include #include #include "d3d11_x.h" @@ -49,7 +50,7 @@ namespace wd HRESULT STDMETHODCALLTYPE SetPrivateDataInterfaceGraphics(REFGUID guid, const IGraphicsUnknown* pData) override { - throw std::exception(__func__); + assert( false && "Not implemented" ); } private: diff --git a/dlls/d3d11_x/device_context_x.h b/dlls/d3d11_x/device_context_x.h index 8a0d159..9f0c071 100644 --- a/dlls/d3d11_x/device_context_x.h +++ b/dlls/d3d11_x/device_context_x.h @@ -610,6 +610,29 @@ namespace wd function_table[ i ] = v_ptr[ i ]; } + IGU_DEFINE_REF + + HRESULT QueryInterface(const IID& riid, void** ppvObject) override + { + if (riid == __uuidof(wdi::ID3D11DeviceContext) || riid == __uuidof(wdi::ID3D11DeviceContext1) || + riid == __uuidof(wdi::ID3D11DeviceContext2) || riid == __uuidof(wdi::ID3D11DeviceContextX)) + { + *ppvObject = this; + AddRef( ); + return S_OK; + } + + if (riid == __uuidof(wdi::IGraphicsUnwrap)) + { + *ppvObject = wrapped_interface; + return S_OK; + } + + TRACE_INTERFACE_NOT_HANDLED("device_context_x"); + *ppvObject = nullptr; + return E_NOINTERFACE; + } + void GetDevice(ID3D11Device** ppDevice) override; HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override; HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override; diff --git a/dlls/d3d11_x/device_x.h b/dlls/d3d11_x/device_x.h index 28e2f81..a3b3164 100644 --- a/dlls/d3d11_x/device_x.h +++ b/dlls/d3d11_x/device_x.h @@ -1,8 +1,10 @@ #pragma once +#include #include #include #include "graphics_unknown.h" #include +#include namespace wdi { @@ -251,270 +253,296 @@ namespace wdi namespace wd { - class device_x : wdi::ID3D11DeviceX + class device_x : public wdi::ID3D11DeviceX { public: device_x(::ID3D11Device2* device) : wrapped_interface(device) { wrapped_interface->AddRef(); } - virtual HRESULT CreateBuffer(const D3D11_BUFFER_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Buffer** ppBuffer) override + IGU_DEFINE_REF + + HRESULT QueryInterface(REFIID riid, void** ppvObject) override + { + if (ppvObject == nullptr) { + return E_POINTER; + } + + if (riid == __uuidof(wdi::ID3D11DeviceX) || riid == __uuidof(wdi::ID3D11Device) || riid == __uuidof(wdi::ID3D11Device1) || riid == __uuidof(wdi::ID3D11Device2)) + { + *ppvObject = static_cast(this); + AddRef( ); + return S_OK; + } + + if (riid == __uuidof(wdi::IGraphicsUnwrap)) + { + *ppvObject = wrapped_interface; + return S_OK; + } + + TRACE_INTERFACE_NOT_HANDLED("device_x"); + *ppvObject = nullptr; + return E_NOINTERFACE; + } + + HRESULT CreateBuffer(const D3D11_BUFFER_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Buffer** ppBuffer) override { return wrapped_interface->CreateBuffer(pDesc, pInitialData, ppBuffer); } - virtual HRESULT CreateTexture1D(const D3D11_TEXTURE1D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture1D** ppTexture1D) override + HRESULT CreateTexture1D(const D3D11_TEXTURE1D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture1D** ppTexture1D) override { return wrapped_interface->CreateTexture1D(pDesc, pInitialData, ppTexture1D); } - virtual HRESULT CreateTexture2D(const D3D11_TEXTURE2D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture2D** ppTexture2D) override + HRESULT CreateTexture2D(const D3D11_TEXTURE2D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture2D** ppTexture2D) override { return wrapped_interface->CreateTexture2D(pDesc, pInitialData, ppTexture2D); } - virtual HRESULT CreateTexture3D(const D3D11_TEXTURE3D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture3D** ppTexture3D) override + HRESULT CreateTexture3D(const D3D11_TEXTURE3D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture3D** ppTexture3D) override { return wrapped_interface->CreateTexture3D(pDesc, pInitialData, ppTexture3D); } - virtual HRESULT CreateShaderResourceView(ID3D11Resource* pResource, const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc, ID3D11ShaderResourceView** ppSRView) override + HRESULT CreateShaderResourceView(ID3D11Resource* pResource, const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc, ID3D11ShaderResourceView** ppSRView) override { return wrapped_interface->CreateShaderResourceView(pResource, pDesc, ppSRView); } - virtual HRESULT CreateUnorderedAccessView(ID3D11Resource* pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc, ID3D11UnorderedAccessView** ppUAView) override + HRESULT CreateUnorderedAccessView(ID3D11Resource* pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc, ID3D11UnorderedAccessView** ppUAView) override { return wrapped_interface->CreateUnorderedAccessView(pResource, pDesc, ppUAView); } - virtual HRESULT CreateRenderTargetView(ID3D11Resource* pResource, const D3D11_RENDER_TARGET_VIEW_DESC* pDesc, ID3D11RenderTargetView** ppRTView) override + HRESULT CreateRenderTargetView(ID3D11Resource* pResource, const D3D11_RENDER_TARGET_VIEW_DESC* pDesc, ID3D11RenderTargetView** ppRTView) override { return wrapped_interface->CreateRenderTargetView(pResource, pDesc, ppRTView); } - virtual HRESULT CreateDepthStencilView(ID3D11Resource* pResource, const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc, ID3D11DepthStencilView** ppDepthStencilView) override + HRESULT CreateDepthStencilView(ID3D11Resource* pResource, const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc, ID3D11DepthStencilView** ppDepthStencilView) override { return wrapped_interface->CreateDepthStencilView(pResource, pDesc, ppDepthStencilView); } - virtual HRESULT CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements, const void* pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, ID3D11InputLayout** ppInputLayout) override + HRESULT CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements, const void* pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, ID3D11InputLayout** ppInputLayout) override { return wrapped_interface->CreateInputLayout(pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); } - virtual HRESULT CreateVertexShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) override + HRESULT CreateVertexShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader) override { return wrapped_interface->CreateVertexShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); } - virtual HRESULT CreateGeometryShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) override + HRESULT CreateGeometryShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) override { return wrapped_interface->CreateGeometryShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); } - virtual HRESULT CreateGeometryShaderWithStreamOutput(const void* pShaderBytecode, SIZE_T BytecodeLength, const D3D11_SO_DECLARATION_ENTRY* pSODeclaration, UINT NumEntries, const UINT* pBufferStrides, UINT NumStrides, UINT RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) override + HRESULT CreateGeometryShaderWithStreamOutput(const void* pShaderBytecode, SIZE_T BytecodeLength, const D3D11_SO_DECLARATION_ENTRY* pSODeclaration, UINT NumEntries, const UINT* pBufferStrides, UINT NumStrides, UINT RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader) override { return wrapped_interface->CreateGeometryShaderWithStreamOutput(pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); } - virtual HRESULT CreatePixelShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) override + HRESULT CreatePixelShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader) override { return wrapped_interface->CreatePixelShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); } - virtual HRESULT CreateHullShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) override + HRESULT CreateHullShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader) override { return wrapped_interface->CreateHullShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); } - virtual HRESULT CreateDomainShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) override + HRESULT CreateDomainShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader) override { return wrapped_interface->CreateDomainShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); } - virtual HRESULT CreateComputeShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) override + HRESULT CreateComputeShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader) override { return wrapped_interface->CreateComputeShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); } - virtual HRESULT CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) override + HRESULT CreateClassLinkage(ID3D11ClassLinkage** ppLinkage) override { return wrapped_interface->CreateClassLinkage(ppLinkage); } - virtual HRESULT CreateBlendState(const D3D11_BLEND_DESC* pBlendStateDesc, ID3D11BlendState** ppBlendState) override + HRESULT CreateBlendState(const D3D11_BLEND_DESC* pBlendStateDesc, ID3D11BlendState** ppBlendState) override { return wrapped_interface->CreateBlendState(pBlendStateDesc, ppBlendState); } - virtual HRESULT CreateDepthStencilState(const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) override + HRESULT CreateDepthStencilState(const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) override { return wrapped_interface->CreateDepthStencilState(pDepthStencilDesc, ppDepthStencilState); } - virtual HRESULT CreateRasterizerState(const D3D11_RASTERIZER_DESC* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) override + HRESULT CreateRasterizerState(const D3D11_RASTERIZER_DESC* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState) override { return wrapped_interface->CreateRasterizerState(pRasterizerDesc, ppRasterizerState); } - virtual HRESULT CreateSamplerState(const D3D11_SAMPLER_DESC* pSamplerDesc, ID3D11SamplerState** ppSamplerState) override + HRESULT CreateSamplerState(const D3D11_SAMPLER_DESC* pSamplerDesc, ID3D11SamplerState** ppSamplerState) override { return wrapped_interface->CreateSamplerState(pSamplerDesc, ppSamplerState); } - virtual HRESULT CreateQuery(const D3D11_QUERY_DESC* pQueryDesc, ID3D11Query** ppQuery) override + HRESULT CreateQuery(const D3D11_QUERY_DESC* pQueryDesc, ID3D11Query** ppQuery) override { return wrapped_interface->CreateQuery(pQueryDesc, ppQuery); } - virtual HRESULT CreatePredicate(const D3D11_QUERY_DESC* pPredicateDesc, ID3D11Predicate** ppPredicate) override + HRESULT CreatePredicate(const D3D11_QUERY_DESC* pPredicateDesc, ID3D11Predicate** ppPredicate) override { return wrapped_interface->CreatePredicate(pPredicateDesc, ppPredicate); } - virtual HRESULT CreateCounter(const D3D11_COUNTER_DESC* pCounterDesc, ID3D11Counter** ppCounter) override + HRESULT CreateCounter(const D3D11_COUNTER_DESC* pCounterDesc, ID3D11Counter** ppCounter) override { return wrapped_interface->CreateCounter(pCounterDesc, ppCounter); } - virtual HRESULT CreateDeferredContext(UINT ContextFlags, ID3D11DeviceContext** ppDeferredContext) override + HRESULT CreateDeferredContext(UINT ContextFlags, ID3D11DeviceContext** ppDeferredContext) override { return wrapped_interface->CreateDeferredContext(ContextFlags, ppDeferredContext); } - virtual HRESULT OpenSharedResource(HANDLE hResource, REFIID ReturnedInterface, void** ppResource) override + HRESULT OpenSharedResource(HANDLE hResource, REFIID ReturnedInterface, void** ppResource) override { return wrapped_interface->OpenSharedResource(hResource, ReturnedInterface, ppResource); } - virtual HRESULT CheckFormatSupport(DXGI_FORMAT Format, UINT* pFormatSupport) override + HRESULT CheckFormatSupport(DXGI_FORMAT Format, UINT* pFormatSupport) override { return wrapped_interface->CheckFormatSupport(Format, pFormatSupport); } - virtual HRESULT CheckMultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, UINT* pNumQualityLevels) override + HRESULT CheckMultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, UINT* pNumQualityLevels) override { return wrapped_interface->CheckMultisampleQualityLevels(Format, SampleCount, pNumQualityLevels); } - virtual void CheckCounterInfo(D3D11_COUNTER_INFO* pCounterInfo) override + void CheckCounterInfo(D3D11_COUNTER_INFO* pCounterInfo) override { wrapped_interface->CheckCounterInfo(pCounterInfo); } - virtual HRESULT CheckCounter(const D3D11_COUNTER_DESC* pDesc, D3D11_COUNTER_TYPE* pType, UINT* pActiveCounters, LPSTR szName, UINT* pNameLength, LPSTR szUnits, UINT* pUnitsLength, LPSTR szDescription, UINT* pDescriptionLength) override + HRESULT CheckCounter(const D3D11_COUNTER_DESC* pDesc, D3D11_COUNTER_TYPE* pType, UINT* pActiveCounters, LPSTR szName, UINT* pNameLength, LPSTR szUnits, UINT* pUnitsLength, LPSTR szDescription, UINT* pDescriptionLength) override { return wrapped_interface->CheckCounter(pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); } - virtual HRESULT CheckFeatureSupport(D3D11_FEATURE Feature, void* pFeatureSupportData, UINT FeatureSupportDataSize) override + HRESULT CheckFeatureSupport(D3D11_FEATURE Feature, void* pFeatureSupportData, UINT FeatureSupportDataSize) override { return wrapped_interface->CheckFeatureSupport(Feature, pFeatureSupportData, FeatureSupportDataSize); } - virtual HRESULT GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData) override + HRESULT GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData) override { return wrapped_interface->GetPrivateData(guid, pDataSize, pData); } - virtual HRESULT SetPrivateData(REFGUID guid, UINT DataSize, const void* pData) override + HRESULT SetPrivateData(REFGUID guid, UINT DataSize, const void* pData) override { return wrapped_interface->SetPrivateData(guid, DataSize, pData); } - virtual HRESULT SetPrivateDataInterface(REFGUID guid, const IUnknown* pData) override + HRESULT SetPrivateDataInterface(REFGUID guid, const IUnknown* pData) override { return wrapped_interface->SetPrivateDataInterface(guid, pData); } - virtual HRESULT SetPrivateDataInterfaceGraphics(REFGUID guid, const IGraphicsUnknown* pData) override + HRESULT SetPrivateDataInterfaceGraphics(REFGUID guid, const IGraphicsUnknown* pData) override { throw std::exception("Not implemented"); //return wrapped_interface->SetPrivateDataInterfaceGraphics(guid, pData); } - virtual D3D_FEATURE_LEVEL GetFeatureLevel( ) override + D3D_FEATURE_LEVEL GetFeatureLevel( ) override { return wrapped_interface->GetFeatureLevel( ); } - virtual UINT GetCreationFlags( ) override + UINT GetCreationFlags( ) override { return wrapped_interface->GetCreationFlags( ); } - virtual HRESULT GetDeviceRemovedReason( ) override + HRESULT GetDeviceRemovedReason( ) override { return wrapped_interface->GetDeviceRemovedReason( ); } - virtual void GetImmediateContext(ID3D11DeviceContext** ppImmediateContext) override + void GetImmediateContext(ID3D11DeviceContext** ppImmediateContext) override { wrapped_interface->GetImmediateContext(ppImmediateContext); } - virtual HRESULT SetExceptionMode(UINT RaiseFlags) override + HRESULT SetExceptionMode(UINT RaiseFlags) override { return wrapped_interface->SetExceptionMode(RaiseFlags); } - virtual UINT GetExceptionMode( ) override + UINT GetExceptionMode( ) override { return wrapped_interface->GetExceptionMode( ); } // ID3D11Device1 methods - virtual void GetImmediateContext1(ID3D11DeviceContext1** ppImmediateContext) override + void GetImmediateContext1(ID3D11DeviceContext1** ppImmediateContext) override { wrapped_interface->GetImmediateContext1(ppImmediateContext); } - virtual HRESULT CreateDeferredContext1(UINT ContextFlags, ID3D11DeviceContext1** ppDeferredContext) override + HRESULT CreateDeferredContext1(UINT ContextFlags, ID3D11DeviceContext1** ppDeferredContext) override { return wrapped_interface->CreateDeferredContext1(ContextFlags, ppDeferredContext); } - virtual HRESULT CreateBlendState1(const D3D11_BLEND_DESC1* pBlendStateDesc, ID3D11BlendState1** ppBlendState) override + HRESULT CreateBlendState1(const D3D11_BLEND_DESC1* pBlendStateDesc, ID3D11BlendState1** ppBlendState) override { return wrapped_interface->CreateBlendState1(pBlendStateDesc, ppBlendState); } - virtual HRESULT CreateRasterizerState1(const D3D11_RASTERIZER_DESC1* pRasterizerDesc, ID3D11RasterizerState1** ppRasterizerState) override + HRESULT CreateRasterizerState1(const D3D11_RASTERIZER_DESC1* pRasterizerDesc, ID3D11RasterizerState1** ppRasterizerState) override { return wrapped_interface->CreateRasterizerState1(pRasterizerDesc, ppRasterizerState); } - virtual HRESULT CreateDeviceContextState(UINT Flags, const D3D_FEATURE_LEVEL* pFeatureLevels, UINT FeatureLevels, UINT SDKVersion, REFIID EmulatedInterface, D3D_FEATURE_LEVEL* pChosenFeatureLevel, ID3DDeviceContextState** ppContextState) override + HRESULT CreateDeviceContextState(UINT Flags, const D3D_FEATURE_LEVEL* pFeatureLevels, UINT FeatureLevels, UINT SDKVersion, REFIID EmulatedInterface, D3D_FEATURE_LEVEL* pChosenFeatureLevel, ID3DDeviceContextState** ppContextState) override { return wrapped_interface->CreateDeviceContextState(Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState); } - virtual HRESULT OpenSharedResource1(HANDLE hResource, REFIID ReturnedInterface, void** ppResource) override + HRESULT OpenSharedResource1(HANDLE hResource, REFIID ReturnedInterface, void** ppResource) override { return wrapped_interface->OpenSharedResource1(hResource, ReturnedInterface, ppResource); } - virtual HRESULT OpenSharedResourceByName(LPCWSTR lpName, DWORD dwDesiredAccess, REFIID ReturnedInterface, void** ppResource) override + HRESULT OpenSharedResourceByName(LPCWSTR lpName, DWORD dwDesiredAccess, REFIID ReturnedInterface, void** ppResource) override { return wrapped_interface->OpenSharedResourceByName(lpName, dwDesiredAccess, ReturnedInterface, ppResource); } // ID3D11Device2 methods - virtual void GetImmediateContext2(ID3D11DeviceContext2** ppImmediateContext) override + void GetImmediateContext2(ID3D11DeviceContext2** ppImmediateContext) override { wrapped_interface->GetImmediateContext2(ppImmediateContext); } - virtual HRESULT CreateDeferredContext2(UINT ContextFlags, ID3D11DeviceContext2** ppDeferredContext) override + HRESULT CreateDeferredContext2(UINT ContextFlags, ID3D11DeviceContext2** ppDeferredContext) override { return wrapped_interface->CreateDeferredContext2(ContextFlags, ppDeferredContext); } - virtual void GetResourceTiling(ID3D11Resource* pTiledResource, UINT* pNumTilesForEntireResource, D3D11_PACKED_MIP_DESC* pPackedMipDesc, D3D11_TILE_SHAPE* pStandardTileShapeForNonPackedMips, UINT* pNumSubresourceTilings, UINT FirstSubresourceTilingToGet, D3D11_SUBRESOURCE_TILING* pSubresourceTilingsForNonPackedMips) override + void GetResourceTiling(ID3D11Resource* pTiledResource, UINT* pNumTilesForEntireResource, D3D11_PACKED_MIP_DESC* pPackedMipDesc, D3D11_TILE_SHAPE* pStandardTileShapeForNonPackedMips, UINT* pNumSubresourceTilings, UINT FirstSubresourceTilingToGet, D3D11_SUBRESOURCE_TILING* pSubresourceTilingsForNonPackedMips) override { wrapped_interface->GetResourceTiling(pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); } - virtual HRESULT CheckMultisampleQualityLevels1(DXGI_FORMAT Format, UINT SampleCount, UINT Flags, UINT* pNumQualityLevels) override + HRESULT CheckMultisampleQualityLevels1(DXGI_FORMAT Format, UINT SampleCount, UINT Flags, UINT* pNumQualityLevels) override { return wrapped_interface->CheckMultisampleQualityLevels1(Format, SampleCount, Flags, pNumQualityLevels); } diff --git a/dlls/d3d11_x/graphics_unknown.h b/dlls/d3d11_x/graphics_unknown.h index 106b08b..80a9afa 100644 --- a/dlls/d3d11_x/graphics_unknown.h +++ b/dlls/d3d11_x/graphics_unknown.h @@ -20,6 +20,11 @@ namespace wdi virtual ULONG AddRef( ) = 0; virtual ULONG Release( ) = 0; }; + + D3DINTERFACE(IGraphicsUnwrap, bcfaae29, e1a2, 4b9a, aa, fc, 55, b9, ff, 21, fa, 54) + { + + }; } namespace wd @@ -31,12 +36,12 @@ namespace wd m_RefCount = 1; } - ULONG STDMETHODCALLTYPE AddRef( ) override + ULONG AddRef( ) override { return InterlockedIncrement(&m_RefCount); } - ULONG STDMETHODCALLTYPE Release( ) override + ULONG Release( ) override { ULONG refCount = InterlockedDecrement(&m_RefCount); if (refCount == 0) { @@ -45,7 +50,7 @@ namespace wd return refCount; } - HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override + HRESULT QueryInterface(REFIID riid, void** ppvObject) override { if (ppvObject == nullptr) { diff --git a/dlls/kernelx/Exports.def b/dlls/kernelx/Exports.def index bbfc193..7728487 100644 --- a/dlls/kernelx/Exports.def +++ b/dlls/kernelx/Exports.def @@ -478,7 +478,7 @@ EXPORTS UnregisterTraceGuids = Kernel32.UnregisterTraceGuids @471 UnregisterWaitEx = Kernel32.UnregisterWaitEx @472 UpdateProcThreadAttribute = Kernel32.UpdateProcThreadAttribute @473 - VirtualAlloc = Kernel32.VirtualAlloc @474 + VirtualAlloc = VirtualAlloc_X @474 VirtualAllocEx = Kernel32.VirtualAllocEx @475 VirtualFree = Kernel32.VirtualFree @476 VirtualFreeEx = Kernel32.VirtualFreeEx @477 diff --git a/dlls/kernelx/kernelx.cpp b/dlls/kernelx/kernelx.cpp index cc62f95..c791e5c 100644 --- a/dlls/kernelx/kernelx.cpp +++ b/dlls/kernelx/kernelx.cpp @@ -297,6 +297,10 @@ static decltype(&XMemFree_X) XMemFreeRoutine_X; void XMemSetAllocationHooks_X(decltype(&XMemAlloc_X) Alloc, decltype(&XMemFree_X) Free) { + if (XMemSetAllocationHooksLock_X.OwningThread == 0) { + InitializeCriticalSection(&XMemSetAllocationHooksLock_X); + } + EnterCriticalSection(&XMemSetAllocationHooksLock_X); if (Alloc) { @@ -311,219 +315,30 @@ void XMemSetAllocationHooks_X(decltype(&XMemAlloc_X) Alloc, decltype(&XMemFree_X LeaveCriticalSection(&XMemSetAllocationHooksLock_X); } -// TODO -// absolutely temporary implementation I just want to make it work -// sub_18001BCA0 -char* TblPtrs; -HANDLE hExtendedLocaleKey; -HANDLE hCustomLocaleKey; -HANDLE hLangGroupsKey; -HANDLE hAltSortsKey; -HANDLE hLocaleKey; -HANDLE hCodePageKey; -HANDLE gpACPHashN; -char* dword_18002B84C; -LPVOID P; // ?!?! ? -LPVOID P_0; // ¡!¡ ¡!?!?? -//sub_18001BB8C -int IsNlsProcessInitialized; +#define PROTECT_FLAGS_MASK (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY | PAGE_NOACCESS | PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY | PAGE_GUARD | PAGE_NOCACHE) +#define ALLOCATION_FLAGS_MASK (MEM_COMMIT | MEM_RESERVE | MEM_RESET | MEM_LARGE_PAGES | MEM_PHYSICAL | MEM_TOP_DOWN | MEM_WRITE_WATCH) - -int sub_18001D528() +LPVOID VirtualAlloc_X( + LPVOID lpAddress, + SIZE_T dwSize, + DWORD flAllocationType, + DWORD flProtect +) { - //TODO - return 0; + flProtect &= PROTECT_FLAGS_MASK; + flAllocationType &= ALLOCATION_FLAGS_MASK; + + LPVOID ret = VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect); + + // backup plan in the case that VirtualAlloc fails despite the flags being masked away + if (ret == nullptr) + { + printf("VirtualAlloc failed with %i, using backup...\n", GetLastError()); + ret = VirtualAlloc(lpAddress, dwSize, MEM_COMMIT, flProtect); + } + + assert(ret != nullptr && "VirtualAlloc should not fail, check proper handling of xbox-one specific memory protection constants."); + + return ret; } - -INT16 sub_18001D768() -{ - //TODO - return 0; -} - -int sub_18001D96C(int v2, unsigned short* codePageData, unsigned int p, bool t, long l) -{ - //TODO - return 0; -} - -__int64 sub_18001BB8C() -{ - // I know it should look better if it was initalized at dllmain.cpp but then I can't fix some idiotic errors - HMODULE ntdll = LoadLibraryA("ntdll.dll"); - if (ntdll) { - NtAllocateVirtualMemory = - (NtAllocateVirtualMemory_t)GetProcAddress(ntdll, "NtAllocateVirtualMemory"); - NtFreeVirtualMemory = - (NtFreeVirtualMemory_t)GetProcAddress(ntdll, "NtFreeVirtualMemory"); - - FreeLibrary(ntdll); - } - /*unsigned int v0; // ebx - unsigned __int16* AnsiCodePageData; // rdx - int v2; // ecx - PVOID v3; // rbx - HMODULE v4; // rcx - - v0 = 0; - if (!dword_18002B84C) - { - - v0 = sub_18001D528(); - if (!v0) - { - v0 = sub_18001D768(); - if (!v0) - { - // not sure - AnsiCodePageData = (unsigned __int16*)NtCurrentTeb()->ProcessEnvironmentBlock->ProcessParameters; - v2 = AnsiCodePageData[1]; - dword_18002BF68 = v2; - v0 = sub_18001D96C(v2, AnsiCodePageData, (unsigned int)&P, 0, 0LL); - if (!v0) - { - RtlAcquireSRWLockExclusive(&unk_18002B838); - qword_18002B828 = sub_18001EB38(127LL); - if (qword_18002B828) - { - RtlReleaseSRWLockExclusive(&unk_18002B838); - qword_18002B990 = 0LL; - qword_18002B980 = 0LL; - word_18002BF64 = 1; - Event = 0LL; - dword_18002B84C = 1; - } - else - { - RtlReleaseSRWLockExclusive(&unk_18002B838); - v3 = gpACPHashN; - v4 = (HMODULE) * ((_QWORD*)gpACPHashN + 8); - if (v4) - FreeLibrary(v4); - RtlFreeHeap(NtCurrentPeb()->ProcessHeap, 0, v3); - gpACPHashN = 0LL; - return 87; - } - } - } - } - } - return v0;*/ - return 0; -} - - -// absolutely temporary implementation I just want to make it work -// decompilation from ghidra (it looks horrible lol) -NTSTATUS NlsProcessDestroy(HINSTANCE hInstance, DWORD forwardReason, LPVOID lpvReserved) -{ - char* v0; // rax - __int64 v1; // rdi - __int64 v2; // rsi - char* v3; // rbx - HMODULE v4; // rcx - char* v5; // rbp - char* v6; // rax - __int64 v7; // rdi - __int64 v8; // rsi - char* v9; // r8 - char* v10; // rbx - PVOID v11; // rbx - HMODULE v12; // rcx - NTSTATUS result; // al - - - v0 = (char*)TblPtrs; - if (TblPtrs) - { - v1 = 0LL; - v2 = 197LL; - do - { - v3 = *(char**)&v0[v1]; - if (v3) - { - do - { - v4 = (HMODULE)v3[8]; - v5 = (char*)v3[9]; - if (v4) - FreeLibrary(v4); - HeapFree(GetProcessHeap(), 0, v3); - v3 = v5; - } while (v5); - v0 = (char*)TblPtrs; - } - v1 += 8LL; - --v2; - } while (v2); - if (v0) - HeapFree(GetProcessHeap(), 0, TblPtrs); - TblPtrs = 0LL; - } - v6 = (char*)P; - v7 = 0LL; - v8 = 128LL; - do - { - v9 = *(char**)&v6[v7]; - if (v9) - { - do - { - v10 = (char*)v9[10]; - HeapFree(GetProcessHeap(), 0, v9); - v9 = v10; - } while (v10); - v6 = (char*)P; - } - v7 += 8LL; - --v8; - } while (v8); - if (v6) - HeapFree(GetProcessHeap(), 0, P); - P = 0LL; - if (P_0) - HeapFree(GetProcessHeap(), 0, P_0); - v11 = gpACPHashN; - P_0 = 0LL; - v12 = (HMODULE) * ((char*)gpACPHashN + 8); - if (v12) - FreeLibrary(v12); - result = HeapFree(GetProcessHeap(), 0, v11); - gpACPHashN = 0LL; - if (hCodePageKey) - { - result = NtClose(hCodePageKey); - hCodePageKey = 0LL; - } - if (hLocaleKey) - { - result = NtClose(hLocaleKey); - hLocaleKey = 0LL; - } - if (hAltSortsKey) - { - result = NtClose(hAltSortsKey); - hAltSortsKey = 0LL; - } - if (hLangGroupsKey) - { - result = NtClose(hLangGroupsKey); - hLangGroupsKey = 0LL; - } - if (hCustomLocaleKey) - { - result = NtClose(hCustomLocaleKey); - hCustomLocaleKey = 0LL; - } - if (hExtendedLocaleKey) - { - result = NtClose(hExtendedLocaleKey); - hExtendedLocaleKey = 0LL; - } - IsNlsProcessInitialized = 0; - return result; -} - diff --git a/dlls/kernelx/utils.h b/dlls/kernelx/utils.h index 434d7cb..25b1c6b 100644 --- a/dlls/kernelx/utils.h +++ b/dlls/kernelx/utils.h @@ -1,8 +1,9 @@ #pragma once - -#include +#define WIN32_LEAN_AND_MEAN +#include #include -#include +#include + #define FAILED(hr) (((HRESULT)(hr)) < 0) #define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0) diff --git a/dlls/winrt_x/Implementation/Windows.Xbox.Input.Controller.cpp b/dlls/winrt_x/Implementation/Windows.Xbox.Input.Controller.cpp index c04dc51..8af74ce 100644 --- a/dlls/winrt_x/Implementation/Windows.Xbox.Input.Controller.cpp +++ b/dlls/winrt_x/Implementation/Windows.Xbox.Input.Controller.cpp @@ -60,12 +60,11 @@ namespace winrt::Windows::Xbox::Input::implementation winrt::event_token Controller::ControllerOrderChanged(winrt::Windows::Foundation::EventHandler const& handler) { printf("[ControllerOrderChanged] STUBBED\n"); - throw hresult_not_implemented( ); + return {}; } void Controller::ControllerOrderChanged(winrt::event_token const& token) noexcept { - printf("[ControllerOrderChanged] STUBBED\n"); - throw hresult_not_implemented( ); + printf("[ControllerOrderChangedInternal] STUBBED\n"); } winrt::Windows::Xbox::Input::IController Controller::GetControllerById(uint64_t controllerId) { diff --git a/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.cpp b/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.cpp index 7266f53..d1362c8 100644 --- a/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.cpp +++ b/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.cpp @@ -37,7 +37,13 @@ namespace winrt::Windows::Xbox::Management::Deployment::implementation } winrt::Windows::Xbox::Management::Deployment::PackageTransferManager PackageTransferManager::Current() { - throw hresult_not_implemented(); + if (static_manager == Deployment::PackageTransferManager{ nullptr }) + { + static_manager = make( ); + } + + printf("PackageTransferManager::Current()\n"); + return static_manager; } winrt::Windows::Xbox::Management::Deployment::PackageTransferManager PackageTransferManager::Create(winrt::Windows::ApplicationModel::Package const& package) { @@ -49,7 +55,8 @@ namespace winrt::Windows::Xbox::Management::Deployment::implementation } bool PackageTransferManager::IsChunkInstalled(uint32_t chunkId) { - throw hresult_not_implemented(); + printf("PackageTransferManager::IsChunkInstalled() STUBBED\n"); + return true; } bool PackageTransferManager::AreChunksInstalled(winrt::Windows::Foundation::Collections::IIterable const& chunkIds) { diff --git a/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.h b/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.h index 6134388..99a02ab 100644 --- a/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.h +++ b/dlls/winrt_x/Implementation/Windows.Xbox.Management.Deployment.PackageTransferManager.h @@ -42,6 +42,8 @@ namespace winrt::Windows::Xbox::Management::Deployment::implementation winrt::Windows::Xbox::Management::Deployment::InstallationState GetInstallationState(winrt::Windows::Xbox::Management::Deployment::ChunkSpecifiers const& specifiers); winrt::Windows::Foundation::IAsyncOperation AddChunkSpecifiersAsync(winrt::Windows::Xbox::Management::Deployment::ChunkSpecifiers additionalSpecifiers); winrt::Windows::Foundation::IAsyncAction RemoveChunkSpecifiersAsync(winrt::Windows::Xbox::Management::Deployment::ChunkSpecifiers removeSpecifiers); + + inline static Deployment::PackageTransferManager static_manager = { nullptr }; }; } namespace winrt::Windows::Xbox::Management::Deployment::factory_implementation