FreeRDP
Loading...
Searching...
No Matches
sdl_render_service.cpp
1
19
20#include <atomic>
21#include <mutex>
22#include <new>
23
24#include <winpr/assert.h>
25#include <winpr/error.h>
26
27#include "sdl_context.hpp"
28#include "sdl_render_service.hpp"
29
30/* The renderers hand their frames to SdlContext, which places and draws them
31 * (presentRenderers). The service lock is held while calling into SdlContext, so detaching
32 * waits for the calls under way. */
33
35template <typename T>
36static HRESULT queryInterface(T* self, const IID* iid, const IID* riid, void** ppvObject)
37{
38 if (!ppvObject)
39 return E_POINTER;
40 *ppvObject = nullptr;
41 if (!riid)
42 return E_POINTER;
43 if (!winpr_com_guid_equal(riid, &WINPR_IID_IUnknown) && !winpr_com_guid_equal(riid, iid))
44 return E_NOINTERFACE;
45 self->AddRef();
46 *ppvObject = self;
47 return S_OK;
48}
49
50namespace
51{
52 class SdlRenderService final : public IWTSBitmapRenderService
53 {
54 public:
55 explicit SdlRenderService(SdlContext* sdl) : _sdl(sdl)
56 {
57 }
58
59 ~SdlRenderService() = default;
60
61 HRESULT WINPR_COM_CALL QueryInterface(const IID* riid, void** ppvObject) override
62 {
63 return queryInterface(this, &IID_IWTSBitmapRenderService, riid, ppvObject);
64 }
65
66 ULONG WINPR_COM_CALL AddRef() override
67 {
68 return ++_refCount;
69 }
70
71 ULONG WINPR_COM_CALL Release() override
72 {
73 const ULONG count = --_refCount;
74 if (count == 0)
75 delete this;
76 return count;
77 }
78
79 HRESULT WINPR_COM_CALL
80 GetMappedRenderer(UINT64 mappingId, IWTSBitmapRendererCallback* pMappedRendererCallback,
81 IWTSBitmapRenderer** ppMappedRenderer) override;
82
83 void detach()
84 {
85 std::scoped_lock lock(_lock);
86 _sdl = nullptr;
87 }
88
90 template <typename Fn> bool withContext(Fn fn)
91 {
92 std::scoped_lock lock(_lock);
93 if (!_sdl)
94 return false;
95 fn(*_sdl);
96 return true;
97 }
98
99 SdlRenderService(const SdlRenderService&) = delete;
100 SdlRenderService(SdlRenderService&&) = delete;
101 SdlRenderService& operator=(const SdlRenderService&) = delete;
102 SdlRenderService& operator=(SdlRenderService&&) = delete;
103
104 private:
105 std::atomic<ULONG> _refCount{ 1 };
106 std::mutex _lock;
107 SdlContext* _sdl; /* nullptr once detached */
108 };
109
110 class SdlRenderer final : public IWTSBitmapRenderer
111 {
112 public:
113 SdlRenderer(SdlRenderService* service, Uint64 id) : _service(service), _id(id)
114 {
115 _service->AddRef();
116 }
117
118 HRESULT WINPR_COM_CALL QueryInterface(const IID* riid, void** ppvObject) override
119 {
120 return queryInterface(this, &IID_IWTSBitmapRenderer, riid, ppvObject);
121 }
122
123 ULONG WINPR_COM_CALL AddRef() override
124 {
125 return ++_refCount;
126 }
127
128 ULONG WINPR_COM_CALL Release() override
129 {
130 const ULONG count = --_refCount;
131 if (count == 0)
132 delete this;
133 return count;
134 }
135
136 HRESULT WINPR_COM_CALL Render(GUID imageFormat, DWORD dwWidth, DWORD dwHeight,
137 LONG cbStride, DWORD cbImageBuffer,
138 BYTE* pImageBuffer) override
139 {
140 /* BGRA only (GUID_NULL) */
141 static const GUID guid_null = {};
142 if (!winpr_com_guid_equal(&imageFormat, &guid_null))
143 return E_INVALIDARG;
144 if (!pImageBuffer || (dwWidth == 0) || (dwHeight == 0) || (dwWidth > 16384) ||
145 (dwHeight > 16384) || (cbStride < static_cast<LONG>(dwWidth * 4)) ||
146 (cbImageBuffer < (static_cast<DWORD>(cbStride) * (dwHeight - 1)) + (dwWidth * 4)))
147 return E_INVALIDARG;
148
149 HRESULT hr = E_UNEXPECTED;
150 std::ignore = _service->withContext(
151 [&](SdlContext& sdl)
152 {
153 if (_removed)
154 return;
155 if (sdl.rendererFrame(_id, pImageBuffer, dwWidth, dwHeight, cbStride))
156 {
157 _stats.dwFramesDelivered++;
158 hr = S_OK;
159 }
160 else
161 _stats.dwFramesDropped++;
162 });
163 return hr;
164 }
165
166 HRESULT WINPR_COM_CALL
167 GetRendererStatistics(BITMAP_RENDERER_STATISTICS* pStatistics) override
168 {
169 if (!pStatistics)
170 return E_POINTER;
171 /* the stats only change under the service lock */
172 if (!_service->withContext([&](SdlContext&) { *pStatistics = _stats; }))
173 *pStatistics = _stats;
174 return S_OK;
175 }
176
177 HRESULT WINPR_COM_CALL RemoveMapping() override
178 {
179 remove();
180 return S_OK;
181 }
182
183 SdlRenderer(const SdlRenderer&) = delete;
184 SdlRenderer(SdlRenderer&&) = delete;
185 SdlRenderer& operator=(const SdlRenderer&) = delete;
186 SdlRenderer& operator=(SdlRenderer&&) = delete;
187
188 private:
189 ~SdlRenderer()
190 {
191 remove();
192 _service->Release();
193 }
194
195 void remove()
196 {
197 std::ignore = _service->withContext(
198 [&](SdlContext& sdl)
199 {
200 if (_removed)
201 return;
202 _removed = true;
203 sdl.rendererRemove(_id);
204 });
205 }
206
207 std::atomic<ULONG> _refCount{ 1 };
208 SdlRenderService* _service; /* a reference */
209 Uint64 _id; /* SdlContext's */
210 bool _removed = false;
211 BITMAP_RENDERER_STATISTICS _stats{};
212 };
213} // namespace
214
215HRESULT WINPR_COM_CALL SdlRenderService::GetMappedRenderer(
216 UINT64 mappingId, IWTSBitmapRendererCallback* pMappedRendererCallback,
217 IWTSBitmapRenderer** ppMappedRenderer)
218{
219 if (!ppMappedRenderer)
220 return E_POINTER;
221 *ppMappedRenderer = nullptr;
222
223 Uint64 id = 0;
224 if (!withContext([&](SdlContext& sdl)
225 { id = sdl.rendererAdd(mappingId, pMappedRendererCallback); }))
226 return E_UNEXPECTED;
227
228 auto renderer = new (std::nothrow) SdlRenderer(this, id);
229 if (!renderer)
230 {
231 std::ignore = withContext([&](SdlContext& sdl) { sdl.rendererRemove(id); });
232 return E_OUTOFMEMORY;
233 }
234 *ppMappedRenderer = renderer;
235 return S_OK;
236}
237
238IWTSBitmapRenderService* sdl_render_service_new(SdlContext* sdl)
239{
240 WINPR_ASSERT(sdl);
241 return new (std::nothrow) SdlRenderService(sdl);
242}
243
244void sdl_render_service_detach(IWTSBitmapRenderService* service)
245{
246 auto s = dynamic_cast<SdlRenderService*>(service);
247 if (s)
248 s->detach();
249}
static BOOL winpr_com_guid_equal(const GUID *a, const GUID *b)
IsEqualGUID.
Definition com.h:166
#define WINPR_COM_CALL
the calling convention of COM methods (STDMETHODCALLTYPE)
Definition com.h:82