1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved
#include "ThreadManager.h"
DWORD WINAPI DDProc(_In_ void* Param);
THREADMANAGER::THREADMANAGER() : m_ThreadCount(0),
m_ThreadHandles(nullptr),
m_ThreadData(nullptr)
{
RtlZeroMemory(&m_PtrInfo, sizeof(m_PtrInfo));
}
THREADMANAGER::~THREADMANAGER()
{
Clean();
}
//
// Clean up resources
//
void THREADMANAGER::Clean()
{
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]) {
CloseHandle(m_ThreadHandles[i]);
}
}
delete [] m_ThreadHandles;
m_ThreadHandles = nullptr;
}
if (m_ThreadData) {
for (UINT i = 0; i < m_ThreadCount; ++i) {
CleanDx(&m_ThreadData[i].DxRes);
}
delete [] m_ThreadData;
m_ThreadData = nullptr;
}
m_ThreadCount = 0;
}
//
// Clean up DX_RESOURCES
//
void THREADMANAGER::CleanDx(_Inout_ DX_RESOURCES* Data)
{
if (Data->Device) {
Data->Device->Release();
Data->Device = nullptr;
}
if (Data->Context) {
Data->Context->Release();
Data->Context = nullptr;
}
if (Data->VertexShader) {
Data->VertexShader->Release();
Data->VertexShader = nullptr;
}
if (Data->PixelShader) {
Data->PixelShader->Release();
Data->PixelShader = nullptr;
}
if (Data->InputLayout) {
Data->InputLayout->Release();
Data->InputLayout = nullptr;
}
if (Data->SamplerLinear) {
Data->SamplerLinear->Release();
Data->SamplerLinear = nullptr;
}
}
//
// Start up threads for DDA
//
DUPL_RETURN THREADMANAGER::Initialize(INT SingleOutput, UINT OutputCount, HANDLE UnexpectedErrorEvent, HANDLE ExpectedErrorEvent, HANDLE TerminateThreadsEvent, HANDLE SharedHandle, _In_ const struct tmedia_producer_s* Producer, _In_ RECT* DesktopDim)
{
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) {
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) {
m_ThreadData[i].UnexpectedErrorEvent = UnexpectedErrorEvent;
m_ThreadData[i].ExpectedErrorEvent = ExpectedErrorEvent;
m_ThreadData[i].TerminateThreadsEvent = TerminateThreadsEvent;
m_ThreadData[i].Output = (SingleOutput < 0) ? i : SingleOutput;
m_ThreadData[i].TexSharedHandle = SharedHandle;
m_ThreadData[i].OffsetX = DesktopDim->left;
m_ThreadData[i].OffsetY = DesktopDim->top;
m_ThreadData[i].PtrInfo = &m_PtrInfo;
m_ThreadData[i].Producer = Producer;
RtlZeroMemory(&m_ThreadData[i].DxRes, sizeof(DX_RESOURCES));
Ret = InitializeDx(&m_ThreadData[i].DxRes);
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) {
return ProcessFailure(nullptr, L"Failed to create thread", L"Error", E_FAIL);
}
}
return Ret;
}
//
// Get DX_RESOURCES
//
DUPL_RETURN THREADMANAGER::InitializeDx(_Out_ DX_RESOURCES* Data)
{
HRESULT hr = S_OK;
// Driver types supported
D3D_DRIVER_TYPE DriverTypes[] = {
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT NumDriverTypes = ARRAYSIZE(DriverTypes);
// Feature levels supported
D3D_FEATURE_LEVEL FeatureLevels[] = {
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_1
};
UINT NumFeatureLevels = ARRAYSIZE(FeatureLevels);
D3D_FEATURE_LEVEL FeatureLevel;
// Create device
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)) {
// Device creation success, no need to loop anymore
break;
}
}
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)) {
return ProcessFailure(Data->Device, L"Failed to create vertex shader in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
}
// Input 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)) {
return ProcessFailure(Data->Device, L"Failed to create input layout in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
}
Data->Context->IASetInputLayout(Data->InputLayout);
// Pixel shader
Size = ARRAYSIZE(g_PS);
hr = Data->Device->CreatePixelShader(g_PS, Size, nullptr, &Data->PixelShader);
if (FAILED(hr)) {
return ProcessFailure(Data->Device, L"Failed to create pixel shader in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
}
// Set up sampler
D3D11_SAMPLER_DESC SampDesc;
RtlZeroMemory(&SampDesc, sizeof(SampDesc));
SampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
SampDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
SampDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
SampDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
SampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
SampDesc.MinLOD = 0;
SampDesc.MaxLOD = D3D11_FLOAT32_MAX;
hr = Data->Device->CreateSamplerState(&SampDesc, &Data->SamplerLinear);
if (FAILED(hr)) {
return ProcessFailure(Data->Device, L"Failed to create sampler state in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
}
return DUPL_RETURN_SUCCESS;
}
//
// Getter for the PTR_INFO structure
//
PTR_INFO* THREADMANAGER::GetPointerInfo()
{
return &m_PtrInfo;
}
//
// Waits infinitely for all spawned threads to terminate
//
bool THREADMANAGER::WaitForThreadTermination(DWORD timeout /*= INFINITE*/)
{
bool bRet = true;
if (m_ThreadCount != 0) {
bRet = (WaitForMultipleObjectsEx(m_ThreadCount, m_ThreadHandles, TRUE, timeout, FALSE) != WAIT_TIMEOUT);
}
return bRet;
}
|
