diff options
Diffstat (limited to 'plugins/pluginWinDD')
| -rwxr-xr-x | plugins/pluginWinDD/dllmain_dd.cxx | 98 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/CommonTypes.h | 22 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/DisplayManager.cxx | 315 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/DisplayManager.h | 44 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/DuplicationManager.cxx | 393 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/DuplicationManager.h | 40 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/OutputManager.cxx | 503 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/OutputManager.h | 66 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/ThreadManager.cxx | 95 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/internals/ThreadManager.h | 28 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/plugin_win_dd_config.h | 4 | ||||
| -rwxr-xr-x | plugins/pluginWinDD/plugin_win_dd_producer.cxx | 1600 |
12 files changed, 1437 insertions, 1771 deletions
diff --git a/plugins/pluginWinDD/dllmain_dd.cxx b/plugins/pluginWinDD/dllmain_dd.cxx index b390c90..e8df126 100755 --- a/plugins/pluginWinDD/dllmain_dd.cxx +++ b/plugins/pluginWinDD/dllmain_dd.cxx @@ -35,80 +35,72 @@ PLUGIN_WIN_DDP_API tsk_plugin_def_ptr_const_t __plugin_get_def_at(int index); PLUGIN_WIN_DD_END_DECLS /* END */ BOOL APIENTRY DllMain(HMODULE hModule, -DWORD ul_reason_for_call, -LPVOID lpReserved -) + DWORD ul_reason_for_call, + LPVOID lpReserved + ) { - switch (ul_reason_for_call) - { - case DLL_PROCESS_ATTACH: - break; - case DLL_THREAD_ATTACH: - break; - case DLL_THREAD_DETACH: - break; - case DLL_PROCESS_DETACH: - break; - } - return TRUE; + switch (ul_reason_for_call) { + case DLL_PROCESS_ATTACH: + break; + case DLL_THREAD_ATTACH: + break; + case DLL_THREAD_DETACH: + break; + case DLL_PROCESS_DETACH: + break; + } + return TRUE; } -typedef enum PLUGIN_INDEX_E -{ - PLUGIN_INDEX_PRODUCER, +typedef enum PLUGIN_INDEX_E { + PLUGIN_INDEX_PRODUCER, - PLUGIN_INDEX_COUNT + PLUGIN_INDEX_COUNT } PLUGIN_INDEX_T; int __plugin_get_def_count() { - return PLUGIN_INDEX_COUNT; + return PLUGIN_INDEX_COUNT; } tsk_plugin_def_type_t __plugin_get_def_type_at(int index) { - switch (index){ - case PLUGIN_INDEX_PRODUCER: - { - return tsk_plugin_def_type_producer; - } - default: - { - TSK_DEBUG_ERROR("No plugin at index %d", index); - return tsk_plugin_def_type_none; - } - } + switch (index) { + case PLUGIN_INDEX_PRODUCER: { + return tsk_plugin_def_type_producer; + } + default: { + TSK_DEBUG_ERROR("No plugin at index %d", index); + return tsk_plugin_def_type_none; + } + } } tsk_plugin_def_media_type_t __plugin_get_def_media_type_at(int index) { - switch (index){ - case PLUGIN_INDEX_PRODUCER: - { - return tsk_plugin_def_media_type_screencast; - } - default: - { - TSK_DEBUG_ERROR("No plugin at index %d", index); - return tsk_plugin_def_media_type_none; - } - } + switch (index) { + case PLUGIN_INDEX_PRODUCER: { + return tsk_plugin_def_media_type_screencast; + } + default: { + TSK_DEBUG_ERROR("No plugin at index %d", index); + return tsk_plugin_def_media_type_none; + } + } } tsk_plugin_def_ptr_const_t __plugin_get_def_at(int index) { - switch (index){ - case PLUGIN_INDEX_PRODUCER: - { - return plugin_win_dd_producer_plugin_def_t; - } - default: - { - TSK_DEBUG_ERROR("No plugin at index %d", index); - return tsk_null; - } - } + switch (index) { + case PLUGIN_INDEX_PRODUCER: { + return plugin_win_dd_producer_plugin_def_t; + } + default: { + TSK_DEBUG_ERROR("No plugin at index %d", index); + return tsk_null; + } + } } diff --git a/plugins/pluginWinDD/internals/CommonTypes.h b/plugins/pluginWinDD/internals/CommonTypes.h index 7b9c2d4..3870e96 100755 --- a/plugins/pluginWinDD/internals/CommonTypes.h +++ b/plugins/pluginWinDD/internals/CommonTypes.h @@ -32,12 +32,11 @@ extern HRESULT AcquireFrameExpectedError[]; extern HRESULT EnumOutputsExpectedErrors[]; -typedef _Return_type_success_(return == DUPL_RETURN_SUCCESS) enum -{ +typedef _Return_type_success_(return == DUPL_RETURN_SUCCESS) enum { DUPL_RETURN_SUCCESS = 0, DUPL_RETURN_ERROR_EXPECTED = 1, DUPL_RETURN_ERROR_UNEXPECTED = 2 -}DUPL_RETURN; +} DUPL_RETURN; _Post_satisfies_(return != DUPL_RETURN_SUCCESS) DUPL_RETURN ProcessFailure(_In_opt_ ID3D11Device* Device, _In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr, _In_opt_z_ HRESULT* ExpectedErrors = nullptr); @@ -47,8 +46,7 @@ void DisplayMsg(_In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr); // // Holds info about the pointer/cursor // -typedef struct _PTR_INFO -{ +typedef struct _PTR_INFO { _Field_size_bytes_(BufferSize) BYTE* PtrShapeBuffer; DXGI_OUTDUPL_POINTER_SHAPE_INFO ShapeInfo; POINT Position; @@ -61,8 +59,7 @@ typedef struct _PTR_INFO // // Structure that holds D3D resources not directly tied to any one thread // -typedef struct _DX_RESOURCES -{ +typedef struct _DX_RESOURCES { ID3D11Device* Device; ID3D11DeviceContext* Context; ID3D11VertexShader* VertexShader; @@ -74,8 +71,7 @@ typedef struct _DX_RESOURCES // // Structure to pass to a new thread // -typedef struct _THREAD_DATA -{ +typedef struct _THREAD_DATA { // Used to indicate abnormal error condition HANDLE UnexpectedErrorEvent; @@ -92,14 +88,13 @@ typedef struct _THREAD_DATA PTR_INFO* PtrInfo; DX_RESOURCES DxRes; - const struct tmedia_producer_s* Producer; + const struct tmedia_producer_s* Producer; } THREAD_DATA; // // FRAME_DATA holds information about an acquired frame // -typedef struct _FRAME_DATA -{ +typedef struct _FRAME_DATA { ID3D11Texture2D* Frame; DXGI_OUTDUPL_FRAME_INFO FrameInfo; _Field_size_bytes_((MoveCount * sizeof(DXGI_OUTDUPL_MOVE_RECT)) + (DirtyCount * sizeof(RECT))) BYTE* MetaData; @@ -110,8 +105,7 @@ typedef struct _FRAME_DATA // // A vertex with a position and texture coordinate // -typedef struct _VERTEX -{ +typedef struct _VERTEX { DirectX::XMFLOAT3 Pos; DirectX::XMFLOAT2 TexCoord; } VERTEX; diff --git a/plugins/pluginWinDD/internals/DisplayManager.cxx b/plugins/pluginWinDD/internals/DisplayManager.cxx index 98209a0..e60ab64 100755 --- a/plugins/pluginWinDD/internals/DisplayManager.cxx +++ b/plugins/pluginWinDD/internals/DisplayManager.cxx @@ -12,15 +12,15 @@ using namespace DirectX; // Constructor NULLs out vars // DISPLAYMANAGER::DISPLAYMANAGER() : m_Device(nullptr), - m_DeviceContext(nullptr), - m_MoveSurf(nullptr), - m_VertexShader(nullptr), - m_PixelShader(nullptr), - m_InputLayout(nullptr), - m_RTV(nullptr), - m_SamplerLinear(nullptr), - m_DirtyVertexBufferAlloc(nullptr), - m_DirtyVertexBufferAllocSize(0) + m_DeviceContext(nullptr), + m_MoveSurf(nullptr), + m_VertexShader(nullptr), + m_PixelShader(nullptr), + m_InputLayout(nullptr), + m_RTV(nullptr), + m_SamplerLinear(nullptr), + m_DirtyVertexBufferAlloc(nullptr), + m_DirtyVertexBufferAllocSize(0) { } @@ -31,8 +31,7 @@ DISPLAYMANAGER::~DISPLAYMANAGER() { CleanRefs(); - if (m_DirtyVertexBufferAlloc) - { + if (m_DirtyVertexBufferAlloc) { delete [] m_DirtyVertexBufferAlloc; m_DirtyVertexBufferAlloc = nullptr; } @@ -66,22 +65,18 @@ DUPL_RETURN DISPLAYMANAGER::ProcessFrame(_In_ FRAME_DATA* Data, _Inout_ ID3D11Te DUPL_RETURN Ret = DUPL_RETURN_SUCCESS; // Process dirties and moves - if (Data->FrameInfo.TotalMetadataBufferSize) - { + if (Data->FrameInfo.TotalMetadataBufferSize) { D3D11_TEXTURE2D_DESC Desc; Data->Frame->GetDesc(&Desc); - if (Data->MoveCount) - { + if (Data->MoveCount) { Ret = CopyMove(SharedSurf, reinterpret_cast<DXGI_OUTDUPL_MOVE_RECT*>(Data->MetaData), Data->MoveCount, OffsetX, OffsetY, DeskDesc, Desc.Width, Desc.Height); - if (Ret != DUPL_RETURN_SUCCESS) - { + if (Ret != DUPL_RETURN_SUCCESS) { return Ret; } } - if (Data->DirtyCount) - { + if (Data->DirtyCount) { Ret = CopyDirty(Data->Frame, SharedSurf, reinterpret_cast<RECT*>(Data->MetaData + (Data->MoveCount * sizeof(DXGI_OUTDUPL_MOVE_RECT))), Data->DirtyCount, OffsetX, OffsetY, DeskDesc); } } @@ -102,64 +97,58 @@ ID3D11Device* DISPLAYMANAGER::GetDevice() // void DISPLAYMANAGER::SetMoveRect(_Out_ RECT* SrcRect, _Out_ RECT* DestRect, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ DXGI_OUTDUPL_MOVE_RECT* MoveRect, INT TexWidth, INT TexHeight) { - switch (DeskDesc->Rotation) - { - case DXGI_MODE_ROTATION_UNSPECIFIED: - case DXGI_MODE_ROTATION_IDENTITY: - { - SrcRect->left = MoveRect->SourcePoint.x; - SrcRect->top = MoveRect->SourcePoint.y; - SrcRect->right = MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left; - SrcRect->bottom = MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top; - - *DestRect = MoveRect->DestinationRect; - break; - } - case DXGI_MODE_ROTATION_ROTATE90: - { - SrcRect->left = TexHeight - (MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top); - SrcRect->top = MoveRect->SourcePoint.x; - SrcRect->right = TexHeight - MoveRect->SourcePoint.y; - SrcRect->bottom = MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left; - - DestRect->left = TexHeight - MoveRect->DestinationRect.bottom; - DestRect->top = MoveRect->DestinationRect.left; - DestRect->right = TexHeight - MoveRect->DestinationRect.top; - DestRect->bottom = MoveRect->DestinationRect.right; - break; - } - case DXGI_MODE_ROTATION_ROTATE180: - { - SrcRect->left = TexWidth - (MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left); - SrcRect->top = TexHeight - (MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top); - SrcRect->right = TexWidth - MoveRect->SourcePoint.x; - SrcRect->bottom = TexHeight - MoveRect->SourcePoint.y; - - DestRect->left = TexWidth - MoveRect->DestinationRect.right; - DestRect->top = TexHeight - MoveRect->DestinationRect.bottom; - DestRect->right = TexWidth - MoveRect->DestinationRect.left; - DestRect->bottom = TexHeight - MoveRect->DestinationRect.top; - break; - } - case DXGI_MODE_ROTATION_ROTATE270: - { - SrcRect->left = MoveRect->SourcePoint.x; - SrcRect->top = TexWidth - (MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left); - SrcRect->right = MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top; - SrcRect->bottom = TexWidth - MoveRect->SourcePoint.x; - - DestRect->left = MoveRect->DestinationRect.top; - DestRect->top = TexWidth - MoveRect->DestinationRect.right; - DestRect->right = MoveRect->DestinationRect.bottom; - DestRect->bottom = TexWidth - MoveRect->DestinationRect.left; - break; - } - default: - { - RtlZeroMemory(DestRect, sizeof(RECT)); - RtlZeroMemory(SrcRect, sizeof(RECT)); - break; - } + switch (DeskDesc->Rotation) { + case DXGI_MODE_ROTATION_UNSPECIFIED: + case DXGI_MODE_ROTATION_IDENTITY: { + SrcRect->left = MoveRect->SourcePoint.x; + SrcRect->top = MoveRect->SourcePoint.y; + SrcRect->right = MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left; + SrcRect->bottom = MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top; + + *DestRect = MoveRect->DestinationRect; + break; + } + case DXGI_MODE_ROTATION_ROTATE90: { + SrcRect->left = TexHeight - (MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top); + SrcRect->top = MoveRect->SourcePoint.x; + SrcRect->right = TexHeight - MoveRect->SourcePoint.y; + SrcRect->bottom = MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left; + + DestRect->left = TexHeight - MoveRect->DestinationRect.bottom; + DestRect->top = MoveRect->DestinationRect.left; + DestRect->right = TexHeight - MoveRect->DestinationRect.top; + DestRect->bottom = MoveRect->DestinationRect.right; + break; + } + case DXGI_MODE_ROTATION_ROTATE180: { + SrcRect->left = TexWidth - (MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left); + SrcRect->top = TexHeight - (MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top); + SrcRect->right = TexWidth - MoveRect->SourcePoint.x; + SrcRect->bottom = TexHeight - MoveRect->SourcePoint.y; + + DestRect->left = TexWidth - MoveRect->DestinationRect.right; + DestRect->top = TexHeight - MoveRect->DestinationRect.bottom; + DestRect->right = TexWidth - MoveRect->DestinationRect.left; + DestRect->bottom = TexHeight - MoveRect->DestinationRect.top; + break; + } + case DXGI_MODE_ROTATION_ROTATE270: { + SrcRect->left = MoveRect->SourcePoint.x; + SrcRect->top = TexWidth - (MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left); + SrcRect->right = MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top; + SrcRect->bottom = TexWidth - MoveRect->SourcePoint.x; + + DestRect->left = MoveRect->DestinationRect.top; + DestRect->top = TexWidth - MoveRect->DestinationRect.right; + DestRect->right = MoveRect->DestinationRect.bottom; + DestRect->bottom = TexWidth - MoveRect->DestinationRect.left; + break; + } + default: { + RtlZeroMemory(DestRect, sizeof(RECT)); + RtlZeroMemory(SrcRect, sizeof(RECT)); + break; + } } } @@ -172,8 +161,7 @@ DUPL_RETURN DISPLAYMANAGER::CopyMove(_Inout_ ID3D11Texture2D* SharedSurf, _In_re SharedSurf->GetDesc(&FullDesc); // Make new intermediate surface to copy into for moving - if (!m_MoveSurf) - { + if (!m_MoveSurf) { D3D11_TEXTURE2D_DESC MoveDesc; MoveDesc = FullDesc; MoveDesc.Width = DeskDesc->DesktopCoordinates.right - DeskDesc->DesktopCoordinates.left; @@ -181,14 +169,12 @@ DUPL_RETURN DISPLAYMANAGER::CopyMove(_Inout_ ID3D11Texture2D* SharedSurf, _In_re MoveDesc.BindFlags = D3D11_BIND_RENDER_TARGET; MoveDesc.MiscFlags = 0; HRESULT hr = m_Device->CreateTexture2D(&MoveDesc, nullptr, &m_MoveSurf); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create staging texture for move rects", L"Error", hr, SystemTransitionsExpectedErrors); } } - for (UINT i = 0; i < MoveCount; ++i) - { + for (UINT i = 0; i < MoveCount; ++i) { RECT SrcRect; RECT DestRect; @@ -235,75 +221,70 @@ void DISPLAYMANAGER::SetDirtyVert(_Out_writes_(NUMVERTICES) VERTEX* Vertices, _I RECT DestDirty = *Dirty; // Set appropriate coordinates compensated for rotation - switch (DeskDesc->Rotation) - { - case DXGI_MODE_ROTATION_ROTATE90: - { - DestDirty.left = Width - Dirty->bottom; - DestDirty.top = Dirty->left; - DestDirty.right = Width - Dirty->top; - DestDirty.bottom = Dirty->right; - - Vertices[0].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[1].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[2].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[5].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - break; - } - case DXGI_MODE_ROTATION_ROTATE180: - { - DestDirty.left = Width - Dirty->right; - DestDirty.top = Height - Dirty->bottom; - DestDirty.right = Width - Dirty->left; - DestDirty.bottom = Height - Dirty->top; - - Vertices[0].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[1].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[2].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[5].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - break; - } - case DXGI_MODE_ROTATION_ROTATE270: - { - DestDirty.left = Dirty->top; - DestDirty.top = Height - Dirty->right; - DestDirty.right = Dirty->bottom; - DestDirty.bottom = Height - Dirty->left; - - Vertices[0].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[1].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[2].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[5].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - break; - } - default: - assert(false); // drop through - case DXGI_MODE_ROTATION_UNSPECIFIED: - case DXGI_MODE_ROTATION_IDENTITY: - { - Vertices[0].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[1].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[2].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); - Vertices[5].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); - break; - } + switch (DeskDesc->Rotation) { + case DXGI_MODE_ROTATION_ROTATE90: { + DestDirty.left = Width - Dirty->bottom; + DestDirty.top = Dirty->left; + DestDirty.right = Width - Dirty->top; + DestDirty.bottom = Dirty->right; + + Vertices[0].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[1].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[2].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[5].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + break; + } + case DXGI_MODE_ROTATION_ROTATE180: { + DestDirty.left = Width - Dirty->right; + DestDirty.top = Height - Dirty->bottom; + DestDirty.right = Width - Dirty->left; + DestDirty.bottom = Height - Dirty->top; + + Vertices[0].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[1].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[2].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[5].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + break; + } + case DXGI_MODE_ROTATION_ROTATE270: { + DestDirty.left = Dirty->top; + DestDirty.top = Height - Dirty->right; + DestDirty.right = Dirty->bottom; + DestDirty.bottom = Height - Dirty->left; + + Vertices[0].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[1].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[2].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[5].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + break; + } + default: + assert(false); // drop through + case DXGI_MODE_ROTATION_UNSPECIFIED: + case DXGI_MODE_ROTATION_IDENTITY: { + Vertices[0].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[1].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[2].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height)); + Vertices[5].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height)); + break; + } } // Set positions Vertices[0].Pos = XMFLOAT3((DestDirty.left + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX), - -1 * (DestDirty.bottom + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), - 0.0f); + -1 * (DestDirty.bottom + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), + 0.0f); Vertices[1].Pos = XMFLOAT3((DestDirty.left + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX), - -1 * (DestDirty.top + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), - 0.0f); + -1 * (DestDirty.top + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), + 0.0f); Vertices[2].Pos = XMFLOAT3((DestDirty.right + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX), - -1 * (DestDirty.bottom + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), - 0.0f); + -1 * (DestDirty.bottom + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), + 0.0f); Vertices[3].Pos = Vertices[2].Pos; Vertices[4].Pos = Vertices[1].Pos; Vertices[5].Pos = XMFLOAT3((DestDirty.right + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX), - -1 * (DestDirty.top + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), - 0.0f); + -1 * (DestDirty.top + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY), + 0.0f); Vertices[3].TexCoord = Vertices[2].TexCoord; Vertices[4].TexCoord = Vertices[1].TexCoord; @@ -324,11 +305,9 @@ DUPL_RETURN DISPLAYMANAGER::CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ D3D11_TEXTURE2D_DESC ThisDesc; SrcSurface->GetDesc(&ThisDesc); - if (!m_RTV) - { + if (!m_RTV) { hr = m_Device->CreateRenderTargetView(SharedSurf, nullptr, &m_RTV); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create render target view for dirty rects", L"Error", hr, SystemTransitionsExpectedErrors); } } @@ -342,8 +321,7 @@ DUPL_RETURN DISPLAYMANAGER::CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ // Create new shader resource view ID3D11ShaderResourceView* ShaderResource = nullptr; hr = m_Device->CreateShaderResourceView(SrcSurface, &ShaderDesc, &ShaderResource); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create shader resource view for dirty rects", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -358,16 +336,13 @@ DUPL_RETURN DISPLAYMANAGER::CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ // Create space for vertices for the dirty rects if the current space isn't large enough UINT BytesNeeded = sizeof(VERTEX) * NUMVERTICES * DirtyCount; - if (BytesNeeded > m_DirtyVertexBufferAllocSize) - { - if (m_DirtyVertexBufferAlloc) - { + if (BytesNeeded > m_DirtyVertexBufferAllocSize) { + if (m_DirtyVertexBufferAlloc) { delete [] m_DirtyVertexBufferAlloc; } m_DirtyVertexBufferAlloc = new (std::nothrow) BYTE[BytesNeeded]; - if (!m_DirtyVertexBufferAlloc) - { + if (!m_DirtyVertexBufferAlloc) { m_DirtyVertexBufferAllocSize = 0; return ProcessFailure(nullptr, L"Failed to allocate memory for dirty vertex buffer.", L"Error", E_OUTOFMEMORY); } @@ -377,8 +352,7 @@ DUPL_RETURN DISPLAYMANAGER::CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ // Fill them in VERTEX* DirtyVertex = reinterpret_cast<VERTEX*>(m_DirtyVertexBufferAlloc); - for (UINT i = 0; i < DirtyCount; ++i, DirtyVertex += NUMVERTICES) - { + for (UINT i = 0; i < DirtyCount; ++i, DirtyVertex += NUMVERTICES) { SetDirtyVert(DirtyVertex, &(DirtyBuffer[i]), OffsetX, OffsetY, DeskDesc, &FullDesc, &ThisDesc); } @@ -395,8 +369,7 @@ DUPL_RETURN DISPLAYMANAGER::CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ ID3D11Buffer* VertBuf = nullptr; hr = m_Device->CreateBuffer(&BufferDesc, &InitData, &VertBuf); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create vertex buffer in dirty rect processing", L"Error", hr, SystemTransitionsExpectedErrors); } UINT Stride = sizeof(VERTEX); @@ -428,50 +401,42 @@ DUPL_RETURN DISPLAYMANAGER::CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ // void DISPLAYMANAGER::CleanRefs() { - if (m_DeviceContext) - { + if (m_DeviceContext) { m_DeviceContext->Release(); m_DeviceContext = nullptr; } - if (m_Device) - { + if (m_Device) { m_Device->Release(); m_Device = nullptr; } - if (m_MoveSurf) - { + if (m_MoveSurf) { m_MoveSurf->Release(); m_MoveSurf = nullptr; } - if (m_VertexShader) - { + if (m_VertexShader) { m_VertexShader->Release(); m_VertexShader = nullptr; } - if (m_PixelShader) - { + if (m_PixelShader) { m_PixelShader->Release(); m_PixelShader = nullptr; } - if (m_InputLayout) - { + if (m_InputLayout) { m_InputLayout->Release(); m_InputLayout = nullptr; } - if (m_SamplerLinear) - { + if (m_SamplerLinear) { m_SamplerLinear->Release(); m_SamplerLinear = nullptr; } - if (m_RTV) - { + if (m_RTV) { m_RTV->Release(); m_RTV = nullptr; } diff --git a/plugins/pluginWinDD/internals/DisplayManager.h b/plugins/pluginWinDD/internals/DisplayManager.h index f9bf69c..3308ecb 100755 --- a/plugins/pluginWinDD/internals/DisplayManager.h +++ b/plugins/pluginWinDD/internals/DisplayManager.h @@ -15,32 +15,32 @@ // class DISPLAYMANAGER { - public: - DISPLAYMANAGER(); - ~DISPLAYMANAGER(); - void InitD3D(DX_RESOURCES* Data); - ID3D11Device* GetDevice(); - DUPL_RETURN ProcessFrame(_In_ FRAME_DATA* Data, _Inout_ ID3D11Texture2D* SharedSurf, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc); - void CleanRefs(); +public: + DISPLAYMANAGER(); + ~DISPLAYMANAGER(); + void InitD3D(DX_RESOURCES* Data); + ID3D11Device* GetDevice(); + DUPL_RETURN ProcessFrame(_In_ FRAME_DATA* Data, _Inout_ ID3D11Texture2D* SharedSurf, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc); + void CleanRefs(); - private: +private: // methods - DUPL_RETURN CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(DirtyCount) RECT* DirtyBuffer, UINT DirtyCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc); - DUPL_RETURN CopyMove(_Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(MoveCount) DXGI_OUTDUPL_MOVE_RECT* MoveBuffer, UINT MoveCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, INT TexWidth, INT TexHeight); - void SetDirtyVert(_Out_writes_(NUMVERTICES) VERTEX* Vertices, _In_ RECT* Dirty, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ D3D11_TEXTURE2D_DESC* FullDesc, _In_ D3D11_TEXTURE2D_DESC* ThisDesc); - void SetMoveRect(_Out_ RECT* SrcRect, _Out_ RECT* DestRect, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ DXGI_OUTDUPL_MOVE_RECT* MoveRect, INT TexWidth, INT TexHeight); + DUPL_RETURN CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(DirtyCount) RECT* DirtyBuffer, UINT DirtyCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc); + DUPL_RETURN CopyMove(_Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(MoveCount) DXGI_OUTDUPL_MOVE_RECT* MoveBuffer, UINT MoveCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, INT TexWidth, INT TexHeight); + void SetDirtyVert(_Out_writes_(NUMVERTICES) VERTEX* Vertices, _In_ RECT* Dirty, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ D3D11_TEXTURE2D_DESC* FullDesc, _In_ D3D11_TEXTURE2D_DESC* ThisDesc); + void SetMoveRect(_Out_ RECT* SrcRect, _Out_ RECT* DestRect, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ DXGI_OUTDUPL_MOVE_RECT* MoveRect, INT TexWidth, INT TexHeight); // variables - ID3D11Device* m_Device; - ID3D11DeviceContext* m_DeviceContext; - ID3D11Texture2D* m_MoveSurf; - ID3D11VertexShader* m_VertexShader; - ID3D11PixelShader* m_PixelShader; - ID3D11InputLayout* m_InputLayout; - ID3D11RenderTargetView* m_RTV; - ID3D11SamplerState* m_SamplerLinear; - BYTE* m_DirtyVertexBufferAlloc; - UINT m_DirtyVertexBufferAllocSize; + ID3D11Device* m_Device; + ID3D11DeviceContext* m_DeviceContext; + ID3D11Texture2D* m_MoveSurf; + ID3D11VertexShader* m_VertexShader; + ID3D11PixelShader* m_PixelShader; + ID3D11InputLayout* m_InputLayout; + ID3D11RenderTargetView* m_RTV; + ID3D11SamplerState* m_SamplerLinear; + BYTE* m_DirtyVertexBufferAlloc; + UINT m_DirtyVertexBufferAllocSize; }; #endif diff --git a/plugins/pluginWinDD/internals/DuplicationManager.cxx b/plugins/pluginWinDD/internals/DuplicationManager.cxx index 995c8ec..34ec896 100755 --- a/plugins/pluginWinDD/internals/DuplicationManager.cxx +++ b/plugins/pluginWinDD/internals/DuplicationManager.cxx @@ -12,24 +12,24 @@ #include <Mfapi.h> static inline HRESULT CopyRGBb32DownTop( - BYTE* pDst, - const BYTE* pSrc, - INT dwWidthDstPixels, - INT dwWidthSrcPixels, - INT dwHeightPixels - ); + BYTE* pDst, + const BYTE* pSrc, + INT dwWidthDstPixels, + INT dwWidthSrcPixels, + INT dwHeightPixels +); // // Constructor sets up references / variables // DUPLICATIONMANAGER::DUPLICATIONMANAGER() : m_DeskDupl(nullptr), - m_AcquiredDesktopImage(nullptr), - m_MetaDataBuffer(nullptr), - m_MetaDataSize(0), - m_OutputNumber(0), - m_Device(nullptr), - m_DeviceContext(nullptr), - m_BufferPtr(nullptr), - m_BufferSize(0) + m_AcquiredDesktopImage(nullptr), + m_MetaDataBuffer(nullptr), + m_MetaDataSize(0), + m_OutputNumber(0), + m_Device(nullptr), + m_DeviceContext(nullptr), + m_BufferPtr(nullptr), + m_BufferSize(0) { RtlZeroMemory(&m_OutputDesc, sizeof(m_OutputDesc)); } @@ -39,41 +39,35 @@ DUPLICATIONMANAGER::DUPLICATIONMANAGER() : m_DeskDupl(nullptr), // DUPLICATIONMANAGER::~DUPLICATIONMANAGER() { - if (m_DeskDupl) - { + if (m_DeskDupl) { m_DeskDupl->Release(); m_DeskDupl = nullptr; } - if (m_AcquiredDesktopImage) - { + if (m_AcquiredDesktopImage) { m_AcquiredDesktopImage->Release(); m_AcquiredDesktopImage = nullptr; } - if (m_MetaDataBuffer) - { + if (m_MetaDataBuffer) { delete [] m_MetaDataBuffer; m_MetaDataBuffer = nullptr; } - if (m_DeviceContext) - { - m_DeviceContext->Release(); - m_DeviceContext = nullptr; - } + if (m_DeviceContext) { + m_DeviceContext->Release(); + m_DeviceContext = nullptr; + } - if (m_Device) - { + if (m_Device) { m_Device->Release(); m_Device = nullptr; } - if (m_BufferPtr) - { - VirtualFree(m_BufferPtr, 0, MEM_RELEASE); - m_BufferPtr = nullptr; - } + if (m_BufferPtr) { + VirtualFree(m_BufferPtr, 0, MEM_RELEASE); + m_BufferPtr = nullptr; + } } // @@ -87,14 +81,13 @@ DUPL_RETURN DUPLICATIONMANAGER::InitDupl(_In_ ID3D11Device* Device, ID3D11Device m_Device = Device; m_Device->AddRef(); - m_DeviceContext = DeviceContext; - m_DeviceContext->AddRef(); + m_DeviceContext = DeviceContext; + m_DeviceContext->AddRef(); // Get DXGI device IDXGIDevice* DxgiDevice = nullptr; HRESULT hr = m_Device->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&DxgiDevice)); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(nullptr, L"Failed to QI for DXGI Device", L"Error", hr); } @@ -103,8 +96,7 @@ DUPL_RETURN DUPLICATIONMANAGER::InitDupl(_In_ ID3D11Device* Device, ID3D11Device hr = DxgiDevice->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&DxgiAdapter)); DxgiDevice->Release(); DxgiDevice = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to get parent DXGI Adapter", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -113,8 +105,7 @@ DUPL_RETURN DUPLICATIONMANAGER::InitDupl(_In_ ID3D11Device* Device, ID3D11Device hr = DxgiAdapter->EnumOutputs(Output, &DxgiOutput); DxgiAdapter->Release(); DxgiAdapter = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to get specified output in DUPLICATIONMANAGER", L"Error", hr, EnumOutputsExpectedErrors); } @@ -125,8 +116,7 @@ DUPL_RETURN DUPLICATIONMANAGER::InitDupl(_In_ ID3D11Device* Device, ID3D11Device hr = DxgiOutput->QueryInterface(__uuidof(DxgiOutput1), reinterpret_cast<void**>(&DxgiOutput1)); DxgiOutput->Release(); DxgiOutput = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(nullptr, L"Failed to QI for DxgiOutput1 in DUPLICATIONMANAGER", L"Error", hr); } @@ -134,10 +124,8 @@ DUPL_RETURN DUPLICATIONMANAGER::InitDupl(_In_ ID3D11Device* Device, ID3D11Device hr = DxgiOutput1->DuplicateOutput(m_Device, &m_DeskDupl); DxgiOutput1->Release(); DxgiOutput1 = nullptr; - if (FAILED(hr)) - { - if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE) - { + if (FAILED(hr)) { + if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE) { MessageBoxW(nullptr, L"There is already the maximum number of applications using the Desktop Duplication API running, please close one of those applications and then try again.", L"Error", MB_OK); return DUPL_RETURN_ERROR_UNEXPECTED; } @@ -153,8 +141,7 @@ DUPL_RETURN DUPLICATIONMANAGER::InitDupl(_In_ ID3D11Device* Device, ID3D11Device DUPL_RETURN DUPLICATIONMANAGER::GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OUTDUPL_FRAME_INFO* FrameInfo, INT OffsetX, INT OffsetY) { // A non-zero mouse update timestamp indicates that there is a mouse position update and optionally a shape change - if (FrameInfo->LastMouseUpdateTime.QuadPart == 0) - { + if (FrameInfo->LastMouseUpdateTime.QuadPart == 0) { return DUPL_RETURN_SUCCESS; } @@ -163,20 +150,17 @@ DUPL_RETURN DUPLICATIONMANAGER::GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OU // Make sure we don't update pointer position wrongly // If pointer is invisible, make sure we did not get an update from another output that the last time that said pointer // was visible, if so, don't set it to invisible or update. - if (!FrameInfo->PointerPosition.Visible && (PtrInfo->WhoUpdatedPositionLast != m_OutputNumber)) - { + if (!FrameInfo->PointerPosition.Visible && (PtrInfo->WhoUpdatedPositionLast != m_OutputNumber)) { UpdatePosition = false; } // If two outputs both say they have a visible, only update if new update has newer timestamp - if (FrameInfo->PointerPosition.Visible && PtrInfo->Visible && (PtrInfo->WhoUpdatedPositionLast != m_OutputNumber) && (PtrInfo->LastTimeStamp.QuadPart > FrameInfo->LastMouseUpdateTime.QuadPart)) - { + if (FrameInfo->PointerPosition.Visible && PtrInfo->Visible && (PtrInfo->WhoUpdatedPositionLast != m_OutputNumber) && (PtrInfo->LastTimeStamp.QuadPart > FrameInfo->LastMouseUpdateTime.QuadPart)) { UpdatePosition = false; } // Update position - if (UpdatePosition) - { + if (UpdatePosition) { PtrInfo->Position.x = FrameInfo->PointerPosition.Position.x + m_OutputDesc.DesktopCoordinates.left - OffsetX; PtrInfo->Position.y = FrameInfo->PointerPosition.Position.y + m_OutputDesc.DesktopCoordinates.top - OffsetY; PtrInfo->WhoUpdatedPositionLast = m_OutputNumber; @@ -185,22 +169,18 @@ DUPL_RETURN DUPLICATIONMANAGER::GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OU } // No new shape - if (FrameInfo->PointerShapeBufferSize == 0) - { + if (FrameInfo->PointerShapeBufferSize == 0) { return DUPL_RETURN_SUCCESS; } // Old buffer too small - if (FrameInfo->PointerShapeBufferSize > PtrInfo->BufferSize) - { - if (PtrInfo->PtrShapeBuffer) - { + if (FrameInfo->PointerShapeBufferSize > PtrInfo->BufferSize) { + if (PtrInfo->PtrShapeBuffer) { delete [] PtrInfo->PtrShapeBuffer; PtrInfo->PtrShapeBuffer = nullptr; } PtrInfo->PtrShapeBuffer = new (std::nothrow) BYTE[FrameInfo->PointerShapeBufferSize]; - if (!PtrInfo->PtrShapeBuffer) - { + if (!PtrInfo->PtrShapeBuffer) { PtrInfo->BufferSize = 0; return ProcessFailure(nullptr, L"Failed to allocate memory for pointer shape in DUPLICATIONMANAGER", L"Error", E_OUTOFMEMORY); } @@ -212,8 +192,7 @@ DUPL_RETURN DUPLICATIONMANAGER::GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OU // Get shape UINT BufferSizeRequired; HRESULT hr = m_DeskDupl->GetFramePointerShape(FrameInfo->PointerShapeBufferSize, reinterpret_cast<VOID*>(PtrInfo->PtrShapeBuffer), &BufferSizeRequired, &(PtrInfo->ShapeInfo)); - if (FAILED(hr)) - { + if (FAILED(hr)) { delete [] PtrInfo->PtrShapeBuffer; PtrInfo->PtrShapeBuffer = nullptr; PtrInfo->BufferSize = 0; @@ -235,21 +214,18 @@ DUPL_RETURN DUPLICATIONMANAGER::GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Tim // Get new frame HRESULT hr = m_DeskDupl->AcquireNextFrame(500, &FrameInfo, &DesktopResource); - if (hr == DXGI_ERROR_WAIT_TIMEOUT) - { + if (hr == DXGI_ERROR_WAIT_TIMEOUT) { *Timeout = true; return DUPL_RETURN_SUCCESS; } *Timeout = false; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to acquire next frame in DUPLICATIONMANAGER", L"Error", hr, FrameInfoExpectedErrors); } // If still holding old frame, destroy it - if (m_AcquiredDesktopImage) - { + if (m_AcquiredDesktopImage) { m_AcquiredDesktopImage->Release(); m_AcquiredDesktopImage = nullptr; } @@ -258,25 +234,20 @@ DUPL_RETURN DUPLICATIONMANAGER::GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Tim hr = DesktopResource->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void **>(&m_AcquiredDesktopImage)); DesktopResource->Release(); DesktopResource = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(nullptr, L"Failed to QI for ID3D11Texture2D from acquired IDXGIResource in DUPLICATIONMANAGER", L"Error", hr); } // Get metadata - if (FrameInfo.TotalMetadataBufferSize) - { + if (FrameInfo.TotalMetadataBufferSize) { // Old buffer too small - if (FrameInfo.TotalMetadataBufferSize > m_MetaDataSize) - { - if (m_MetaDataBuffer) - { + if (FrameInfo.TotalMetadataBufferSize > m_MetaDataSize) { + if (m_MetaDataBuffer) { delete [] m_MetaDataBuffer; m_MetaDataBuffer = nullptr; } m_MetaDataBuffer = new (std::nothrow) BYTE[FrameInfo.TotalMetadataBufferSize]; - if (!m_MetaDataBuffer) - { + if (!m_MetaDataBuffer) { m_MetaDataSize = 0; Data->MoveCount = 0; Data->DirtyCount = 0; @@ -289,8 +260,7 @@ DUPL_RETURN DUPLICATIONMANAGER::GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Tim // Get move rectangles hr = m_DeskDupl->GetFrameMoveRects(BufSize, reinterpret_cast<DXGI_OUTDUPL_MOVE_RECT*>(m_MetaDataBuffer), &BufSize); - if (FAILED(hr)) - { + if (FAILED(hr)) { Data->MoveCount = 0; Data->DirtyCount = 0; return ProcessFailure(nullptr, L"Failed to get frame move rects in DUPLICATIONMANAGER", L"Error", hr, FrameInfoExpectedErrors); @@ -302,8 +272,7 @@ DUPL_RETURN DUPLICATIONMANAGER::GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Tim // Get dirty rectangles hr = m_DeskDupl->GetFrameDirtyRects(BufSize, reinterpret_cast<RECT*>(DirtyRects), &BufSize); - if (FAILED(hr)) - { + if (FAILED(hr)) { Data->MoveCount = 0; Data->DirtyCount = 0; return ProcessFailure(nullptr, L"Failed to get frame dirty rects in DUPLICATIONMANAGER", L"Error", hr, FrameInfoExpectedErrors); @@ -325,13 +294,11 @@ DUPL_RETURN DUPLICATIONMANAGER::GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Tim DUPL_RETURN DUPLICATIONMANAGER::DoneWithFrame() { HRESULT hr = m_DeskDupl->ReleaseFrame(); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to release frame in DUPLICATIONMANAGER", L"Error", hr, FrameInfoExpectedErrors); } - if (m_AcquiredDesktopImage) - { + if (m_AcquiredDesktopImage) { m_AcquiredDesktopImage->Release(); m_AcquiredDesktopImage = nullptr; } @@ -350,150 +317,138 @@ void DUPLICATIONMANAGER::GetOutputDesc(_Out_ DXGI_OUTPUT_DESC* DescPtr) HRESULT DUPLICATIONMANAGER::SendData(struct tmedia_producer_s* pProducer, FRAME_DATA* FrameData) { - HRESULT hr = E_FAIL; - D3D11_TEXTURE2D_DESC CopyBufferDesc = {0}; - D3D11_TEXTURE2D_DESC FullDesc; - DXGI_MAPPED_RECT MappedSurface; - D3D11_BOX Box; - UINT BuffSize; - - ID3D11Texture2D* CopyBuffer = nullptr; - IDXGISurface* CopySurface = nullptr; - ID3D11Device* Device = nullptr; - - FrameData->Frame->GetDesc(&FullDesc); - - CopyBufferDesc.Width = FullDesc.Width; - CopyBufferDesc.Height = FullDesc.Height; - CopyBufferDesc.MipLevels = 1; - CopyBufferDesc.ArraySize = 1; - CopyBufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; - CopyBufferDesc.SampleDesc.Count = 1; - CopyBufferDesc.SampleDesc.Quality = 0; - CopyBufferDesc.Usage = D3D11_USAGE_STAGING; - CopyBufferDesc.BindFlags = 0; - CopyBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; - CopyBufferDesc.MiscFlags = 0; - - FrameData->Frame->GetDevice(&Device); - if (!Device) - { - hr = E_POINTER; - ProcessFailure(m_Device, L"Failed to get device", L"Error", hr, SystemTransitionsExpectedErrors); - goto bail; - } - - hr = Device->CreateTexture2D(&CopyBufferDesc, nullptr, &CopyBuffer); - if (FAILED(hr)) - { - ProcessFailure(m_Device, L"Failed creating staging texture for pointer", L"Error", hr, SystemTransitionsExpectedErrors); - goto bail; - } - - Box.left = 0; - Box.top = 0; - Box.right = CopyBufferDesc.Width; - Box.bottom = CopyBufferDesc.Height; - Box.front = 0; - Box.back = 1; - m_DeviceContext->CopySubresourceRegion(CopyBuffer, 0, 0, 0, 0, FrameData->Frame, 0, &Box); - - hr = CopyBuffer->QueryInterface(__uuidof(IDXGISurface), (void **)&CopySurface); - if (FAILED(hr)) - { - ProcessFailure(nullptr, L"Failed to QI staging texture into IDXGISurface for pointer", L"Error", hr, SystemTransitionsExpectedErrors); - goto bail; - } - - BuffSize = CopyBufferDesc.Width * CopyBufferDesc.Height * 4; - if (m_BufferSize < BuffSize) - { - if (m_BufferPtr) - { - VirtualFree(m_BufferPtr, 0, MEM_RELEASE); - m_BufferSize = 0; - } - if (!(m_BufferPtr = (BYTE*)VirtualAlloc(NULL, BuffSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE))) - { - ProcessFailure(Device, L"Failed to allocate memory", L"Error", hr, SystemTransitionsExpectedErrors); - goto bail; - } - m_BufferSize = BuffSize; - } - - hr = CopySurface->Map(&MappedSurface, DXGI_MAP_READ); // *** MAP *** // - if (FAILED(hr)) - { - ProcessFailure(Device, L"Failed to map surface for pointer", L"Error", hr, SystemTransitionsExpectedErrors); - goto bail; - } - - pProducer->video.width = CopyBufferDesc.Width; - pProducer->video.height = CopyBufferDesc.Height; + HRESULT hr = E_FAIL; + D3D11_TEXTURE2D_DESC CopyBufferDesc = {0}; + D3D11_TEXTURE2D_DESC FullDesc; + DXGI_MAPPED_RECT MappedSurface; + D3D11_BOX Box; + UINT BuffSize; + + ID3D11Texture2D* CopyBuffer = nullptr; + IDXGISurface* CopySurface = nullptr; + ID3D11Device* Device = nullptr; + + FrameData->Frame->GetDesc(&FullDesc); + + CopyBufferDesc.Width = FullDesc.Width; + CopyBufferDesc.Height = FullDesc.Height; + CopyBufferDesc.MipLevels = 1; + CopyBufferDesc.ArraySize = 1; + CopyBufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + CopyBufferDesc.SampleDesc.Count = 1; + CopyBufferDesc.SampleDesc.Quality = 0; + CopyBufferDesc.Usage = D3D11_USAGE_STAGING; + CopyBufferDesc.BindFlags = 0; + CopyBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + CopyBufferDesc.MiscFlags = 0; + + FrameData->Frame->GetDevice(&Device); + if (!Device) { + hr = E_POINTER; + ProcessFailure(m_Device, L"Failed to get device", L"Error", hr, SystemTransitionsExpectedErrors); + goto bail; + } + + hr = Device->CreateTexture2D(&CopyBufferDesc, nullptr, &CopyBuffer); + if (FAILED(hr)) { + ProcessFailure(m_Device, L"Failed creating staging texture for pointer", L"Error", hr, SystemTransitionsExpectedErrors); + goto bail; + } + + Box.left = 0; + Box.top = 0; + Box.right = CopyBufferDesc.Width; + Box.bottom = CopyBufferDesc.Height; + Box.front = 0; + Box.back = 1; + m_DeviceContext->CopySubresourceRegion(CopyBuffer, 0, 0, 0, 0, FrameData->Frame, 0, &Box); + + hr = CopyBuffer->QueryInterface(__uuidof(IDXGISurface), (void **)&CopySurface); + if (FAILED(hr)) { + ProcessFailure(nullptr, L"Failed to QI staging texture into IDXGISurface for pointer", L"Error", hr, SystemTransitionsExpectedErrors); + goto bail; + } + + BuffSize = CopyBufferDesc.Width * CopyBufferDesc.Height * 4; + if (m_BufferSize < BuffSize) { + if (m_BufferPtr) { + VirtualFree(m_BufferPtr, 0, MEM_RELEASE); + m_BufferSize = 0; + } + if (!(m_BufferPtr = (BYTE*)VirtualAlloc(NULL, BuffSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE))) { + ProcessFailure(Device, L"Failed to allocate memory", L"Error", hr, SystemTransitionsExpectedErrors); + goto bail; + } + m_BufferSize = BuffSize; + } + + hr = CopySurface->Map(&MappedSurface, DXGI_MAP_READ); // *** MAP *** // + if (FAILED(hr)) { + ProcessFailure(Device, L"Failed to map surface for pointer", L"Error", hr, SystemTransitionsExpectedErrors); + goto bail; + } + + pProducer->video.width = CopyBufferDesc.Width; + pProducer->video.height = CopyBufferDesc.Height; #if 0 - hr = MFCopyImage( - m_BufferPtr, - (LONG)(CopyBufferDesc.Width << 2), - (BYTE*)MappedSurface.pBits, - (LONG)MappedSurface.Pitch, - (DWORD)(CopyBufferDesc.Width << 2), - (DWORD)CopyBufferDesc.Height - ); + hr = MFCopyImage( + m_BufferPtr, + (LONG)(CopyBufferDesc.Width << 2), + (BYTE*)MappedSurface.pBits, + (LONG)MappedSurface.Pitch, + (DWORD)(CopyBufferDesc.Width << 2), + (DWORD)CopyBufferDesc.Height + ); #else; - hr = CopyRGBb32DownTop( - m_BufferPtr, - MappedSurface.pBits, - CopyBufferDesc.Width, - (MappedSurface.Pitch >> 2), // Bytes -> Pixels - CopyBufferDesc.Height); + hr = CopyRGBb32DownTop( + m_BufferPtr, + MappedSurface.pBits, + CopyBufferDesc.Width, + (MappedSurface.Pitch >> 2), // Bytes -> Pixels + CopyBufferDesc.Height); #endif - pProducer->enc_cb.callback(pProducer->enc_cb.callback_data, m_BufferPtr, BuffSize); + pProducer->enc_cb.callback(pProducer->enc_cb.callback_data, m_BufferPtr, BuffSize); - CopySurface->Unmap(); // *** UNMAP *** // + CopySurface->Unmap(); // *** UNMAP *** // bail: - if (CopyBuffer) - { - CopyBuffer->Release(); - } - if (CopySurface) - { - CopySurface->Release(); - } - if (Device) - { - Device->Release(); - } - return hr; + if (CopyBuffer) { + CopyBuffer->Release(); + } + if (CopySurface) { + CopySurface->Release(); + } + if (Device) { + Device->Release(); + } + return hr; } // For RGB32: // Direct3D -> Top-Down // Video Processor -> Down-Top static inline HRESULT CopyRGBb32DownTop( - BYTE* pDst, - const BYTE* pSrc, - INT dwWidthDstPixels, - INT dwWidthSrcPixels, - INT dwHeightPixels - ) + BYTE* pDst, + const BYTE* pSrc, + INT dwWidthDstPixels, + INT dwWidthSrcPixels, + INT dwHeightPixels +) { - RGBQUAD *pSrcPixel = &((RGBQUAD*)pSrc)[(dwWidthSrcPixels * dwHeightPixels) - dwWidthSrcPixels]; - RGBQUAD *pDestPixel = &((RGBQUAD*)pDst)[0]; - - register INT x; - register INT y; - - for (y = dwHeightPixels; y > 0; --y) - { - for (x = 0; x < dwWidthDstPixels; ++x) - { - pDestPixel[x] = pSrcPixel[x]; - } - pDestPixel += dwWidthDstPixels; - pSrcPixel -= dwWidthSrcPixels; - } - return S_OK; + RGBQUAD *pSrcPixel = &((RGBQUAD*)pSrc)[(dwWidthSrcPixels * dwHeightPixels) - dwWidthSrcPixels]; + RGBQUAD *pDestPixel = &((RGBQUAD*)pDst)[0]; + + register INT x; + register INT y; + + for (y = dwHeightPixels; y > 0; --y) { + for (x = 0; x < dwWidthDstPixels; ++x) { + pDestPixel[x] = pSrcPixel[x]; + } + pDestPixel += dwWidthDstPixels; + pSrcPixel -= dwWidthSrcPixels; + } + return S_OK; }
\ No newline at end of file diff --git a/plugins/pluginWinDD/internals/DuplicationManager.h b/plugins/pluginWinDD/internals/DuplicationManager.h index 2c44b57..8f98145 100755 --- a/plugins/pluginWinDD/internals/DuplicationManager.h +++ b/plugins/pluginWinDD/internals/DuplicationManager.h @@ -15,29 +15,29 @@ // class DUPLICATIONMANAGER { - public: - DUPLICATIONMANAGER(); - ~DUPLICATIONMANAGER(); - _Success_(*Timeout == false && return == DUPL_RETURN_SUCCESS) DUPL_RETURN GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Timeout); - DUPL_RETURN DoneWithFrame(); - DUPL_RETURN InitDupl(_In_ ID3D11Device* Device, ID3D11DeviceContext* DeviceContext, UINT Output); - DUPL_RETURN GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OUTDUPL_FRAME_INFO* FrameInfo, INT OffsetX, INT OffsetY); - void GetOutputDesc(_Out_ DXGI_OUTPUT_DESC* DescPtr); - HRESULT SendData(struct tmedia_producer_s* pProducer, FRAME_DATA* FrameData); +public: + DUPLICATIONMANAGER(); + ~DUPLICATIONMANAGER(); + _Success_(*Timeout == false && return == DUPL_RETURN_SUCCESS) DUPL_RETURN GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Timeout); + DUPL_RETURN DoneWithFrame(); + DUPL_RETURN InitDupl(_In_ ID3D11Device* Device, ID3D11DeviceContext* DeviceContext, UINT Output); + DUPL_RETURN GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OUTDUPL_FRAME_INFO* FrameInfo, INT OffsetX, INT OffsetY); + void GetOutputDesc(_Out_ DXGI_OUTPUT_DESC* DescPtr); + HRESULT SendData(struct tmedia_producer_s* pProducer, FRAME_DATA* FrameData); - private: +private: // vars - IDXGIOutputDuplication* m_DeskDupl; - ID3D11Texture2D* m_AcquiredDesktopImage; - _Field_size_bytes_(m_MetaDataSize) BYTE* m_MetaDataBuffer; - UINT m_MetaDataSize; - UINT m_OutputNumber; - DXGI_OUTPUT_DESC m_OutputDesc; - ID3D11Device* m_Device; - ID3D11DeviceContext* m_DeviceContext; - BYTE* m_BufferPtr; - UINT m_BufferSize; + IDXGIOutputDuplication* m_DeskDupl; + ID3D11Texture2D* m_AcquiredDesktopImage; + _Field_size_bytes_(m_MetaDataSize) BYTE* m_MetaDataBuffer; + UINT m_MetaDataSize; + UINT m_OutputNumber; + DXGI_OUTPUT_DESC m_OutputDesc; + ID3D11Device* m_Device; + ID3D11DeviceContext* m_DeviceContext; + BYTE* m_BufferPtr; + UINT m_BufferSize; }; #endif diff --git a/plugins/pluginWinDD/internals/OutputManager.cxx b/plugins/pluginWinDD/internals/OutputManager.cxx index 7468cf2..a82f84c 100755 --- a/plugins/pluginWinDD/internals/OutputManager.cxx +++ b/plugins/pluginWinDD/internals/OutputManager.cxx @@ -12,20 +12,20 @@ using namespace DirectX; // Constructor NULLs out all pointers & sets appropriate var vals // OUTPUTMANAGER::OUTPUTMANAGER() : m_SwapChain(nullptr), - m_Device(nullptr), - m_Factory(nullptr), - m_DeviceContext(nullptr), - m_RTV(nullptr), - m_SamplerLinear(nullptr), - m_BlendState(nullptr), - m_VertexShader(nullptr), - m_PixelShader(nullptr), - m_InputLayout(nullptr), - m_SharedSurf(nullptr), - m_KeyMutex(nullptr), - m_WindowHandle(nullptr), - m_NeedsResize(false), - m_OcclusionCookie(0) + m_Device(nullptr), + m_Factory(nullptr), + m_DeviceContext(nullptr), + m_RTV(nullptr), + m_SamplerLinear(nullptr), + m_BlendState(nullptr), + m_VertexShader(nullptr), + m_PixelShader(nullptr), + m_InputLayout(nullptr), + m_SharedSurf(nullptr), + m_KeyMutex(nullptr), + m_WindowHandle(nullptr), + m_NeedsResize(false), + m_OcclusionCookie(0) { } @@ -56,8 +56,7 @@ DUPL_RETURN OUTPUTMANAGER::InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* m_WindowHandle = Window; // Driver types supported - D3D_DRIVER_TYPE DriverTypes[] = - { + D3D_DRIVER_TYPE DriverTypes[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP, D3D_DRIVER_TYPE_REFERENCE, @@ -65,8 +64,7 @@ DUPL_RETURN OUTPUTMANAGER::InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* UINT NumDriverTypes = ARRAYSIZE(DriverTypes); // Feature levels supported - D3D_FEATURE_LEVEL FeatureLevels[] = - { + D3D_FEATURE_LEVEL FeatureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, @@ -76,26 +74,22 @@ DUPL_RETURN OUTPUTMANAGER::InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* D3D_FEATURE_LEVEL FeatureLevel; // Create device - for (UINT DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex) - { + for (UINT DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex) { hr = D3D11CreateDevice(nullptr, DriverTypes[DriverTypeIndex], nullptr, 0, FeatureLevels, NumFeatureLevels, - D3D11_SDK_VERSION, &m_Device, &FeatureLevel, &m_DeviceContext); - if (SUCCEEDED(hr)) - { + D3D11_SDK_VERSION, &m_Device, &FeatureLevel, &m_DeviceContext); + if (SUCCEEDED(hr)) { // Device creation succeeded, no need to loop anymore break; } } - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Device creation in OUTPUTMANAGER failed", L"Error", hr, SystemTransitionsExpectedErrors); } // Get DXGI factory IDXGIDevice* DxgiDevice = nullptr; hr = m_Device->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&DxgiDevice)); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(nullptr, L"Failed to QI for DXGI Device", L"Error", hr, nullptr); } @@ -103,79 +97,69 @@ DUPL_RETURN OUTPUTMANAGER::InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* hr = DxgiDevice->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&DxgiAdapter)); DxgiDevice->Release(); DxgiDevice = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to get parent DXGI Adapter", L"Error", hr, SystemTransitionsExpectedErrors); } hr = DxgiAdapter->GetParent(__uuidof(IDXGIFactory2), reinterpret_cast<void**>(&m_Factory)); DxgiAdapter->Release(); DxgiAdapter = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to get parent DXGI Factory", L"Error", hr, SystemTransitionsExpectedErrors); } // Register for occlusion status windows message - if (m_WindowHandle) - { - hr = m_Factory->RegisterOcclusionStatusWindow(Window, OCCLUSION_STATUS_MSG, &m_OcclusionCookie); - if (FAILED(hr)) - { - return ProcessFailure(m_Device, L"Failed to register for occlusion message", L"Error", hr, SystemTransitionsExpectedErrors); - } - } + if (m_WindowHandle) { + hr = m_Factory->RegisterOcclusionStatusWindow(Window, OCCLUSION_STATUS_MSG, &m_OcclusionCookie); + if (FAILED(hr)) { + return ProcessFailure(m_Device, L"Failed to register for occlusion message", L"Error", hr, SystemTransitionsExpectedErrors); + } + } // Get window size RECT WindowRect; - GetClientRect(m_WindowHandle ? m_WindowHandle : GetDesktopWindow(), &WindowRect); + GetClientRect(m_WindowHandle ? m_WindowHandle : GetDesktopWindow(), &WindowRect); UINT Width = WindowRect.right - WindowRect.left; UINT Height = WindowRect.bottom - WindowRect.top; - if (m_WindowHandle) - { - // Create swapchain for window - DXGI_SWAP_CHAIN_DESC1 SwapChainDesc; - RtlZeroMemory(&SwapChainDesc, sizeof(SwapChainDesc)); - - SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; - SwapChainDesc.BufferCount = 2; - SwapChainDesc.Width = Width; - SwapChainDesc.Height = Height; - SwapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; - SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; - SwapChainDesc.SampleDesc.Count = 1; - SwapChainDesc.SampleDesc.Quality = 0; - hr = m_Factory->CreateSwapChainForHwnd(m_Device, Window, &SwapChainDesc, nullptr, nullptr, &m_SwapChain); - if (FAILED(hr)) - { - return ProcessFailure(m_Device, L"Failed to create window swapchain", L"Error", hr, SystemTransitionsExpectedErrors); - } - - // Disable the ALT-ENTER shortcut for entering full-screen mode - hr = m_Factory->MakeWindowAssociation(Window, DXGI_MWA_NO_ALT_ENTER); - if (FAILED(hr)) - { - return ProcessFailure(m_Device, L"Failed to make window association", L"Error", hr, SystemTransitionsExpectedErrors); - } - } + if (m_WindowHandle) { + // Create swapchain for window + DXGI_SWAP_CHAIN_DESC1 SwapChainDesc; + RtlZeroMemory(&SwapChainDesc, sizeof(SwapChainDesc)); + + SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + SwapChainDesc.BufferCount = 2; + SwapChainDesc.Width = Width; + SwapChainDesc.Height = Height; + SwapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + SwapChainDesc.SampleDesc.Count = 1; + SwapChainDesc.SampleDesc.Quality = 0; + hr = m_Factory->CreateSwapChainForHwnd(m_Device, Window, &SwapChainDesc, nullptr, nullptr, &m_SwapChain); + if (FAILED(hr)) { + return ProcessFailure(m_Device, L"Failed to create window swapchain", L"Error", hr, SystemTransitionsExpectedErrors); + } + + // Disable the ALT-ENTER shortcut for entering full-screen mode + hr = m_Factory->MakeWindowAssociation(Window, DXGI_MWA_NO_ALT_ENTER); + if (FAILED(hr)) { + return ProcessFailure(m_Device, L"Failed to make window association", L"Error", hr, SystemTransitionsExpectedErrors); + } + } // Create shared texture DUPL_RETURN Return = CreateSharedSurf(SingleOutput, OutCount, DeskBounds); - if (Return != DUPL_RETURN_SUCCESS) - { + if (Return != DUPL_RETURN_SUCCESS) { return Return; } // Make new render target view - if (m_WindowHandle) - { - Return = MakeRTV(); - if (Return != DUPL_RETURN_SUCCESS) - { - return Return; - } - } + if (m_WindowHandle) { + Return = MakeRTV(); + if (Return != DUPL_RETURN_SUCCESS) { + return Return; + } + } // Set view port SetViewPort(Width, Height); @@ -191,41 +175,37 @@ DUPL_RETURN OUTPUTMANAGER::InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* SampDesc.MinLOD = 0; SampDesc.MaxLOD = D3D11_FLOAT32_MAX; hr = m_Device->CreateSamplerState(&SampDesc, &m_SamplerLinear); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create sampler state in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } - if (m_WindowHandle) - { - // Create the blend state - D3D11_BLEND_DESC BlendStateDesc; - BlendStateDesc.AlphaToCoverageEnable = FALSE; - BlendStateDesc.IndependentBlendEnable = FALSE; - BlendStateDesc.RenderTarget[0].BlendEnable = TRUE; - BlendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; - BlendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; - BlendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; - BlendStateDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; - BlendStateDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; - BlendStateDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; - BlendStateDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; - hr = m_Device->CreateBlendState(&BlendStateDesc, &m_BlendState); - if (FAILED(hr)) - { - return ProcessFailure(m_Device, L"Failed to create blend state in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); - } - - // Initialize shaders - Return = InitShaders(); - if (Return != DUPL_RETURN_SUCCESS) - { - return Return; - } - - GetWindowRect(m_WindowHandle, &WindowRect); - MoveWindow(m_WindowHandle, WindowRect.left, WindowRect.top, (DeskBounds->right - DeskBounds->left) / 2, (DeskBounds->bottom - DeskBounds->top) / 2, TRUE); - } + if (m_WindowHandle) { + // Create the blend state + D3D11_BLEND_DESC BlendStateDesc; + BlendStateDesc.AlphaToCoverageEnable = FALSE; + BlendStateDesc.IndependentBlendEnable = FALSE; + BlendStateDesc.RenderTarget[0].BlendEnable = TRUE; + BlendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; + BlendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; + BlendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; + BlendStateDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; + BlendStateDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; + BlendStateDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; + BlendStateDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; + hr = m_Device->CreateBlendState(&BlendStateDesc, &m_BlendState); + if (FAILED(hr)) { + return ProcessFailure(m_Device, L"Failed to create blend state in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); + } + + // Initialize shaders + Return = InitShaders(); + if (Return != DUPL_RETURN_SUCCESS) { + return Return; + } + + GetWindowRect(m_WindowHandle, &WindowRect); + MoveWindow(m_WindowHandle, WindowRect.left, WindowRect.top, (DeskBounds->right - DeskBounds->left) / 2, (DeskBounds->bottom - DeskBounds->top) / 2, TRUE); + } return Return; } @@ -240,8 +220,7 @@ DUPL_RETURN OUTPUTMANAGER::CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCou // Get DXGI resources IDXGIDevice* DxgiDevice = nullptr; hr = m_Device->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&DxgiDevice)); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(nullptr, L"Failed to QI for DXGI Device", L"Error", hr); } @@ -249,8 +228,7 @@ DUPL_RETURN OUTPUTMANAGER::CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCou hr = DxgiDevice->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&DxgiAdapter)); DxgiDevice->Release(); DxgiDevice = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to get parent DXGI Adapter", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -264,19 +242,15 @@ DUPL_RETURN OUTPUTMANAGER::CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCou // Figure out right dimensions for full size desktop texture and # of outputs to duplicate UINT OutputCount; - if (SingleOutput < 0) - { + if (SingleOutput < 0) { hr = S_OK; - for (OutputCount = 0; SUCCEEDED(hr); ++OutputCount) - { - if (DxgiOutput) - { + for (OutputCount = 0; SUCCEEDED(hr); ++OutputCount) { + if (DxgiOutput) { DxgiOutput->Release(); DxgiOutput = nullptr; } hr = DxgiAdapter->EnumOutputs(OutputCount, &DxgiOutput); - if (DxgiOutput && (hr != DXGI_ERROR_NOT_FOUND)) - { + if (DxgiOutput && (hr != DXGI_ERROR_NOT_FOUND)) { DXGI_OUTPUT_DESC DesktopDesc; DxgiOutput->GetDesc(&DesktopDesc); @@ -289,11 +263,9 @@ DUPL_RETURN OUTPUTMANAGER::CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCou --OutputCount; } - else - { + else { hr = DxgiAdapter->EnumOutputs(SingleOutput, &DxgiOutput); - if (FAILED(hr)) - { + if (FAILED(hr)) { DxgiAdapter->Release(); DxgiAdapter = nullptr; return ProcessFailure(m_Device, L"Output specified to be duplicated does not exist", L"Error", hr); @@ -314,8 +286,7 @@ DUPL_RETURN OUTPUTMANAGER::CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCou // Set passed in output count variable *OutCount = OutputCount; - if (OutputCount == 0) - { + if (OutputCount == 0) { // We could not find any outputs, the system must be in a transition so return expected error // so we will attempt to recreate return DUPL_RETURN_ERROR_EXPECTED; @@ -336,10 +307,8 @@ DUPL_RETURN OUTPUTMANAGER::CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCou DeskTexD.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX; hr = m_Device->CreateTexture2D(&DeskTexD, nullptr, &m_SharedSurf); - if (FAILED(hr)) - { - if (OutputCount != 1) - { + if (FAILED(hr)) { + if (OutputCount != 1) { // If we are duplicating the complete desktop we try to create a single texture to hold the // complete desktop image and blit updates from the per output DDA interface. The GPU can // always support a texture size of the maximum resolution of any single output but there is no @@ -348,16 +317,14 @@ DUPL_RETURN OUTPUTMANAGER::CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCou // we could revert back to using GDI to update the window in this failure case. return ProcessFailure(m_Device, L"Failed to create DirectX shared texture - we are attempting to create a texture the size of the complete desktop and this may be larger than the maximum texture size of your GPU. Please try again using the -output command line parameter to duplicate only 1 monitor or configure your computer to a single monitor configuration", L"Error", hr, SystemTransitionsExpectedErrors); } - else - { + else { return ProcessFailure(m_Device, L"Failed to create shared texture", L"Error", hr, SystemTransitionsExpectedErrors); } } // Get keyed mutex hr = m_SharedSurf->QueryInterface(__uuidof(IDXGIKeyedMutex), reinterpret_cast<void**>(&m_KeyMutex)); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to query for keyed mutex in OUTPUTMANAGER", L"Error", hr); } @@ -376,23 +343,19 @@ DUPL_RETURN OUTPUTMANAGER::UpdateApplicationWindow(_In_ PTR_INFO* PointerInfo, _ // Try and acquire sync on common display buffer HRESULT hr = m_KeyMutex->AcquireSync(1, 100); - if (hr == static_cast<HRESULT>(WAIT_TIMEOUT)) - { + if (hr == static_cast<HRESULT>(WAIT_TIMEOUT)) { // Another thread has the keyed mutex so try again later return DUPL_RETURN_SUCCESS; } - else if (FAILED(hr)) - { + else if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to acquire Keyed mutex in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } // Got mutex, so draw DUPL_RETURN Ret = DrawFrame(); - if (Ret == DUPL_RETURN_SUCCESS) - { + if (Ret == DUPL_RETURN_SUCCESS) { // We have keyed mutex so we can access the mouse info - if (PointerInfo->Visible) - { + if (PointerInfo->Visible) { // Draw mouse into texture Ret = DrawMouse(PointerInfo); } @@ -400,27 +363,22 @@ DUPL_RETURN OUTPUTMANAGER::UpdateApplicationWindow(_In_ PTR_INFO* PointerInfo, _ // Release keyed mutex hr = m_KeyMutex->ReleaseSync(0); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to Release Keyed mutex in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } // Present to window if all worked - if (Ret == DUPL_RETURN_SUCCESS) - { + if (Ret == DUPL_RETURN_SUCCESS) { // Present to window - if (m_SwapChain) - { - hr = m_SwapChain->Present(1, 0); - if (FAILED(hr)) - { - return ProcessFailure(m_Device, L"Failed to present", L"Error", hr, SystemTransitionsExpectedErrors); - } - else if (hr == DXGI_STATUS_OCCLUDED) - { - *Occluded = true; - } - } + if (m_SwapChain) { + hr = m_SwapChain->Present(1, 0); + if (FAILED(hr)) { + return ProcessFailure(m_Device, L"Failed to present", L"Error", hr, SystemTransitionsExpectedErrors); + } + else if (hr == DXGI_STATUS_OCCLUDED) { + *Occluded = true; + } + } } return Ret; @@ -436,8 +394,7 @@ HANDLE OUTPUTMANAGER::GetSharedHandle() // QI IDXGIResource interface to synchronized shared surface. IDXGIResource* DXGIResource = nullptr; HRESULT hr = m_SharedSurf->QueryInterface(__uuidof(IDXGIResource), reinterpret_cast<void**>(&DXGIResource)); - if (SUCCEEDED(hr)) - { + if (SUCCEEDED(hr)) { // Obtain handle to IDXGIResource object. DXGIResource->GetSharedHandle(&Hnd); DXGIResource->Release(); @@ -455,19 +412,16 @@ DUPL_RETURN OUTPUTMANAGER::DrawFrame() HRESULT hr; // If window was resized, resize swapchain - if (m_NeedsResize) - { + if (m_NeedsResize) { DUPL_RETURN Ret = ResizeSwapChain(); - if (Ret != DUPL_RETURN_SUCCESS) - { + if (Ret != DUPL_RETURN_SUCCESS) { return Ret; } m_NeedsResize = false; } // Vertices for drawing whole texture - VERTEX Vertices[NUMVERTICES] = - { + VERTEX Vertices[NUMVERTICES] = { {XMFLOAT3(-1.0f, -1.0f, 0), XMFLOAT2(0.0f, 1.0f)}, {XMFLOAT3(-1.0f, 1.0f, 0), XMFLOAT2(0.0f, 0.0f)}, {XMFLOAT3(1.0f, -1.0f, 0), XMFLOAT2(1.0f, 1.0f)}, @@ -488,8 +442,7 @@ DUPL_RETURN OUTPUTMANAGER::DrawFrame() // Create new shader resource view ID3D11ShaderResourceView* ShaderResource = nullptr; hr = m_Device->CreateShaderResourceView(m_SharedSurf, &ShaderDesc, &ShaderResource); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create shader resource when drawing a frame", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -519,8 +472,7 @@ DUPL_RETURN OUTPUTMANAGER::DrawFrame() // Create vertex buffer hr = m_Device->CreateBuffer(&BufferDesc, &InitData, &VertexBuffer); - if (FAILED(hr)) - { + if (FAILED(hr)) { ShaderResource->Release(); ShaderResource = nullptr; return ProcessFailure(m_Device, L"Failed to create vertex buffer when drawing a frame", L"Error", hr, SystemTransitionsExpectedErrors); @@ -543,7 +495,7 @@ DUPL_RETURN OUTPUTMANAGER::DrawFrame() // // Process both masked and monochrome pointers // -DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInfo, _Out_ INT* PtrWidth, _Out_ INT* PtrHeight, _Out_ INT* PtrLeft, _Out_ INT* PtrTop, _Outptr_result_bytebuffer_(*PtrHeight * *PtrWidth * BPP) BYTE** InitBuffer, _Out_ D3D11_BOX* Box) +DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInfo, _Out_ INT* PtrWidth, _Out_ INT* PtrHeight, _Out_ INT* PtrLeft, _Out_ INT* PtrTop, _Outptr_result_bytebuffer_(*PtrHeight **PtrWidth * BPP) BYTE** InitBuffer, _Out_ D3D11_BOX* Box) { // Desktop dimensions D3D11_TEXTURE2D_DESC FullDesc; @@ -556,39 +508,31 @@ DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInf INT GivenTop = PtrInfo->Position.y; // Figure out if any adjustment is needed for out of bound positions - if (GivenLeft < 0) - { + if (GivenLeft < 0) { *PtrWidth = GivenLeft + static_cast<INT>(PtrInfo->ShapeInfo.Width); } - else if ((GivenLeft + static_cast<INT>(PtrInfo->ShapeInfo.Width)) > DesktopWidth) - { + else if ((GivenLeft + static_cast<INT>(PtrInfo->ShapeInfo.Width)) > DesktopWidth) { *PtrWidth = DesktopWidth - GivenLeft; } - else - { + else { *PtrWidth = static_cast<INT>(PtrInfo->ShapeInfo.Width); } - if (IsMono) - { + if (IsMono) { PtrInfo->ShapeInfo.Height = PtrInfo->ShapeInfo.Height / 2; } - if (GivenTop < 0) - { + if (GivenTop < 0) { *PtrHeight = GivenTop + static_cast<INT>(PtrInfo->ShapeInfo.Height); } - else if ((GivenTop + static_cast<INT>(PtrInfo->ShapeInfo.Height)) > DesktopHeight) - { + else if ((GivenTop + static_cast<INT>(PtrInfo->ShapeInfo.Height)) > DesktopHeight) { *PtrHeight = DesktopHeight - GivenTop; } - else - { + else { *PtrHeight = static_cast<INT>(PtrInfo->ShapeInfo.Height); } - if (IsMono) - { + if (IsMono) { PtrInfo->ShapeInfo.Height = PtrInfo->ShapeInfo.Height * 2; } @@ -611,8 +555,7 @@ DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInf ID3D11Texture2D* CopyBuffer = nullptr; HRESULT hr = m_Device->CreateTexture2D(&CopyBufferDesc, nullptr, &CopyBuffer); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed creating staging texture for pointer", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -628,25 +571,22 @@ DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInf hr = CopyBuffer->QueryInterface(__uuidof(IDXGISurface), (void **)&CopySurface); CopyBuffer->Release(); CopyBuffer = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(nullptr, L"Failed to QI staging texture into IDXGISurface for pointer", L"Error", hr, SystemTransitionsExpectedErrors); } // Map pixels DXGI_MAPPED_RECT MappedSurface; hr = CopySurface->Map(&MappedSurface, DXGI_MAP_READ); - if (FAILED(hr)) - { + if (FAILED(hr)) { CopySurface->Release(); CopySurface = nullptr; return ProcessFailure(m_Device, L"Failed to map surface for pointer", L"Error", hr, SystemTransitionsExpectedErrors); } // New mouseshape buffer - *InitBuffer = new (std::nothrow) BYTE[*PtrWidth * *PtrHeight * BPP]; - if (!(*InitBuffer)) - { + *InitBuffer = new (std::nothrow) BYTE[*PtrWidth **PtrHeight * BPP]; + if (!(*InitBuffer)) { return ProcessFailure(nullptr, L"Failed to allocate memory for new mouse shape buffer.", L"Error", E_OUTOFMEMORY); } @@ -658,15 +598,12 @@ DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInf UINT SkipX = (GivenLeft < 0) ? (-1 * GivenLeft) : (0); UINT SkipY = (GivenTop < 0) ? (-1 * GivenTop) : (0); - if (IsMono) - { - for (INT Row = 0; Row < *PtrHeight; ++Row) - { + if (IsMono) { + for (INT Row = 0; Row < *PtrHeight; ++Row) { // Set mask BYTE Mask = 0x80; Mask = Mask >> (SkipX % 8); - for (INT Col = 0; Col < *PtrWidth; ++Col) - { + for (INT Col = 0; Col < *PtrWidth; ++Col) { // Get masks using appropriate offsets BYTE AndMask = PtrInfo->PtrShapeBuffer[((Col + SkipX) / 8) + ((Row + SkipY) * (PtrInfo->ShapeInfo.Pitch))] & Mask; BYTE XorMask = PtrInfo->PtrShapeBuffer[((Col + SkipX) / 8) + ((Row + SkipY + (PtrInfo->ShapeInfo.Height / 2)) * (PtrInfo->ShapeInfo.Pitch))] & Mask; @@ -674,40 +611,33 @@ DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInf UINT XorMask32 = (XorMask) ? 0x00FFFFFF : 0x00000000; // Set new pixel - InitBuffer32[(Row * *PtrWidth) + Col] = (Desktop32[(Row * DesktopPitchInPixels) + Col] & AndMask32) ^ XorMask32; + InitBuffer32[(Row **PtrWidth) + Col] = (Desktop32[(Row * DesktopPitchInPixels) + Col] & AndMask32) ^ XorMask32; // Adjust mask - if (Mask == 0x01) - { + if (Mask == 0x01) { Mask = 0x80; } - else - { + else { Mask = Mask >> 1; } } } } - else - { + else { UINT* Buffer32 = reinterpret_cast<UINT*>(PtrInfo->PtrShapeBuffer); // Iterate through pixels - for (INT Row = 0; Row < *PtrHeight; ++Row) - { - for (INT Col = 0; Col < *PtrWidth; ++Col) - { + for (INT Row = 0; Row < *PtrHeight; ++Row) { + for (INT Col = 0; Col < *PtrWidth; ++Col) { // Set up mask UINT MaskVal = 0xFF000000 & Buffer32[(Col + SkipX) + ((Row + SkipY) * (PtrInfo->ShapeInfo.Pitch / sizeof(UINT)))]; - if (MaskVal) - { + if (MaskVal) { // Mask was 0xFF - InitBuffer32[(Row * *PtrWidth) + Col] = (Desktop32[(Row * DesktopPitchInPixels) + Col] ^ Buffer32[(Col + SkipX) + ((Row + SkipY) * (PtrInfo->ShapeInfo.Pitch / sizeof(UINT)))]) | 0xFF000000; + InitBuffer32[(Row **PtrWidth) + Col] = (Desktop32[(Row * DesktopPitchInPixels) + Col] ^ Buffer32[(Col + SkipX) + ((Row + SkipY) * (PtrInfo->ShapeInfo.Pitch / sizeof(UINT)))]) | 0xFF000000; } - else - { + else { // Mask was 0x00 - InitBuffer32[(Row * *PtrWidth) + Col] = Buffer32[(Col + SkipX) + ((Row + SkipY) * (PtrInfo->ShapeInfo.Pitch / sizeof(UINT)))] | 0xFF000000; + InitBuffer32[(Row **PtrWidth) + Col] = Buffer32[(Col + SkipX) + ((Row + SkipY) * (PtrInfo->ShapeInfo.Pitch / sizeof(UINT)))] | 0xFF000000; } } } @@ -717,8 +647,7 @@ DUPL_RETURN OUTPUTMANAGER::ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInf hr = CopySurface->Unmap(); CopySurface->Release(); CopySurface = nullptr; - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to unmap surface for pointer", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -739,8 +668,7 @@ DUPL_RETURN OUTPUTMANAGER::DrawMouse(_In_ PTR_INFO* PtrInfo) D3D11_SHADER_RESOURCE_VIEW_DESC SDesc; // Position will be changed based on mouse position - VERTEX Vertices[NUMVERTICES] = - { + VERTEX Vertices[NUMVERTICES] = { {XMFLOAT3(-1.0f, -1.0f, 0), XMFLOAT2(0.0f, 1.0f)}, {XMFLOAT3(-1.0f, 1.0f, 0), XMFLOAT2(0.0f, 0.0f)}, {XMFLOAT3(1.0f, -1.0f, 0), XMFLOAT2(1.0f, 1.0f)}, @@ -788,33 +716,29 @@ DUPL_RETURN OUTPUTMANAGER::DrawMouse(_In_ PTR_INFO* PtrInfo) SDesc.Texture2D.MostDetailedMip = Desc.MipLevels - 1; SDesc.Texture2D.MipLevels = Desc.MipLevels; - switch (PtrInfo->ShapeInfo.Type) - { - case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR: - { - PtrLeft = PtrInfo->Position.x; - PtrTop = PtrInfo->Position.y; + switch (PtrInfo->ShapeInfo.Type) { + case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR: { + PtrLeft = PtrInfo->Position.x; + PtrTop = PtrInfo->Position.y; - PtrWidth = static_cast<INT>(PtrInfo->ShapeInfo.Width); - PtrHeight = static_cast<INT>(PtrInfo->ShapeInfo.Height); + PtrWidth = static_cast<INT>(PtrInfo->ShapeInfo.Width); + PtrHeight = static_cast<INT>(PtrInfo->ShapeInfo.Height); - break; - } + break; + } - case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME: - { - ProcessMonoMask(true, PtrInfo, &PtrWidth, &PtrHeight, &PtrLeft, &PtrTop, &InitBuffer, &Box); - break; - } + case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME: { + ProcessMonoMask(true, PtrInfo, &PtrWidth, &PtrHeight, &PtrLeft, &PtrTop, &InitBuffer, &Box); + break; + } - case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR: - { - ProcessMonoMask(false, PtrInfo, &PtrWidth, &PtrHeight, &PtrLeft, &PtrTop, &InitBuffer, &Box); - break; - } + case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR: { + ProcessMonoMask(false, PtrInfo, &PtrWidth, &PtrHeight, &PtrLeft, &PtrTop, &InitBuffer, &Box); + break; + } - default: - break; + default: + break; } // VERTEX creation @@ -842,15 +766,13 @@ DUPL_RETURN OUTPUTMANAGER::DrawMouse(_In_ PTR_INFO* PtrInfo) // Create mouseshape as texture HRESULT hr = m_Device->CreateTexture2D(&Desc, &InitData, &MouseTex); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create mouse pointer texture", L"Error", hr, SystemTransitionsExpectedErrors); } // Create shader resource from texture hr = m_Device->CreateShaderResourceView(MouseTex, &SDesc, &ShaderRes); - if (FAILED(hr)) - { + if (FAILED(hr)) { MouseTex->Release(); MouseTex = nullptr; return ProcessFailure(m_Device, L"Failed to create shader resource from mouse pointer texture", L"Error", hr, SystemTransitionsExpectedErrors); @@ -868,8 +790,7 @@ DUPL_RETURN OUTPUTMANAGER::DrawMouse(_In_ PTR_INFO* PtrInfo) // Create vertex buffer hr = m_Device->CreateBuffer(&BDesc, &InitData, &VertexBufferMouse); - if (FAILED(hr)) - { + if (FAILED(hr)) { ShaderRes->Release(); ShaderRes = nullptr; MouseTex->Release(); @@ -893,23 +814,19 @@ DUPL_RETURN OUTPUTMANAGER::DrawMouse(_In_ PTR_INFO* PtrInfo) m_DeviceContext->Draw(NUMVERTICES, 0); // Clean - if (VertexBufferMouse) - { + if (VertexBufferMouse) { VertexBufferMouse->Release(); VertexBufferMouse = nullptr; } - if (ShaderRes) - { + if (ShaderRes) { ShaderRes->Release(); ShaderRes = nullptr; } - if (MouseTex) - { + if (MouseTex) { MouseTex->Release(); MouseTex = nullptr; } - if (InitBuffer) - { + if (InitBuffer) { delete [] InitBuffer; InitBuffer = nullptr; } @@ -926,28 +843,24 @@ DUPL_RETURN OUTPUTMANAGER::InitShaders() UINT Size = ARRAYSIZE(g_VS); hr = m_Device->CreateVertexShader(g_VS, Size, nullptr, &m_VertexShader); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create vertex shader in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } - D3D11_INPUT_ELEMENT_DESC Layout[] = - { + D3D11_INPUT_ELEMENT_DESC Layout[] = { {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0} }; UINT NumElements = ARRAYSIZE(Layout); hr = m_Device->CreateInputLayout(Layout, NumElements, g_VS, Size, &m_InputLayout); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create input layout in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } m_DeviceContext->IASetInputLayout(m_InputLayout); Size = ARRAYSIZE(g_PS); hr = m_Device->CreatePixelShader(g_PS, Size, nullptr, &m_PixelShader); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create pixel shader in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -962,16 +875,14 @@ DUPL_RETURN OUTPUTMANAGER::MakeRTV() // Get backbuffer ID3D11Texture2D* BackBuffer = nullptr; HRESULT hr = m_SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&BackBuffer)); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to get backbuffer for making render target view in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } // Create a render target view hr = m_Device->CreateRenderTargetView(BackBuffer, nullptr, &m_RTV); BackBuffer->Release(); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to create render target view in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -1001,8 +912,7 @@ void OUTPUTMANAGER::SetViewPort(UINT Width, UINT Height) // DUPL_RETURN OUTPUTMANAGER::ResizeSwapChain() { - if (m_RTV) - { + if (m_RTV) { m_RTV->Release(); m_RTV = nullptr; } @@ -1016,15 +926,13 @@ DUPL_RETURN OUTPUTMANAGER::ResizeSwapChain() DXGI_SWAP_CHAIN_DESC SwapChainDesc; m_SwapChain->GetDesc(&SwapChainDesc); HRESULT hr = m_SwapChain->ResizeBuffers(SwapChainDesc.BufferCount, Width, Height, SwapChainDesc.BufferDesc.Format, SwapChainDesc.Flags); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(m_Device, L"Failed to resize swapchain buffers in OUTPUTMANAGER", L"Error", hr, SystemTransitionsExpectedErrors); } // Make new render target view DUPL_RETURN Ret = MakeRTV(); - if (Ret != DUPL_RETURN_SUCCESS) - { + if (Ret != DUPL_RETURN_SUCCESS) { return Ret; } @@ -1039,76 +947,63 @@ DUPL_RETURN OUTPUTMANAGER::ResizeSwapChain() // void OUTPUTMANAGER::CleanRefs() { - if (m_VertexShader) - { + if (m_VertexShader) { m_VertexShader->Release(); m_VertexShader = nullptr; } - if (m_PixelShader) - { + if (m_PixelShader) { m_PixelShader->Release(); m_PixelShader = nullptr; } - if (m_InputLayout) - { + if (m_InputLayout) { m_InputLayout->Release(); m_InputLayout = nullptr; } - if (m_RTV) - { + if (m_RTV) { m_RTV->Release(); m_RTV = nullptr; } - if (m_SamplerLinear) - { + if (m_SamplerLinear) { m_SamplerLinear->Release(); m_SamplerLinear = nullptr; } - if (m_BlendState) - { + if (m_BlendState) { m_BlendState->Release(); m_BlendState = nullptr; } - if (m_DeviceContext) - { + if (m_DeviceContext) { m_DeviceContext->Release(); m_DeviceContext = nullptr; } - if (m_Device) - { + if (m_Device) { m_Device->Release(); m_Device = nullptr; } - if (m_SwapChain) - { + if (m_SwapChain) { m_SwapChain->Release(); m_SwapChain = nullptr; } - if (m_SharedSurf) - { + if (m_SharedSurf) { m_SharedSurf->Release(); m_SharedSurf = nullptr; } - if (m_KeyMutex) - { + if (m_KeyMutex) { m_KeyMutex->Release(); m_KeyMutex = nullptr; } - if (m_Factory) - { - if (m_OcclusionCookie) - { + if (m_Factory) { + if (m_OcclusionCookie) { m_Factory->UnregisterOcclusionStatus(m_OcclusionCookie); m_OcclusionCookie = 0; } diff --git a/plugins/pluginWinDD/internals/OutputManager.h b/plugins/pluginWinDD/internals/OutputManager.h index cd16e5f..fa1902a 100755 --- a/plugins/pluginWinDD/internals/OutputManager.h +++ b/plugins/pluginWinDD/internals/OutputManager.h @@ -19,43 +19,43 @@ // class OUTPUTMANAGER { - public: - OUTPUTMANAGER(); - ~OUTPUTMANAGER(); - DUPL_RETURN InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* OutCount, _Out_ RECT* DeskBounds); - DUPL_RETURN UpdateApplicationWindow(_In_ PTR_INFO* PointerInfo, _Inout_ bool* Occluded); - void CleanRefs(); - HANDLE GetSharedHandle(); - void WindowResize(); +public: + OUTPUTMANAGER(); + ~OUTPUTMANAGER(); + DUPL_RETURN InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* OutCount, _Out_ RECT* DeskBounds); + DUPL_RETURN UpdateApplicationWindow(_In_ PTR_INFO* PointerInfo, _Inout_ bool* Occluded); + void CleanRefs(); + HANDLE GetSharedHandle(); + void WindowResize(); - private: +private: // Methods - DUPL_RETURN ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInfo, _Out_ INT* PtrWidth, _Out_ INT* PtrHeight, _Out_ INT* PtrLeft, _Out_ INT* PtrTop, _Outptr_result_bytebuffer_(*PtrHeight * *PtrWidth * BPP) BYTE** InitBuffer, _Out_ D3D11_BOX* Box); - DUPL_RETURN MakeRTV(); - void SetViewPort(UINT Width, UINT Height); - DUPL_RETURN InitShaders(); - DUPL_RETURN InitGeometry(); - DUPL_RETURN CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCount, _Out_ RECT* DeskBounds); - DUPL_RETURN DrawFrame(); - DUPL_RETURN DrawMouse(_In_ PTR_INFO* PtrInfo); - DUPL_RETURN ResizeSwapChain(); + DUPL_RETURN ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInfo, _Out_ INT* PtrWidth, _Out_ INT* PtrHeight, _Out_ INT* PtrLeft, _Out_ INT* PtrTop, _Outptr_result_bytebuffer_(*PtrHeight **PtrWidth * BPP) BYTE** InitBuffer, _Out_ D3D11_BOX* Box); + DUPL_RETURN MakeRTV(); + void SetViewPort(UINT Width, UINT Height); + DUPL_RETURN InitShaders(); + DUPL_RETURN InitGeometry(); + DUPL_RETURN CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCount, _Out_ RECT* DeskBounds); + DUPL_RETURN DrawFrame(); + DUPL_RETURN DrawMouse(_In_ PTR_INFO* PtrInfo); + DUPL_RETURN ResizeSwapChain(); // Vars - IDXGISwapChain1* m_SwapChain; - ID3D11Device* m_Device; - IDXGIFactory2* m_Factory; - ID3D11DeviceContext* m_DeviceContext; - ID3D11RenderTargetView* m_RTV; - ID3D11SamplerState* m_SamplerLinear; - ID3D11BlendState* m_BlendState; - ID3D11VertexShader* m_VertexShader; - ID3D11PixelShader* m_PixelShader; - ID3D11InputLayout* m_InputLayout; - ID3D11Texture2D* m_SharedSurf; - IDXGIKeyedMutex* m_KeyMutex; - HWND m_WindowHandle; - bool m_NeedsResize; - DWORD m_OcclusionCookie; + IDXGISwapChain1* m_SwapChain; + ID3D11Device* m_Device; + IDXGIFactory2* m_Factory; + ID3D11DeviceContext* m_DeviceContext; + ID3D11RenderTargetView* m_RTV; + ID3D11SamplerState* m_SamplerLinear; + ID3D11BlendState* m_BlendState; + ID3D11VertexShader* m_VertexShader; + ID3D11PixelShader* m_PixelShader; + ID3D11InputLayout* m_InputLayout; + ID3D11Texture2D* m_SharedSurf; + IDXGIKeyedMutex* m_KeyMutex; + HWND m_WindowHandle; + bool m_NeedsResize; + DWORD m_OcclusionCookie; }; #endif diff --git a/plugins/pluginWinDD/internals/ThreadManager.cxx b/plugins/pluginWinDD/internals/ThreadManager.cxx index 68fe757..fcae447 100755 --- a/plugins/pluginWinDD/internals/ThreadManager.cxx +++ b/plugins/pluginWinDD/internals/ThreadManager.cxx @@ -10,8 +10,8 @@ DWORD WINAPI DDProc(_In_ void* Param); THREADMANAGER::THREADMANAGER() : m_ThreadCount(0), - m_ThreadHandles(nullptr), - m_ThreadData(nullptr) + m_ThreadHandles(nullptr), + m_ThreadData(nullptr) { RtlZeroMemory(&m_PtrInfo, sizeof(m_PtrInfo)); } @@ -26,19 +26,15 @@ THREADMANAGER::~THREADMANAGER() // void THREADMANAGER::Clean() { - if (m_PtrInfo.PtrShapeBuffer) - { + if (m_PtrInfo.PtrShapeBuffer) { delete [] m_PtrInfo.PtrShapeBuffer; m_PtrInfo.PtrShapeBuffer = nullptr; } RtlZeroMemory(&m_PtrInfo, sizeof(m_PtrInfo)); - if (m_ThreadHandles) - { - for (UINT i = 0; i < m_ThreadCount; ++i) - { - if (m_ThreadHandles[i]) - { + if (m_ThreadHandles) { + for (UINT i = 0; i < m_ThreadCount; ++i) { + if (m_ThreadHandles[i]) { CloseHandle(m_ThreadHandles[i]); } } @@ -46,10 +42,8 @@ void THREADMANAGER::Clean() m_ThreadHandles = nullptr; } - if (m_ThreadData) - { - for (UINT i = 0; i < m_ThreadCount; ++i) - { + if (m_ThreadData) { + for (UINT i = 0; i < m_ThreadCount; ++i) { CleanDx(&m_ThreadData[i].DxRes); } delete [] m_ThreadData; @@ -64,38 +58,32 @@ void THREADMANAGER::Clean() // void THREADMANAGER::CleanDx(_Inout_ DX_RESOURCES* Data) { - if (Data->Device) - { + if (Data->Device) { Data->Device->Release(); Data->Device = nullptr; } - if (Data->Context) - { + if (Data->Context) { Data->Context->Release(); Data->Context = nullptr; } - if (Data->VertexShader) - { + if (Data->VertexShader) { Data->VertexShader->Release(); Data->VertexShader = nullptr; } - if (Data->PixelShader) - { + if (Data->PixelShader) { Data->PixelShader->Release(); Data->PixelShader = nullptr; } - if (Data->InputLayout) - { + if (Data->InputLayout) { Data->InputLayout->Release(); Data->InputLayout = nullptr; } - if (Data->SamplerLinear) - { + if (Data->SamplerLinear) { Data->SamplerLinear->Release(); Data->SamplerLinear = nullptr; } @@ -109,15 +97,13 @@ DUPL_RETURN THREADMANAGER::Initialize(INT SingleOutput, UINT OutputCount, HANDLE m_ThreadCount = OutputCount; m_ThreadHandles = new (std::nothrow) HANDLE[m_ThreadCount]; m_ThreadData = new (std::nothrow) THREAD_DATA[m_ThreadCount]; - if (!m_ThreadHandles || !m_ThreadData) - { + if (!m_ThreadHandles || !m_ThreadData) { return ProcessFailure(nullptr, L"Failed to allocate array for threads", L"Error", E_OUTOFMEMORY); } // Create appropriate # of threads for duplication DUPL_RETURN Ret = DUPL_RETURN_SUCCESS; - for (UINT i = 0; i < m_ThreadCount; ++i) - { + for (UINT i = 0; i < m_ThreadCount; ++i) { m_ThreadData[i].UnexpectedErrorEvent = UnexpectedErrorEvent; m_ThreadData[i].ExpectedErrorEvent = ExpectedErrorEvent; m_ThreadData[i].TerminateThreadsEvent = TerminateThreadsEvent; @@ -126,19 +112,17 @@ DUPL_RETURN THREADMANAGER::Initialize(INT SingleOutput, UINT OutputCount, HANDLE m_ThreadData[i].OffsetX = DesktopDim->left; m_ThreadData[i].OffsetY = DesktopDim->top; m_ThreadData[i].PtrInfo = &m_PtrInfo; - m_ThreadData[i].Producer = Producer; + m_ThreadData[i].Producer = Producer; RtlZeroMemory(&m_ThreadData[i].DxRes, sizeof(DX_RESOURCES)); Ret = InitializeDx(&m_ThreadData[i].DxRes); - if (Ret != DUPL_RETURN_SUCCESS) - { + if (Ret != DUPL_RETURN_SUCCESS) { return Ret; } DWORD ThreadId; m_ThreadHandles[i] = CreateThread(nullptr, 0, DDProc, &m_ThreadData[i], 0, &ThreadId); - if (m_ThreadHandles[i] == nullptr) - { + if (m_ThreadHandles[i] == nullptr) { return ProcessFailure(nullptr, L"Failed to create thread", L"Error", E_FAIL); } } @@ -154,8 +138,7 @@ DUPL_RETURN THREADMANAGER::InitializeDx(_Out_ DX_RESOURCES* Data) HRESULT hr = S_OK; // Driver types supported - D3D_DRIVER_TYPE DriverTypes[] = - { + D3D_DRIVER_TYPE DriverTypes[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP, D3D_DRIVER_TYPE_REFERENCE, @@ -163,8 +146,7 @@ DUPL_RETURN THREADMANAGER::InitializeDx(_Out_ DX_RESOURCES* Data) UINT NumDriverTypes = ARRAYSIZE(DriverTypes); // Feature levels supported - D3D_FEATURE_LEVEL FeatureLevels[] = - { + D3D_FEATURE_LEVEL FeatureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, @@ -175,39 +157,33 @@ DUPL_RETURN THREADMANAGER::InitializeDx(_Out_ DX_RESOURCES* Data) D3D_FEATURE_LEVEL FeatureLevel; // Create device - for (UINT DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex) - { + for (UINT DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex) { hr = D3D11CreateDevice(nullptr, DriverTypes[DriverTypeIndex], nullptr, 0, FeatureLevels, NumFeatureLevels, - D3D11_SDK_VERSION, &Data->Device, &FeatureLevel, &Data->Context); - if (SUCCEEDED(hr)) - { + D3D11_SDK_VERSION, &Data->Device, &FeatureLevel, &Data->Context); + if (SUCCEEDED(hr)) { // Device creation success, no need to loop anymore break; } } - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(nullptr, L"Failed to create device in InitializeDx", L"Error", hr); } // VERTEX shader UINT Size = ARRAYSIZE(g_VS); hr = Data->Device->CreateVertexShader(g_VS, Size, nullptr, &Data->VertexShader); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(Data->Device, L"Failed to create vertex shader in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors); } // Input layout - D3D11_INPUT_ELEMENT_DESC Layout[] = - { + D3D11_INPUT_ELEMENT_DESC Layout[] = { {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0} }; UINT NumElements = ARRAYSIZE(Layout); hr = Data->Device->CreateInputLayout(Layout, NumElements, g_VS, Size, &Data->InputLayout); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(Data->Device, L"Failed to create input layout in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors); } Data->Context->IASetInputLayout(Data->InputLayout); @@ -215,8 +191,7 @@ DUPL_RETURN THREADMANAGER::InitializeDx(_Out_ DX_RESOURCES* Data) // Pixel shader Size = ARRAYSIZE(g_PS); hr = Data->Device->CreatePixelShader(g_PS, Size, nullptr, &Data->PixelShader); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(Data->Device, L"Failed to create pixel shader in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -231,8 +206,7 @@ DUPL_RETURN THREADMANAGER::InitializeDx(_Out_ DX_RESOURCES* Data) SampDesc.MinLOD = 0; SampDesc.MaxLOD = D3D11_FLOAT32_MAX; hr = Data->Device->CreateSamplerState(&SampDesc, &Data->SamplerLinear); - if (FAILED(hr)) - { + if (FAILED(hr)) { return ProcessFailure(Data->Device, L"Failed to create sampler state in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors); } @@ -252,10 +226,9 @@ PTR_INFO* THREADMANAGER::GetPointerInfo() // bool THREADMANAGER::WaitForThreadTermination(DWORD timeout /*= INFINITE*/) { - bool bRet = true; - if (m_ThreadCount != 0) - { - bRet = (WaitForMultipleObjectsEx(m_ThreadCount, m_ThreadHandles, TRUE, timeout, FALSE) != WAIT_TIMEOUT); + bool bRet = true; + if (m_ThreadCount != 0) { + bRet = (WaitForMultipleObjectsEx(m_ThreadCount, m_ThreadHandles, TRUE, timeout, FALSE) != WAIT_TIMEOUT); } - return bRet; + return bRet; } diff --git a/plugins/pluginWinDD/internals/ThreadManager.h b/plugins/pluginWinDD/internals/ThreadManager.h index d710998..2a9157f 100755 --- a/plugins/pluginWinDD/internals/ThreadManager.h +++ b/plugins/pluginWinDD/internals/ThreadManager.h @@ -12,22 +12,22 @@ class THREADMANAGER { - public: - THREADMANAGER(); - ~THREADMANAGER(); - void Clean(); - DUPL_RETURN Initialize(INT SingleOutput, UINT OutputCount, HANDLE UnexpectedErrorEvent, HANDLE ExpectedErrorEvent, HANDLE TerminateThreadsEvent, HANDLE SharedHandle, _In_ const struct tmedia_producer_s* Producer, _In_ RECT* DesktopDim); - PTR_INFO* GetPointerInfo(); - bool WaitForThreadTermination(DWORD timeout = INFINITE); +public: + THREADMANAGER(); + ~THREADMANAGER(); + void Clean(); + DUPL_RETURN Initialize(INT SingleOutput, UINT OutputCount, HANDLE UnexpectedErrorEvent, HANDLE ExpectedErrorEvent, HANDLE TerminateThreadsEvent, HANDLE SharedHandle, _In_ const struct tmedia_producer_s* Producer, _In_ RECT* DesktopDim); + PTR_INFO* GetPointerInfo(); + bool WaitForThreadTermination(DWORD timeout = INFINITE); - private: - DUPL_RETURN InitializeDx(_Out_ DX_RESOURCES* Data); - void CleanDx(_Inout_ DX_RESOURCES* Data); +private: + DUPL_RETURN InitializeDx(_Out_ DX_RESOURCES* Data); + void CleanDx(_Inout_ DX_RESOURCES* Data); - PTR_INFO m_PtrInfo; - UINT m_ThreadCount; - _Field_size_(m_ThreadCount) HANDLE* m_ThreadHandles; - _Field_size_(m_ThreadCount) THREAD_DATA* m_ThreadData; + PTR_INFO m_PtrInfo; + UINT m_ThreadCount; + _Field_size_(m_ThreadCount) HANDLE* m_ThreadHandles; + _Field_size_(m_ThreadCount) THREAD_DATA* m_ThreadData; }; #endif diff --git a/plugins/pluginWinDD/plugin_win_dd_config.h b/plugins/pluginWinDD/plugin_win_dd_config.h index a1d3855..70e6ce5 100755 --- a/plugins/pluginWinDD/plugin_win_dd_config.h +++ b/plugins/pluginWinDD/plugin_win_dd_config.h @@ -48,12 +48,12 @@ # define PLUGIN_WIN_DD_UNDER_X86 1 #endif -// Guards against C++ name mangling +// Guards against C++ name mangling #ifdef __cplusplus # define PLUGIN_WIN_DD_BEGIN_DECLS extern "C" { # define PLUGIN_WIN_DD_END_DECLS } #else -# define PLUGIN_WIN_DD_BEGIN_DECLS +# define PLUGIN_WIN_DD_BEGIN_DECLS # define PLUGIN_WIN_DD_END_DECLS #endif diff --git a/plugins/pluginWinDD/plugin_win_dd_producer.cxx b/plugins/pluginWinDD/plugin_win_dd_producer.cxx index 7c13767..01d857d 100755 --- a/plugins/pluginWinDD/plugin_win_dd_producer.cxx +++ b/plugins/pluginWinDD/plugin_win_dd_producer.cxx @@ -55,28 +55,27 @@ // // plugin_win_dd_producer_t // -typedef struct plugin_win_dd_producer_s -{ - TMEDIA_DECLARE_PRODUCER; - - bool bStarted, bPrepared, bMuted, bWindowHooked, bThreadTerminationDelayed; - tsk_thread_handle_t* ppTread[1]; - - OUTPUTMANAGER *pOutMgr; - THREADMANAGER *pThreadMgr; - - // Window handles - HWND hwndPreview; - WNDPROC wndPreviewProc; - HWND hwndSrc; - - // Synchronization - HANDLE hlUnexpectedErrorEvent; - HANDLE hlExpectedErrorEvent; - HANDLE hlOcclutionEvent; - HANDLE hlTerminateThreadsEvent; - - HCURSOR hcCursor; +typedef struct plugin_win_dd_producer_s { + TMEDIA_DECLARE_PRODUCER; + + bool bStarted, bPrepared, bMuted, bWindowHooked, bThreadTerminationDelayed; + tsk_thread_handle_t* ppTread[1]; + + OUTPUTMANAGER *pOutMgr; + THREADMANAGER *pThreadMgr; + + // Window handles + HWND hwndPreview; + WNDPROC wndPreviewProc; + HWND hwndSrc; + + // Synchronization + HANDLE hlUnexpectedErrorEvent; + HANDLE hlExpectedErrorEvent; + HANDLE hlOcclutionEvent; + HANDLE hlTerminateThreadsEvent; + + HCURSOR hcCursor; } plugin_win_dd_producer_t; @@ -97,11 +96,10 @@ static void* TSK_STDCALL DDThread(void *pArg); // // Class for progressive waits // -typedef struct -{ - UINT WaitTime; - UINT WaitCount; -}WAIT_BAND; +typedef struct { + UINT WaitTime; + UINT WaitCount; +} WAIT_BAND; #define WAIT_BAND_COUNT 3 #define WAIT_BAND_STOP 0 @@ -109,360 +107,316 @@ typedef struct class DYNAMIC_WAIT { public: - DYNAMIC_WAIT(); - ~DYNAMIC_WAIT(); + DYNAMIC_WAIT(); + ~DYNAMIC_WAIT(); - void Wait(); + void Wait(); private: - static const WAIT_BAND m_WaitBands[WAIT_BAND_COUNT]; + static const WAIT_BAND m_WaitBands[WAIT_BAND_COUNT]; - // Period in seconds that a new wait call is considered part of the same wait sequence - static const UINT m_WaitSequenceTimeInSeconds = 2; + // Period in seconds that a new wait call is considered part of the same wait sequence + static const UINT m_WaitSequenceTimeInSeconds = 2; - UINT m_CurrentWaitBandIdx; - UINT m_WaitCountInCurrentBand; - LARGE_INTEGER m_QPCFrequency; - LARGE_INTEGER m_LastWakeUpTime; - BOOL m_QPCValid; + UINT m_CurrentWaitBandIdx; + UINT m_WaitCountInCurrentBand; + LARGE_INTEGER m_QPCFrequency; + LARGE_INTEGER m_LastWakeUpTime; + BOOL m_QPCValid; }; const WAIT_BAND DYNAMIC_WAIT::m_WaitBands[WAIT_BAND_COUNT] = { - { 250, 20 }, - { 2000, 60 }, - { 5000, WAIT_BAND_STOP } // Never move past this band + { 250, 20 }, + { 2000, 60 }, + { 5000, WAIT_BAND_STOP } // Never move past this band }; /* ============ Video DD Producer Interface ================= */ static int plugin_win_dd_producer_set(tmedia_producer_t *p_self, const tmedia_param_t* pc_param) { - int ret = -1; - plugin_win_dd_producer_t* p_dd = (plugin_win_dd_producer_t*)p_self; - - if (!p_dd || !pc_param) - { - DD_DEBUG_ERROR("Invalid parameter"); - return -1; - } - - if (pc_param->value_type == tmedia_pvt_int64) - { - if (tsk_striequals(pc_param->key, "local-hwnd") || tsk_striequals(pc_param->key, "preview-hwnd")) - { - HWND hwnd = (HWND)*((int64_t*)pc_param->value); - ret = SUCCEEDED(HookWindow(p_dd, hwnd)) ? 0 : -1; - } - else if (tsk_striequals(pc_param->key, "src-hwnd")) - { - p_dd->hwndSrc = (HWND)*((int64_t*)pc_param->value); - ret = 0; - } - } - else if (pc_param->value_type == tmedia_pvt_int32) - { - if (tsk_striequals(pc_param->key, "mute")) - { - p_dd->bMuted = (TSK_TO_INT32((uint8_t*)pc_param->value) != 0); - ret = 0; - } - } - - return ret; + int ret = -1; + plugin_win_dd_producer_t* p_dd = (plugin_win_dd_producer_t*)p_self; + + if (!p_dd || !pc_param) { + DD_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + if (pc_param->value_type == tmedia_pvt_int64) { + if (tsk_striequals(pc_param->key, "local-hwnd") || tsk_striequals(pc_param->key, "preview-hwnd")) { + HWND hwnd = (HWND)*((int64_t*)pc_param->value); + ret = SUCCEEDED(HookWindow(p_dd, hwnd)) ? 0 : -1; + } + else if (tsk_striequals(pc_param->key, "src-hwnd")) { + p_dd->hwndSrc = (HWND)*((int64_t*)pc_param->value); + ret = 0; + } + } + else if (pc_param->value_type == tmedia_pvt_int32) { + if (tsk_striequals(pc_param->key, "mute")) { + p_dd->bMuted = (TSK_TO_INT32((uint8_t*)pc_param->value) != 0); + ret = 0; + } + } + + return ret; } static int plugin_win_dd_producer_prepare(tmedia_producer_t* self, const tmedia_codec_t* codec) { - plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; - HRESULT hr = S_OK; - - if (!pSelf || !codec && codec->plugin) - { - DD_DEBUG_ERROR("Invalid parameter"); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - if (pSelf->bPrepared) - { - DD_DEBUG_WARN("DD video producer already prepared"); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - if (pSelf->bThreadTerminationDelayed) - { - DD_DEBUG_INFO("Thread termination was delayed ...cleanup now"); - if (_plugin_win_dd_producer_unprepare(pSelf, true/*cleanup?*/) != 0) - { - DD_CHECK_HR(hr = E_UNEXPECTED); - } - } - - TMEDIA_PRODUCER(pSelf)->video.fps = TMEDIA_CODEC_VIDEO(codec)->out.fps; - TMEDIA_PRODUCER(pSelf)->video.width = TMEDIA_CODEC_VIDEO(codec)->out.width; - TMEDIA_PRODUCER(pSelf)->video.height = TMEDIA_CODEC_VIDEO(codec)->out.height; - TMEDIA_PRODUCER(pSelf)->encoder.codec_id = tmedia_codec_id_none; // means RAW frames as input - - DD_DEBUG_INFO("DD video producer: fps=%d, width=%d, height=%d", - TMEDIA_PRODUCER(pSelf)->video.fps, - TMEDIA_PRODUCER(pSelf)->video.width, - TMEDIA_PRODUCER(pSelf)->video.height); - - // Event used by the threads to signal an unexpected error and we want to quit the app - if (!pSelf->hlUnexpectedErrorEvent && !(pSelf->hlUnexpectedErrorEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) - { - ProcessFailure(nullptr, L"UnexpectedErrorEvent creation failed", L"Error", E_UNEXPECTED); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - // Event for when a thread encounters an expected error - if (!pSelf->hlExpectedErrorEvent && !(pSelf->hlExpectedErrorEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) - { - ProcessFailure(nullptr, L"ExpectedErrorEvent creation failed", L"Error", E_UNEXPECTED); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - // Event for Occlution - if (!pSelf->hlOcclutionEvent && !(pSelf->hlOcclutionEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) - { - ProcessFailure(nullptr, L"OcclutionEvent creation failed", L"Error", E_UNEXPECTED); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - // Event to tell spawned threads to quit - if (!pSelf->hlTerminateThreadsEvent && !(pSelf->hlTerminateThreadsEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) - { - ProcessFailure(nullptr, L"TerminateThreadsEvent creation failed", L"Error", E_UNEXPECTED); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - // Load simple cursor - if (!pSelf->hcCursor && !(pSelf->hcCursor = LoadCursor(nullptr, IDC_ARROW))) - { - ProcessFailure(nullptr, L"Cursor load failed", L"Error", E_UNEXPECTED); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - if (!pSelf->pOutMgr && !(pSelf->pOutMgr = new OUTPUTMANAGER())) - { - ProcessFailure(nullptr, L"Out manager allocation failed", L"Error", E_OUTOFMEMORY); - DD_CHECK_HR(hr = E_OUTOFMEMORY); - } - - if (!pSelf->pThreadMgr && !(pSelf->pThreadMgr = new THREADMANAGER())) - { - ProcessFailure(nullptr, L"Thread managed allocation failed", L"Error", E_OUTOFMEMORY); - DD_CHECK_HR(hr = E_OUTOFMEMORY); - } + plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; + HRESULT hr = S_OK; + + if (!pSelf || !codec && codec->plugin) { + DD_DEBUG_ERROR("Invalid parameter"); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + if (pSelf->bPrepared) { + DD_DEBUG_WARN("DD video producer already prepared"); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + if (pSelf->bThreadTerminationDelayed) { + DD_DEBUG_INFO("Thread termination was delayed ...cleanup now"); + if (_plugin_win_dd_producer_unprepare(pSelf, true/*cleanup?*/) != 0) { + DD_CHECK_HR(hr = E_UNEXPECTED); + } + } + + TMEDIA_PRODUCER(pSelf)->video.fps = TMEDIA_CODEC_VIDEO(codec)->out.fps; + TMEDIA_PRODUCER(pSelf)->video.width = TMEDIA_CODEC_VIDEO(codec)->out.width; + TMEDIA_PRODUCER(pSelf)->video.height = TMEDIA_CODEC_VIDEO(codec)->out.height; + TMEDIA_PRODUCER(pSelf)->encoder.codec_id = tmedia_codec_id_none; // means RAW frames as input + + DD_DEBUG_INFO("DD video producer: fps=%d, width=%d, height=%d", + TMEDIA_PRODUCER(pSelf)->video.fps, + TMEDIA_PRODUCER(pSelf)->video.width, + TMEDIA_PRODUCER(pSelf)->video.height); + + // Event used by the threads to signal an unexpected error and we want to quit the app + if (!pSelf->hlUnexpectedErrorEvent && !(pSelf->hlUnexpectedErrorEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) { + ProcessFailure(nullptr, L"UnexpectedErrorEvent creation failed", L"Error", E_UNEXPECTED); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + // Event for when a thread encounters an expected error + if (!pSelf->hlExpectedErrorEvent && !(pSelf->hlExpectedErrorEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) { + ProcessFailure(nullptr, L"ExpectedErrorEvent creation failed", L"Error", E_UNEXPECTED); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + // Event for Occlution + if (!pSelf->hlOcclutionEvent && !(pSelf->hlOcclutionEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) { + ProcessFailure(nullptr, L"OcclutionEvent creation failed", L"Error", E_UNEXPECTED); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + // Event to tell spawned threads to quit + if (!pSelf->hlTerminateThreadsEvent && !(pSelf->hlTerminateThreadsEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr))) { + ProcessFailure(nullptr, L"TerminateThreadsEvent creation failed", L"Error", E_UNEXPECTED); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + // Load simple cursor + if (!pSelf->hcCursor && !(pSelf->hcCursor = LoadCursor(nullptr, IDC_ARROW))) { + ProcessFailure(nullptr, L"Cursor load failed", L"Error", E_UNEXPECTED); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + if (!pSelf->pOutMgr && !(pSelf->pOutMgr = new OUTPUTMANAGER())) { + ProcessFailure(nullptr, L"Out manager allocation failed", L"Error", E_OUTOFMEMORY); + DD_CHECK_HR(hr = E_OUTOFMEMORY); + } + + if (!pSelf->pThreadMgr && !(pSelf->pThreadMgr = new THREADMANAGER())) { + ProcessFailure(nullptr, L"Thread managed allocation failed", L"Error", E_OUTOFMEMORY); + DD_CHECK_HR(hr = E_OUTOFMEMORY); + } bail: - pSelf->bPrepared = SUCCEEDED(hr); - return SUCCEEDED(hr) ? 0 : -1; + pSelf->bPrepared = SUCCEEDED(hr); + return SUCCEEDED(hr) ? 0 : -1; } static int plugin_win_dd_producer_start(tmedia_producer_t* self) { - plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; - HRESULT hr = S_OK; - - if (!pSelf) - { - DD_DEBUG_ERROR("Invalid parameter"); - return -1; - } - - if (pSelf->bStarted) - { - DD_DEBUG_INFO("Producer already started"); - goto bail; - } - if (!pSelf->bPrepared) - { - DD_DEBUG_ERROR("Producer not prepared"); - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - DD_CHECK_HR(hr = HookWindow(pSelf, pSelf->hwndPreview)); - - // Start asynchronous watcher thread - pSelf->bStarted = true; - int ret = tsk_thread_create(&pSelf->ppTread[0], DDThread, pSelf); - if (ret != 0) - { - TSK_DEBUG_ERROR("Failed to create thread"); - pSelf->bStarted = false; - if (pSelf->ppTread[0]) - { - tsk_thread_join(&pSelf->ppTread[0]); - } - DD_CHECK_HR(hr = E_UNEXPECTED); - } + plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; + HRESULT hr = S_OK; + + if (!pSelf) { + DD_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + if (pSelf->bStarted) { + DD_DEBUG_INFO("Producer already started"); + goto bail; + } + if (!pSelf->bPrepared) { + DD_DEBUG_ERROR("Producer not prepared"); + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + DD_CHECK_HR(hr = HookWindow(pSelf, pSelf->hwndPreview)); + + // Start asynchronous watcher thread + pSelf->bStarted = true; + int ret = tsk_thread_create(&pSelf->ppTread[0], DDThread, pSelf); + if (ret != 0) { + TSK_DEBUG_ERROR("Failed to create thread"); + pSelf->bStarted = false; + if (pSelf->ppTread[0]) { + tsk_thread_join(&pSelf->ppTread[0]); + } + DD_CHECK_HR(hr = E_UNEXPECTED); + } bail: - if (FAILED(hr)) - { - UnhookWindow(pSelf); - return -1; - } - pSelf->bStarted = true; - return 0; + if (FAILED(hr)) { + UnhookWindow(pSelf); + return -1; + } + pSelf->bStarted = true; + return 0; } static int plugin_win_dd_producer_pause(tmedia_producer_t* self) { - plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; - - if (!pSelf) - { - DD_DEBUG_ERROR("Invalid parameter"); - return -1; - } - if (!pSelf->bStarted) - { - DD_DEBUG_INFO("MF video producer not started"); - } - - return 0; + plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; + + if (!pSelf) { + DD_DEBUG_ERROR("Invalid parameter"); + return -1; + } + if (!pSelf->bStarted) { + DD_DEBUG_INFO("MF video producer not started"); + } + + return 0; } static int plugin_win_dd_producer_stop(tmedia_producer_t* self) { - plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; - - if (!pSelf) - { - DD_DEBUG_ERROR("Invalid parameter"); - return -1; - } - - pSelf->bStarted = false; - - UnhookWindow(pSelf); - - if (pSelf->hlTerminateThreadsEvent) - { - SetEvent(pSelf->hlTerminateThreadsEvent); - } - if (pSelf->ppTread[0]) - { - tsk_thread_join(&pSelf->ppTread[0]); - } - - // next start() will be called after prepare() - int ret = _plugin_win_dd_producer_unprepare(pSelf); - - return ret; + plugin_win_dd_producer_t* pSelf = (plugin_win_dd_producer_t*)self; + + if (!pSelf) { + DD_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + pSelf->bStarted = false; + + UnhookWindow(pSelf); + + if (pSelf->hlTerminateThreadsEvent) { + SetEvent(pSelf->hlTerminateThreadsEvent); + } + if (pSelf->ppTread[0]) { + tsk_thread_join(&pSelf->ppTread[0]); + } + + // next start() will be called after prepare() + int ret = _plugin_win_dd_producer_unprepare(pSelf); + + return ret; } static int _plugin_win_dd_producer_unprepare(plugin_win_dd_producer_t* pSelf, bool bCleanup /*= false*/) { - HRESULT hr = S_OK; - - if (!pSelf) - { - DD_DEBUG_ERROR("Invalid parameter"); - return -1; - } - - if (pSelf->bStarted) - { - DD_CHECK_HR(hr = E_UNEXPECTED); - } - - pSelf->bThreadTerminationDelayed = false; - - // Thread manager must be destroyed before the events and output manager - if (pSelf->pThreadMgr) - { - // if we are cleaning the producer then all threads must exit only when all threads are destroyed - // https://code.google.com/p/sincity/issues/detail?id=7 - if (pSelf->pThreadMgr->WaitForThreadTermination(bCleanup ? INFINITE : DD_DDPROC_THREAD_TIMEOUT) == true) - { - delete pSelf->pThreadMgr; - pSelf->pThreadMgr = nullptr; - } - else - { - // Thread wait timedout - DD_DEBUG_WARN("DDProc thread termination delayed"); - pSelf->bThreadTerminationDelayed = true; - } - } - - if (!pSelf->bThreadTerminationDelayed) - { - if (pSelf->hlUnexpectedErrorEvent) - { - CloseHandle(pSelf->hlUnexpectedErrorEvent); - pSelf->hlUnexpectedErrorEvent = nullptr; - } - if (pSelf->hlExpectedErrorEvent) - { - CloseHandle(pSelf->hlExpectedErrorEvent); - pSelf->hlExpectedErrorEvent = nullptr; - } - if (pSelf->hlOcclutionEvent) - { - CloseHandle(pSelf->hlOcclutionEvent); - pSelf->hlOcclutionEvent = nullptr; - } - if (pSelf->hlTerminateThreadsEvent) - { - CloseHandle(pSelf->hlTerminateThreadsEvent); - pSelf->hlTerminateThreadsEvent = nullptr; - } - - if (pSelf->hcCursor) - { - DestroyCursor(pSelf->hcCursor); - pSelf->hcCursor = nullptr; - } - - if (pSelf->pOutMgr) - { - delete pSelf->pOutMgr; - pSelf->pOutMgr = nullptr; - } - } - - pSelf->bPrepared = false; + HRESULT hr = S_OK; + + if (!pSelf) { + DD_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + if (pSelf->bStarted) { + DD_CHECK_HR(hr = E_UNEXPECTED); + } + + pSelf->bThreadTerminationDelayed = false; + + // Thread manager must be destroyed before the events and output manager + if (pSelf->pThreadMgr) { + // if we are cleaning the producer then all threads must exit only when all threads are destroyed + // https://code.google.com/p/sincity/issues/detail?id=7 + if (pSelf->pThreadMgr->WaitForThreadTermination(bCleanup ? INFINITE : DD_DDPROC_THREAD_TIMEOUT) == true) { + delete pSelf->pThreadMgr; + pSelf->pThreadMgr = nullptr; + } + else { + // Thread wait timedout + DD_DEBUG_WARN("DDProc thread termination delayed"); + pSelf->bThreadTerminationDelayed = true; + } + } + + if (!pSelf->bThreadTerminationDelayed) { + if (pSelf->hlUnexpectedErrorEvent) { + CloseHandle(pSelf->hlUnexpectedErrorEvent); + pSelf->hlUnexpectedErrorEvent = nullptr; + } + if (pSelf->hlExpectedErrorEvent) { + CloseHandle(pSelf->hlExpectedErrorEvent); + pSelf->hlExpectedErrorEvent = nullptr; + } + if (pSelf->hlOcclutionEvent) { + CloseHandle(pSelf->hlOcclutionEvent); + pSelf->hlOcclutionEvent = nullptr; + } + if (pSelf->hlTerminateThreadsEvent) { + CloseHandle(pSelf->hlTerminateThreadsEvent); + pSelf->hlTerminateThreadsEvent = nullptr; + } + + if (pSelf->hcCursor) { + DestroyCursor(pSelf->hcCursor); + pSelf->hcCursor = nullptr; + } + + if (pSelf->pOutMgr) { + delete pSelf->pOutMgr; + pSelf->pOutMgr = nullptr; + } + } + + pSelf->bPrepared = false; bail: - return 0; + return 0; } static HRESULT HookWindow(struct plugin_win_dd_producer_s *pSelf, HWND hWnd) { - HRESULT hr = S_OK; - - DD_CHECK_HR(hr = UnhookWindow(pSelf)); - - if ((pSelf->hwndPreview = hWnd)) - { - pSelf->wndPreviewProc = (WNDPROC)SetWindowLongPtr(pSelf->hwndPreview, GWLP_WNDPROC, (LONG_PTR)WndProc); - if (!pSelf->wndPreviewProc) - { - DD_DEBUG_ERROR("HookWindowLongPtr() failed with errcode=%d", GetLastError()); - DD_CHECK_HR(hr = E_FAIL); - } - SetProp(pSelf->hwndPreview, L"Self", pSelf); - pSelf->bWindowHooked = true; - } + HRESULT hr = S_OK; + + DD_CHECK_HR(hr = UnhookWindow(pSelf)); + + if ((pSelf->hwndPreview = hWnd)) { + pSelf->wndPreviewProc = (WNDPROC)SetWindowLongPtr(pSelf->hwndPreview, GWLP_WNDPROC, (LONG_PTR)WndProc); + if (!pSelf->wndPreviewProc) { + DD_DEBUG_ERROR("HookWindowLongPtr() failed with errcode=%d", GetLastError()); + DD_CHECK_HR(hr = E_FAIL); + } + SetProp(pSelf->hwndPreview, L"Self", pSelf); + pSelf->bWindowHooked = true; + } bail: - return S_OK; + return S_OK; } static HRESULT UnhookWindow(struct plugin_win_dd_producer_s *pSelf) { - if (pSelf->hwndPreview && pSelf->wndPreviewProc) - { - SetWindowLongPtr(pSelf->hwndPreview, GWLP_WNDPROC, (LONG_PTR)pSelf->wndPreviewProc); - pSelf->wndPreviewProc = NULL; - } - if (pSelf->hwndPreview) - { - ::InvalidateRect(pSelf->hwndPreview, NULL, FALSE); - } - pSelf->bWindowHooked = false; - return S_OK; + if (pSelf->hwndPreview && pSelf->wndPreviewProc) { + SetWindowLongPtr(pSelf->hwndPreview, GWLP_WNDPROC, (LONG_PTR)pSelf->wndPreviewProc); + pSelf->wndPreviewProc = NULL; + } + if (pSelf->hwndPreview) { + ::InvalidateRect(pSelf->hwndPreview, NULL, FALSE); + } + pSelf->bWindowHooked = false; + return S_OK; } // @@ -471,66 +425,61 @@ static HRESULT UnhookWindow(struct plugin_win_dd_producer_s *pSelf) /* constructor */ static tsk_object_t* plugin_win_dd_producer_ctor(tsk_object_t * self, va_list * app) { - plugin_win_dd_producer_t *pSelf = (plugin_win_dd_producer_t *)self; - if (pSelf) - { - /* init base */ - tmedia_producer_init(TMEDIA_PRODUCER(pSelf)); - - /* init self with default values*/ - TMEDIA_PRODUCER(pSelf)->encoder.codec_id = tmedia_codec_id_none; // means RAW frames as input - TMEDIA_PRODUCER(pSelf)->video.chroma = tmedia_chroma_rgb32; - TMEDIA_PRODUCER(pSelf)->video.fps = 15; - TMEDIA_PRODUCER(pSelf)->video.width = 352; - TMEDIA_PRODUCER(pSelf)->video.height = 288; - - DD_DEBUG_INFO("Create Microsoft Desktop Duplication producer"); - } - return self; + plugin_win_dd_producer_t *pSelf = (plugin_win_dd_producer_t *)self; + if (pSelf) { + /* init base */ + tmedia_producer_init(TMEDIA_PRODUCER(pSelf)); + + /* init self with default values*/ + TMEDIA_PRODUCER(pSelf)->encoder.codec_id = tmedia_codec_id_none; // means RAW frames as input + TMEDIA_PRODUCER(pSelf)->video.chroma = tmedia_chroma_rgb32; + TMEDIA_PRODUCER(pSelf)->video.fps = 15; + TMEDIA_PRODUCER(pSelf)->video.width = 352; + TMEDIA_PRODUCER(pSelf)->video.height = 288; + + DD_DEBUG_INFO("Create Microsoft Desktop Duplication producer"); + } + return self; } /* destructor */ static tsk_object_t* plugin_win_dd_producer_dtor(tsk_object_t * self) { - plugin_win_dd_producer_t *pSelf = (plugin_win_dd_producer_t *)self; - if (pSelf) - { - /* stop */ - if (pSelf->bStarted) - { - plugin_win_dd_producer_stop(TMEDIA_PRODUCER(pSelf)); - } - - /* deinit base */ - tmedia_producer_deinit(TMEDIA_PRODUCER(pSelf)); - /* deinit self */ - _plugin_win_dd_producer_unprepare(pSelf, true/*cleanup*/); - - DD_DEBUG_INFO("*** WinDD producer destroyed ***"); - } - - return self; + plugin_win_dd_producer_t *pSelf = (plugin_win_dd_producer_t *)self; + if (pSelf) { + /* stop */ + if (pSelf->bStarted) { + plugin_win_dd_producer_stop(TMEDIA_PRODUCER(pSelf)); + } + + /* deinit base */ + tmedia_producer_deinit(TMEDIA_PRODUCER(pSelf)); + /* deinit self */ + _plugin_win_dd_producer_unprepare(pSelf, true/*cleanup*/); + + DD_DEBUG_INFO("*** WinDD producer destroyed ***"); + } + + return self; } /* object definition */ -static const tsk_object_def_t plugin_win_dd_producer_def_s = -{ - sizeof(plugin_win_dd_producer_t), - plugin_win_dd_producer_ctor, - plugin_win_dd_producer_dtor, - tsk_null, +static const tsk_object_def_t plugin_win_dd_producer_def_s = { + sizeof(plugin_win_dd_producer_t), + plugin_win_dd_producer_ctor, + plugin_win_dd_producer_dtor, + tsk_null, }; /* plugin definition*/ -static const tmedia_producer_plugin_def_t plugin_win_dd_producer_plugin_def_s = -{ - &plugin_win_dd_producer_def_s, +static const tmedia_producer_plugin_def_t plugin_win_dd_producer_plugin_def_s = { + &plugin_win_dd_producer_def_s, - tmedia_bfcp_video, - "Microsoft Windows Desktop Duplication producer (Video)", + tmedia_bfcp_video, + "Microsoft Windows Desktop Duplication producer (Video)", - plugin_win_dd_producer_set, - plugin_win_dd_producer_prepare, - plugin_win_dd_producer_start, - plugin_win_dd_producer_pause, - plugin_win_dd_producer_stop + plugin_win_dd_producer_set, + plugin_win_dd_producer_prepare, + plugin_win_dd_producer_start, + plugin_win_dd_producer_pause, + plugin_win_dd_producer_stop }; const tmedia_producer_plugin_def_t *plugin_win_dd_producer_plugin_def_t = &plugin_win_dd_producer_plugin_def_s; @@ -545,130 +494,115 @@ const tmedia_producer_plugin_def_t *plugin_win_dd_producer_plugin_def_t = &plugi // These are the errors we expect from general Dxgi API due to a transition HRESULT SystemTransitionsExpectedErrors[] = { - DXGI_ERROR_DEVICE_REMOVED, - DXGI_ERROR_ACCESS_LOST, - static_cast<HRESULT>(WAIT_ABANDONED), - S_OK // Terminate list with zero valued HRESULT + DXGI_ERROR_DEVICE_REMOVED, + DXGI_ERROR_ACCESS_LOST, + static_cast<HRESULT>(WAIT_ABANDONED), + S_OK // Terminate list with zero valued HRESULT }; // These are the errors we expect from IDXGIOutput1::DuplicateOutput due to a transition HRESULT CreateDuplicationExpectedErrors[] = { - DXGI_ERROR_DEVICE_REMOVED, - static_cast<HRESULT>(E_ACCESSDENIED), - DXGI_ERROR_UNSUPPORTED, - DXGI_ERROR_SESSION_DISCONNECTED, - S_OK // Terminate list with zero valued HRESULT + DXGI_ERROR_DEVICE_REMOVED, + static_cast<HRESULT>(E_ACCESSDENIED), + DXGI_ERROR_UNSUPPORTED, + DXGI_ERROR_SESSION_DISCONNECTED, + S_OK // Terminate list with zero valued HRESULT }; // These are the errors we expect from IDXGIOutputDuplication methods due to a transition HRESULT FrameInfoExpectedErrors[] = { - DXGI_ERROR_DEVICE_REMOVED, - DXGI_ERROR_ACCESS_LOST, - S_OK // Terminate list with zero valued HRESULT + DXGI_ERROR_DEVICE_REMOVED, + DXGI_ERROR_ACCESS_LOST, + S_OK // Terminate list with zero valued HRESULT }; // These are the errors we expect from IDXGIAdapter::EnumOutputs methods due to outputs becoming stale during a transition HRESULT EnumOutputsExpectedErrors[] = { - DXGI_ERROR_NOT_FOUND, - S_OK // Terminate list with zero valued HRESULT + DXGI_ERROR_NOT_FOUND, + S_OK // Terminate list with zero valued HRESULT }; _Post_satisfies_(return != DUPL_RETURN_SUCCESS) - DUPL_RETURN ProcessFailure(_In_opt_ ID3D11Device* Device, _In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr, _In_opt_z_ HRESULT* ExpectedErrors) +DUPL_RETURN ProcessFailure(_In_opt_ ID3D11Device* Device, _In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr, _In_opt_z_ HRESULT* ExpectedErrors) { - HRESULT TranslatedHr; - - // On an error check if the DX device is lost - if (Device) - { - HRESULT DeviceRemovedReason = Device->GetDeviceRemovedReason(); - - switch (DeviceRemovedReason) - { - case DXGI_ERROR_DEVICE_REMOVED: - case DXGI_ERROR_DEVICE_RESET: - case static_cast<HRESULT>(E_OUTOFMEMORY) : - { - // Our device has been stopped due to an external event on the GPU so map them all to - // device removed and continue processing the condition - TranslatedHr = DXGI_ERROR_DEVICE_REMOVED; - break; - } - - case S_OK: - { - // Device is not removed so use original error - TranslatedHr = hr; - break; - } - - default: - { - // Device is removed but not a error we want to remap - TranslatedHr = DeviceRemovedReason; - } - } - } - else - { - TranslatedHr = hr; - } - - // Check if this error was expected or not - if (ExpectedErrors) - { - HRESULT* CurrentResult = ExpectedErrors; - - while (*CurrentResult != S_OK) - { - if (*(CurrentResult++) == TranslatedHr) - { - return DUPL_RETURN_ERROR_EXPECTED; - } - } - } - - // Error was not expected so display the message box - DisplayMsg(Str, Title, TranslatedHr); - - return DUPL_RETURN_ERROR_UNEXPECTED; + HRESULT TranslatedHr; + + // On an error check if the DX device is lost + if (Device) { + HRESULT DeviceRemovedReason = Device->GetDeviceRemovedReason(); + + switch (DeviceRemovedReason) { + case DXGI_ERROR_DEVICE_REMOVED: + case DXGI_ERROR_DEVICE_RESET: + case static_cast<HRESULT>(E_OUTOFMEMORY) : { + // Our device has been stopped due to an external event on the GPU so map them all to + // device removed and continue processing the condition + TranslatedHr = DXGI_ERROR_DEVICE_REMOVED; + break; + } + + case S_OK: { + // Device is not removed so use original error + TranslatedHr = hr; + break; + } + + default: { + // Device is removed but not a error we want to remap + TranslatedHr = DeviceRemovedReason; + } + } + } + else { + TranslatedHr = hr; + } + + // Check if this error was expected or not + if (ExpectedErrors) { + HRESULT* CurrentResult = ExpectedErrors; + + while (*CurrentResult != S_OK) { + if (*(CurrentResult++) == TranslatedHr) { + return DUPL_RETURN_ERROR_EXPECTED; + } + } + } + + // Error was not expected so display the message box + DisplayMsg(Str, Title, TranslatedHr); + + return DUPL_RETURN_ERROR_UNEXPECTED; } LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { - switch (message) - { - case WM_DESTROY: - { - PostQuitMessage(0); - break; - } - case WM_SIZE: - { - // Tell output manager that window size has changed - plugin_win_dd_producer_t* pSelf = static_cast<plugin_win_dd_producer_t*>(GetProp(hWnd, L"Self")); - if (pSelf && pSelf->pOutMgr) - { - pSelf->pOutMgr->WindowResize(); - } - break; - } - case OCCLUSION_STATUS_MSG: - { - plugin_win_dd_producer_t* pSelf = static_cast<plugin_win_dd_producer_t*>(GetProp(hWnd, L"Self")); - if (pSelf && pSelf->hlOcclutionEvent) - { - SetEvent(pSelf->hlOcclutionEvent); - } - break; - } - default: - return DefWindowProc(hWnd, message, wParam, lParam); - } - - return 0; + switch (message) { + case WM_DESTROY: { + PostQuitMessage(0); + break; + } + case WM_SIZE: { + // Tell output manager that window size has changed + plugin_win_dd_producer_t* pSelf = static_cast<plugin_win_dd_producer_t*>(GetProp(hWnd, L"Self")); + if (pSelf && pSelf->pOutMgr) { + pSelf->pOutMgr->WindowResize(); + } + break; + } + case OCCLUSION_STATUS_MSG: { + plugin_win_dd_producer_t* pSelf = static_cast<plugin_win_dd_producer_t*>(GetProp(hWnd, L"Self")); + if (pSelf && pSelf->hlOcclutionEvent) { + SetEvent(pSelf->hlOcclutionEvent); + } + break; + } + default: + return DefWindowProc(hWnd, message, wParam, lParam); + } + + return 0; } // @@ -676,399 +610,357 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) // DWORD WINAPI DDProc(_In_ void* Param) { - DD_DEBUG_INFO("DDProc (producer) - ENTER"); - - // Classes - DISPLAYMANAGER DispMgr; - DUPLICATIONMANAGER DuplMgr; - - // D3D objects - ID3D11Texture2D* SharedSurf = nullptr; - IDXGIKeyedMutex* KeyMutex = nullptr; - - // Data passed in from thread creation - THREAD_DATA* TData = reinterpret_cast<THREAD_DATA*>(Param); - - // Get desktop - DUPL_RETURN Ret; - HDESK CurrentDesktop = nullptr; - CurrentDesktop = OpenInputDesktop(0, FALSE, GENERIC_ALL); - if (!CurrentDesktop) - { - // We do not have access to the desktop so request a retry - SetEvent(TData->ExpectedErrorEvent); - Ret = DUPL_RETURN_ERROR_EXPECTED; - goto Exit; - } - - // Attach desktop to this thread - bool DesktopAttached = SetThreadDesktop(CurrentDesktop) != 0; - CloseDesktop(CurrentDesktop); - CurrentDesktop = nullptr; - if (!DesktopAttached) - { - // We do not have access to the desktop so request a retry - Ret = DUPL_RETURN_ERROR_EXPECTED; - goto Exit; - } - - // New display manager - DispMgr.InitD3D(&TData->DxRes); - - // FPS manager - uint64_t TimeNow, TimeLastFrame = 0; - const uint64_t TimeFrameDuration = 1000 / TData->Producer->video.fps; - - // Obtain handle to sync shared Surface - HRESULT hr = TData->DxRes.Device->OpenSharedResource(TData->TexSharedHandle, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&SharedSurf)); - if (FAILED(hr)) - { - Ret = ProcessFailure(TData->DxRes.Device, L"Opening shared texture failed", L"Error", hr, SystemTransitionsExpectedErrors); - goto Exit; - } - - hr = SharedSurf->QueryInterface(__uuidof(IDXGIKeyedMutex), reinterpret_cast<void**>(&KeyMutex)); - if (FAILED(hr)) - { - Ret = ProcessFailure(nullptr, L"Failed to get keyed mutex interface in spawned thread", L"Error", hr); - goto Exit; - } - - // Make duplication manager - Ret = DuplMgr.InitDupl(TData->DxRes.Device, TData->DxRes.Context ,TData->Output); - if (Ret != DUPL_RETURN_SUCCESS) - { - goto Exit; - } - - // Get output description - DXGI_OUTPUT_DESC DesktopDesc; - RtlZeroMemory(&DesktopDesc, sizeof(DXGI_OUTPUT_DESC)); - DuplMgr.GetOutputDesc(&DesktopDesc); - - // Main duplication loop - bool WaitToProcessCurrentFrame = false; - FRAME_DATA CurrentData; - - while (TData->Producer->is_started && (WaitForSingleObjectEx(TData->TerminateThreadsEvent, 0, FALSE) == WAIT_TIMEOUT)) - { - if (!WaitToProcessCurrentFrame) - { - // Get new frame from desktop duplication - bool TimeOut; - Ret = DuplMgr.GetFrame(&CurrentData, &TimeOut); - if (Ret != DUPL_RETURN_SUCCESS) - { - // An error occurred getting the next frame drop out of loop which - // will check if it was expected or not - break; - } - - // Check for timeout - if (TimeOut) - { - // No new frame at the moment - continue; - } - } - - // We have a new frame so try and process it - // Try to acquire keyed mutex in order to access shared surface - hr = KeyMutex->AcquireSync(0, 1000); - if (hr == static_cast<HRESULT>(WAIT_TIMEOUT)) - { - // Can't use shared surface right now, try again later - WaitToProcessCurrentFrame = true; - continue; - } - else if (FAILED(hr)) - { - // Generic unknown failure - Ret = ProcessFailure(TData->DxRes.Device, L"Unexpected error acquiring KeyMutex", L"Error", hr, SystemTransitionsExpectedErrors); - DuplMgr.DoneWithFrame(); - break; - } - - // We can now process the current frame - WaitToProcessCurrentFrame = false; - - // Get mouse info - Ret = DuplMgr.GetMouse(TData->PtrInfo, &(CurrentData.FrameInfo), TData->OffsetX, TData->OffsetY); - if (Ret != DUPL_RETURN_SUCCESS) - { - DuplMgr.DoneWithFrame(); - KeyMutex->ReleaseSync(1); - break; - } - - // Process new frame - Ret = DispMgr.ProcessFrame(&CurrentData, SharedSurf, TData->OffsetX, TData->OffsetY, &DesktopDesc); - if (Ret != DUPL_RETURN_SUCCESS) - { - DuplMgr.DoneWithFrame(); - KeyMutex->ReleaseSync(1); - break; - } - - // Release acquired keyed mutex - hr = KeyMutex->ReleaseSync(1); - if (FAILED(hr)) - { - Ret = ProcessFailure(TData->DxRes.Device, L"Unexpected error releasing the keyed mutex", L"Error", hr, SystemTransitionsExpectedErrors); - DuplMgr.DoneWithFrame(); - break; - } - - // Send Frame Over the Network - TimeNow = tsk_time_now(); - if ((TimeNow - TimeLastFrame) > TimeFrameDuration) - { - if (!((const plugin_win_dd_producer_t*)TData->Producer)->bMuted) - { - hr = DuplMgr.SendData(const_cast<struct tmedia_producer_s*>(TData->Producer), &CurrentData); - } - if (SUCCEEDED(hr)) - { - TimeLastFrame = TimeNow; - } - } + DD_DEBUG_INFO("DDProc (producer) - ENTER"); + + // Classes + DISPLAYMANAGER DispMgr; + DUPLICATIONMANAGER DuplMgr; + + // D3D objects + ID3D11Texture2D* SharedSurf = nullptr; + IDXGIKeyedMutex* KeyMutex = nullptr; + + // Data passed in from thread creation + THREAD_DATA* TData = reinterpret_cast<THREAD_DATA*>(Param); + + // Get desktop + DUPL_RETURN Ret; + HDESK CurrentDesktop = nullptr; + CurrentDesktop = OpenInputDesktop(0, FALSE, GENERIC_ALL); + if (!CurrentDesktop) { + // We do not have access to the desktop so request a retry + SetEvent(TData->ExpectedErrorEvent); + Ret = DUPL_RETURN_ERROR_EXPECTED; + goto Exit; + } + + // Attach desktop to this thread + bool DesktopAttached = SetThreadDesktop(CurrentDesktop) != 0; + CloseDesktop(CurrentDesktop); + CurrentDesktop = nullptr; + if (!DesktopAttached) { + // We do not have access to the desktop so request a retry + Ret = DUPL_RETURN_ERROR_EXPECTED; + goto Exit; + } + + // New display manager + DispMgr.InitD3D(&TData->DxRes); + + // FPS manager + uint64_t TimeNow, TimeLastFrame = 0; + const uint64_t TimeFrameDuration = 1000 / TData->Producer->video.fps; + + // Obtain handle to sync shared Surface + HRESULT hr = TData->DxRes.Device->OpenSharedResource(TData->TexSharedHandle, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&SharedSurf)); + if (FAILED(hr)) { + Ret = ProcessFailure(TData->DxRes.Device, L"Opening shared texture failed", L"Error", hr, SystemTransitionsExpectedErrors); + goto Exit; + } + + hr = SharedSurf->QueryInterface(__uuidof(IDXGIKeyedMutex), reinterpret_cast<void**>(&KeyMutex)); + if (FAILED(hr)) { + Ret = ProcessFailure(nullptr, L"Failed to get keyed mutex interface in spawned thread", L"Error", hr); + goto Exit; + } + + // Make duplication manager + Ret = DuplMgr.InitDupl(TData->DxRes.Device, TData->DxRes.Context ,TData->Output); + if (Ret != DUPL_RETURN_SUCCESS) { + goto Exit; + } + + // Get output description + DXGI_OUTPUT_DESC DesktopDesc; + RtlZeroMemory(&DesktopDesc, sizeof(DXGI_OUTPUT_DESC)); + DuplMgr.GetOutputDesc(&DesktopDesc); + + // Main duplication loop + bool WaitToProcessCurrentFrame = false; + FRAME_DATA CurrentData; + + while (TData->Producer->is_started && (WaitForSingleObjectEx(TData->TerminateThreadsEvent, 0, FALSE) == WAIT_TIMEOUT)) { + if (!WaitToProcessCurrentFrame) { + // Get new frame from desktop duplication + bool TimeOut; + Ret = DuplMgr.GetFrame(&CurrentData, &TimeOut); + if (Ret != DUPL_RETURN_SUCCESS) { + // An error occurred getting the next frame drop out of loop which + // will check if it was expected or not + break; + } + + // Check for timeout + if (TimeOut) { + // No new frame at the moment + continue; + } + } + + // We have a new frame so try and process it + // Try to acquire keyed mutex in order to access shared surface + hr = KeyMutex->AcquireSync(0, 1000); + if (hr == static_cast<HRESULT>(WAIT_TIMEOUT)) { + // Can't use shared surface right now, try again later + WaitToProcessCurrentFrame = true; + continue; + } + else if (FAILED(hr)) { + // Generic unknown failure + Ret = ProcessFailure(TData->DxRes.Device, L"Unexpected error acquiring KeyMutex", L"Error", hr, SystemTransitionsExpectedErrors); + DuplMgr.DoneWithFrame(); + break; + } + + // We can now process the current frame + WaitToProcessCurrentFrame = false; + + // Get mouse info + Ret = DuplMgr.GetMouse(TData->PtrInfo, &(CurrentData.FrameInfo), TData->OffsetX, TData->OffsetY); + if (Ret != DUPL_RETURN_SUCCESS) { + DuplMgr.DoneWithFrame(); + KeyMutex->ReleaseSync(1); + break; + } + + // Process new frame + Ret = DispMgr.ProcessFrame(&CurrentData, SharedSurf, TData->OffsetX, TData->OffsetY, &DesktopDesc); + if (Ret != DUPL_RETURN_SUCCESS) { + DuplMgr.DoneWithFrame(); + KeyMutex->ReleaseSync(1); + break; + } + + // Release acquired keyed mutex + hr = KeyMutex->ReleaseSync(1); + if (FAILED(hr)) { + Ret = ProcessFailure(TData->DxRes.Device, L"Unexpected error releasing the keyed mutex", L"Error", hr, SystemTransitionsExpectedErrors); + DuplMgr.DoneWithFrame(); + break; + } + + // Send Frame Over the Network + TimeNow = tsk_time_now(); + if ((TimeNow - TimeLastFrame) > TimeFrameDuration) { + if (!((const plugin_win_dd_producer_t*)TData->Producer)->bMuted) { + hr = DuplMgr.SendData(const_cast<struct tmedia_producer_s*>(TData->Producer), &CurrentData); + } + if (SUCCEEDED(hr)) { + TimeLastFrame = TimeNow; + } + } #if 0 - else - { - DD_DEBUG_INFO("Skip frame"); - } + else { + DD_DEBUG_INFO("Skip frame"); + } #endif - // Release frame back to desktop duplication - Ret = DuplMgr.DoneWithFrame(); - if (Ret != DUPL_RETURN_SUCCESS) - { - break; - } - } + // Release frame back to desktop duplication + Ret = DuplMgr.DoneWithFrame(); + if (Ret != DUPL_RETURN_SUCCESS) { + break; + } + } Exit: - if (Ret != DUPL_RETURN_SUCCESS) - { - if (Ret == DUPL_RETURN_ERROR_EXPECTED) - { - // The system is in a transition state so request the duplication be restarted - SetEvent(TData->ExpectedErrorEvent); - } - else - { - // Unexpected error so exit the application - SetEvent(TData->UnexpectedErrorEvent); - } - } - - if (SharedSurf) - { - SharedSurf->Release(); - SharedSurf = nullptr; - } - - if (KeyMutex) - { - KeyMutex->Release(); - KeyMutex = nullptr; - } - - DD_DEBUG_INFO("DDProc (producer) - EXIT"); - - return 0; + if (Ret != DUPL_RETURN_SUCCESS) { + if (Ret == DUPL_RETURN_ERROR_EXPECTED) { + // The system is in a transition state so request the duplication be restarted + SetEvent(TData->ExpectedErrorEvent); + } + else { + // Unexpected error so exit the application + SetEvent(TData->UnexpectedErrorEvent); + } + } + + if (SharedSurf) { + SharedSurf->Release(); + SharedSurf = nullptr; + } + + if (KeyMutex) { + KeyMutex->Release(); + KeyMutex = nullptr; + } + + DD_DEBUG_INFO("DDProc (producer) - EXIT"); + + return 0; } // Run session async thread static void* TSK_STDCALL DDThread(void *pArg) { - plugin_win_dd_producer_t *pSelf = (plugin_win_dd_producer_t *)pArg; - HRESULT hr = S_OK; - INT SingleOutput = -1; - - RECT DeskBounds = {}; - UINT OutputCount = 1; - - bool FirstTime = true; - bool Occluded = true; - bool PreviewChanged = false; - DYNAMIC_WAIT DynamicWait; - HWND hwndPreview = NULL; - - DD_DEBUG_INFO("DDThread (producer) - ENTER"); - - while (pSelf->bStarted) - { - DUPL_RETURN Ret = DUPL_RETURN_SUCCESS; - - // Check if Preview window changed - PreviewChanged = (hwndPreview != pSelf->hwndPreview); - - if (WaitForSingleObjectEx(pSelf->hlOcclutionEvent, 0, FALSE) == WAIT_OBJECT_0) - { - Occluded = false; - } - if (WaitForSingleObjectEx(pSelf->hlUnexpectedErrorEvent, 0, FALSE) == WAIT_OBJECT_0) - { - // Unexpected error occurred so exit the application - DD_CHECK_HR(hr = E_UNEXPECTED); - } - else if (FirstTime || PreviewChanged || WaitForSingleObjectEx(pSelf->hlExpectedErrorEvent, 0, FALSE) == WAIT_OBJECT_0) - { - if (PreviewChanged) - { - hwndPreview = pSelf->hwndPreview; - } - - if (!FirstTime) - { - // Terminate other threads - SetEvent(pSelf->hlTerminateThreadsEvent); - pSelf->pThreadMgr->WaitForThreadTermination(); - ResetEvent(pSelf->hlTerminateThreadsEvent); - ResetEvent(pSelf->hlExpectedErrorEvent); - - // Clean up - pSelf->pThreadMgr->Clean(); - pSelf->pOutMgr->CleanRefs(); - - // As we have encountered an error due to a system transition we wait before trying again, using this dynamic wait - // the wait periods will get progressively long to avoid wasting too much system resource if this state lasts a long time - DynamicWait.Wait(); - } - else - { - // First time through the loop so nothing to clean up - FirstTime = false; - } - - // Re-initialize - Ret = pSelf->pOutMgr->InitOutput(hwndPreview, SingleOutput, &OutputCount, &DeskBounds); - if (Ret == DUPL_RETURN_SUCCESS) - { - HANDLE SharedHandle = pSelf->pOutMgr->GetSharedHandle(); - if (SharedHandle) - { - Ret = pSelf->pThreadMgr->Initialize(SingleOutput, OutputCount, pSelf->hlUnexpectedErrorEvent, pSelf->hlExpectedErrorEvent, pSelf->hlTerminateThreadsEvent, SharedHandle, TMEDIA_PRODUCER(pSelf), &DeskBounds); - } - else - { - DisplayMsg(L"Failed to get handle of shared surface", L"Error", S_OK); - Ret = DUPL_RETURN_ERROR_UNEXPECTED; - } - } - - - // We start off in occluded state and we should immediate get a occlusion status window message - Occluded = true; - } - else - { - // Nothing else to do, so try to present to write out to window if not occluded - if (!Occluded || !pSelf->bWindowHooked) - { - Ret = pSelf->pOutMgr->UpdateApplicationWindow(pSelf->pThreadMgr->GetPointerInfo(), &Occluded); - } - } - - // Check if for errors - if (Ret != DUPL_RETURN_SUCCESS) - { - if (Ret == DUPL_RETURN_ERROR_EXPECTED) - { - // Some type of system transition is occurring so retry - SetEvent(pSelf->hlExpectedErrorEvent); - } - else - { - // Unexpected error so exit - DD_CHECK_HR(hr = E_UNEXPECTED); - break; - } - } - } + plugin_win_dd_producer_t *pSelf = (plugin_win_dd_producer_t *)pArg; + HRESULT hr = S_OK; + INT SingleOutput = -1; + + RECT DeskBounds = {}; + UINT OutputCount = 1; + + bool FirstTime = true; + bool Occluded = true; + bool PreviewChanged = false; + DYNAMIC_WAIT DynamicWait; + HWND hwndPreview = NULL; + + DD_DEBUG_INFO("DDThread (producer) - ENTER"); + + while (pSelf->bStarted) { + DUPL_RETURN Ret = DUPL_RETURN_SUCCESS; + + // Check if Preview window changed + PreviewChanged = (hwndPreview != pSelf->hwndPreview); + + if (WaitForSingleObjectEx(pSelf->hlOcclutionEvent, 0, FALSE) == WAIT_OBJECT_0) { + Occluded = false; + } + if (WaitForSingleObjectEx(pSelf->hlUnexpectedErrorEvent, 0, FALSE) == WAIT_OBJECT_0) { + // Unexpected error occurred so exit the application + DD_CHECK_HR(hr = E_UNEXPECTED); + } + else if (FirstTime || PreviewChanged || WaitForSingleObjectEx(pSelf->hlExpectedErrorEvent, 0, FALSE) == WAIT_OBJECT_0) { + if (PreviewChanged) { + hwndPreview = pSelf->hwndPreview; + } + + if (!FirstTime) { + // Terminate other threads + SetEvent(pSelf->hlTerminateThreadsEvent); + pSelf->pThreadMgr->WaitForThreadTermination(); + ResetEvent(pSelf->hlTerminateThreadsEvent); + ResetEvent(pSelf->hlExpectedErrorEvent); + + // Clean up + pSelf->pThreadMgr->Clean(); + pSelf->pOutMgr->CleanRefs(); + + // As we have encountered an error due to a system transition we wait before trying again, using this dynamic wait + // the wait periods will get progressively long to avoid wasting too much system resource if this state lasts a long time + DynamicWait.Wait(); + } + else { + // First time through the loop so nothing to clean up + FirstTime = false; + } + + // Re-initialize + Ret = pSelf->pOutMgr->InitOutput(hwndPreview, SingleOutput, &OutputCount, &DeskBounds); + if (Ret == DUPL_RETURN_SUCCESS) { + HANDLE SharedHandle = pSelf->pOutMgr->GetSharedHandle(); + if (SharedHandle) { + Ret = pSelf->pThreadMgr->Initialize(SingleOutput, OutputCount, pSelf->hlUnexpectedErrorEvent, pSelf->hlExpectedErrorEvent, pSelf->hlTerminateThreadsEvent, SharedHandle, TMEDIA_PRODUCER(pSelf), &DeskBounds); + } + else { + DisplayMsg(L"Failed to get handle of shared surface", L"Error", S_OK); + Ret = DUPL_RETURN_ERROR_UNEXPECTED; + } + } + + + // We start off in occluded state and we should immediate get a occlusion status window message + Occluded = true; + } + else { + // Nothing else to do, so try to present to write out to window if not occluded + if (!Occluded || !pSelf->bWindowHooked) { + Ret = pSelf->pOutMgr->UpdateApplicationWindow(pSelf->pThreadMgr->GetPointerInfo(), &Occluded); + } + } + + // Check if for errors + if (Ret != DUPL_RETURN_SUCCESS) { + if (Ret == DUPL_RETURN_ERROR_EXPECTED) { + // Some type of system transition is occurring so retry + SetEvent(pSelf->hlExpectedErrorEvent); + } + else { + // Unexpected error so exit + DD_CHECK_HR(hr = E_UNEXPECTED); + break; + } + } + } bail: - - DD_DEBUG_INFO("DDThread (producer) - BAIL"); + + DD_DEBUG_INFO("DDThread (producer) - BAIL"); #if 0 // Done by unprepare() - // Make sure all other threads have exited - if (SetEvent(pSelf->hlTerminateThreadsEvent)) - { - ThreadMgr.WaitForThreadTermination(); - } - - // Clean up - CloseHandle(pSelf->hlUnexpectedErrorEvent); pSelf->hlUnexpectedErrorEvent = NULL; - CloseHandle(pSelf->hlExpectedErrorEvent); pSelf->hlExpectedErrorEvent = NULL; - CloseHandle(pSelf->hlTerminateThreadsEvent); pSelf->hlTerminateThreadsEvent = NULL; + // Make sure all other threads have exited + if (SetEvent(pSelf->hlTerminateThreadsEvent)) { + ThreadMgr.WaitForThreadTermination(); + } + + // Clean up + CloseHandle(pSelf->hlUnexpectedErrorEvent); + pSelf->hlUnexpectedErrorEvent = NULL; + CloseHandle(pSelf->hlExpectedErrorEvent); + pSelf->hlExpectedErrorEvent = NULL; + CloseHandle(pSelf->hlTerminateThreadsEvent); + pSelf->hlTerminateThreadsEvent = NULL; #endif - DD_DEBUG_INFO("DDThread (producer) - EXIT"); + DD_DEBUG_INFO("DDThread (producer) - EXIT"); - return NULL; + return NULL; } // // Displays a message // - void DisplayMsg(_In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr) +void DisplayMsg(_In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr) { - const UINT StringLen = (UINT)(wcslen(Str) + sizeof(" with HRESULT 0x########.")); - wchar_t* OutStr = new wchar_t[StringLen]; - if (!OutStr) - { - return; - } - - INT LenWritten = swprintf_s(OutStr, StringLen, L"%s with 0x%X.", Str, hr); - if (LenWritten != -1) - { - DD_DEBUG_ERROR("%ls: %ls", Title, OutStr); - } - - delete[] OutStr; + const UINT StringLen = (UINT)(wcslen(Str) + sizeof(" with HRESULT 0x########.")); + wchar_t* OutStr = new wchar_t[StringLen]; + if (!OutStr) { + return; + } + + INT LenWritten = swprintf_s(OutStr, StringLen, L"%s with 0x%X.", Str, hr); + if (LenWritten != -1) { + DD_DEBUG_ERROR("%ls: %ls", Title, OutStr); + } + + delete[] OutStr; } - DYNAMIC_WAIT::DYNAMIC_WAIT() : m_CurrentWaitBandIdx(0), m_WaitCountInCurrentBand(0) - { - m_QPCValid = QueryPerformanceFrequency(&m_QPCFrequency); - m_LastWakeUpTime.QuadPart = 0L; - } - - DYNAMIC_WAIT::~DYNAMIC_WAIT() - { - } - - void DYNAMIC_WAIT::Wait() - { - LARGE_INTEGER CurrentQPC = { 0 }; - - // Is this wait being called with the period that we consider it to be part of the same wait sequence - QueryPerformanceCounter(&CurrentQPC); - if (m_QPCValid && (CurrentQPC.QuadPart <= (m_LastWakeUpTime.QuadPart + (m_QPCFrequency.QuadPart * m_WaitSequenceTimeInSeconds)))) - { - // We are still in the same wait sequence, lets check if we should move to the next band - if ((m_WaitBands[m_CurrentWaitBandIdx].WaitCount != WAIT_BAND_STOP) && (m_WaitCountInCurrentBand > m_WaitBands[m_CurrentWaitBandIdx].WaitCount)) - { - m_CurrentWaitBandIdx++; - m_WaitCountInCurrentBand = 0; - } - } - else - { - // Either we could not get the current time or we are starting a new wait sequence - m_WaitCountInCurrentBand = 0; - m_CurrentWaitBandIdx = 0; - } - - // Sleep for the required period of time - Sleep(m_WaitBands[m_CurrentWaitBandIdx].WaitTime); - - // Record the time we woke up so we can detect wait sequences - QueryPerformanceCounter(&m_LastWakeUpTime); - m_WaitCountInCurrentBand++; - }
\ No newline at end of file +DYNAMIC_WAIT::DYNAMIC_WAIT() : m_CurrentWaitBandIdx(0), m_WaitCountInCurrentBand(0) +{ + m_QPCValid = QueryPerformanceFrequency(&m_QPCFrequency); + m_LastWakeUpTime.QuadPart = 0L; +} + +DYNAMIC_WAIT::~DYNAMIC_WAIT() +{ +} + +void DYNAMIC_WAIT::Wait() +{ + LARGE_INTEGER CurrentQPC = { 0 }; + + // Is this wait being called with the period that we consider it to be part of the same wait sequence + QueryPerformanceCounter(&CurrentQPC); + if (m_QPCValid && (CurrentQPC.QuadPart <= (m_LastWakeUpTime.QuadPart + (m_QPCFrequency.QuadPart * m_WaitSequenceTimeInSeconds)))) { + // We are still in the same wait sequence, lets check if we should move to the next band + if ((m_WaitBands[m_CurrentWaitBandIdx].WaitCount != WAIT_BAND_STOP) && (m_WaitCountInCurrentBand > m_WaitBands[m_CurrentWaitBandIdx].WaitCount)) { + m_CurrentWaitBandIdx++; + m_WaitCountInCurrentBand = 0; + } + } + else { + // Either we could not get the current time or we are starting a new wait sequence + m_WaitCountInCurrentBand = 0; + m_CurrentWaitBandIdx = 0; + } + + // Sleep for the required period of time + Sleep(m_WaitBands[m_CurrentWaitBandIdx].WaitTime); + + // Record the time we woke up so we can detect wait sequences + QueryPerformanceCounter(&m_LastWakeUpTime); + m_WaitCountInCurrentBand++; +}
\ No newline at end of file |
