FreeRDP
Loading...
Searching...
No Matches
shadow_capture.c
1
19#include <freerdp/config.h>
20
21#include <winpr/crt.h>
22#include <winpr/print.h>
23
24#include <freerdp/log.h>
25
26#include "shadow_surface.h"
27
28#include "shadow_capture.h"
29
30int shadow_capture_align_clip_rect(RECTANGLE_16* rect, const RECTANGLE_16* clip)
31{
32 int dx = 0;
33 int dy = 0;
34 dx = (rect->left % 16);
35
36 if (dx != 0)
37 {
38 rect->left -= dx;
39 rect->right += dx;
40 }
41
42 dx = (rect->right % 16);
43
44 if (dx != 0)
45 {
46 rect->right += (16 - dx);
47 }
48
49 dy = (rect->top % 16);
50
51 if (dy != 0)
52 {
53 rect->top -= dy;
54 rect->bottom += dy;
55 }
56
57 dy = (rect->bottom % 16);
58
59 if (dy != 0)
60 {
61 rect->bottom += (16 - dy);
62 }
63
64 if (rect->left < clip->left)
65 rect->left = clip->left;
66
67 if (rect->top < clip->top)
68 rect->top = clip->top;
69
70 if (rect->right > clip->right)
71 rect->right = clip->right;
72
73 if (rect->bottom > clip->bottom)
74 rect->bottom = clip->bottom;
75
76 return 1;
77}
78
79#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
80int shadow_capture_compare(const BYTE* WINPR_RESTRICT pData1, UINT32 nStep1, UINT32 nWidth,
81 UINT32 nHeight, const BYTE* WINPR_RESTRICT pData2, UINT32 nStep2,
82 RECTANGLE_16* WINPR_RESTRICT rect)
83{
84 return shadow_capture_compare_with_format(pData1, PIXEL_FORMAT_BGRX32, nStep1, nWidth, nHeight,
85 pData2, PIXEL_FORMAT_BGRX32, nStep2, rect);
86}
87#endif
88
89static BOOL color_equal(UINT32 colorA, UINT32 formatA, UINT32 colorB, UINT32 formatB)
90{
91 BYTE ar = 0;
92 BYTE ag = 0;
93 BYTE ab = 0;
94 BYTE aa = 0;
95 BYTE br = 0;
96 BYTE bg = 0;
97 BYTE bb = 0;
98 BYTE ba = 0;
99 FreeRDPSplitColor(colorA, formatA, &ar, &ag, &ab, &aa, NULL);
100 FreeRDPSplitColor(colorB, formatB, &br, &bg, &bb, &ba, NULL);
101
102 if (ar != br)
103 return FALSE;
104 if (ag != bg)
105 return FALSE;
106 if (ab != bb)
107 return FALSE;
108 if (aa != ba)
109 return FALSE;
110 return TRUE;
111}
112
113static BOOL pixel_equal(const BYTE* WINPR_RESTRICT a, UINT32 formatA, const BYTE* WINPR_RESTRICT b,
114 UINT32 formatB, size_t count)
115{
116 const size_t bppA = FreeRDPGetBytesPerPixel(formatA);
117 const size_t bppB = FreeRDPGetBytesPerPixel(formatB);
118
119 for (size_t x = 0; x < count; x++)
120 {
121 const UINT32 colorA = FreeRDPReadColor(&a[bppA * x], formatA);
122 const UINT32 colorB = FreeRDPReadColor(&b[bppB * x], formatB);
123 if (!color_equal(colorA, formatA, colorB, formatB))
124 return FALSE;
125 }
126
127 return TRUE;
128}
129
130static BOOL color_equal_no_alpha(UINT32 colorA, UINT32 formatA, UINT32 colorB, UINT32 formatB)
131{
132 BYTE ar = 0;
133 BYTE ag = 0;
134 BYTE ab = 0;
135 BYTE br = 0;
136 BYTE bg = 0;
137 BYTE bb = 0;
138 FreeRDPSplitColor(colorA, formatA, &ar, &ag, &ab, NULL, NULL);
139 FreeRDPSplitColor(colorB, formatB, &br, &bg, &bb, NULL, NULL);
140
141 if (ar != br)
142 return FALSE;
143 if (ag != bg)
144 return FALSE;
145 if (ab != bb)
146 return FALSE;
147 return TRUE;
148}
149
150static BOOL pixel_equal_no_alpha(const BYTE* WINPR_RESTRICT a, UINT32 formatA,
151 const BYTE* WINPR_RESTRICT b, UINT32 formatB, size_t count)
152{
153 const size_t bppA = FreeRDPGetBytesPerPixel(formatA);
154 const size_t bppB = FreeRDPGetBytesPerPixel(formatB);
155
156 for (size_t x = 0; x < count; x++)
157 {
158 const UINT32 colorA = FreeRDPReadColor(&a[bppA * x], formatA);
159 const UINT32 colorB = FreeRDPReadColor(&b[bppB * x], formatB);
160 if (!color_equal_no_alpha(colorA, formatA, colorB, formatB))
161 return FALSE;
162 }
163
164 return TRUE;
165}
166
167static BOOL pixel_equal_same_format(const BYTE* WINPR_RESTRICT a, UINT32 formatA,
168 const BYTE* WINPR_RESTRICT b, UINT32 formatB, size_t count)
169{
170 if (formatA != formatB)
171 return FALSE;
172 const size_t bppA = FreeRDPGetBytesPerPixel(formatA);
173 return memcmp(a, b, count * bppA) == 0;
174}
175
176typedef BOOL (*pixel_equal_fn_t)(const BYTE* WINPR_RESTRICT a, UINT32 formatA,
177 const BYTE* WINPR_RESTRICT b, UINT32 formatB, size_t count);
178
179static pixel_equal_fn_t get_comparison_fn(DWORD format1, DWORD format2)
180{
181
182 if (format1 == format2)
183 return pixel_equal_same_format;
184
185 const UINT32 bpp1 = FreeRDPGetBitsPerPixel(format1);
186
187 if (!FreeRDPColorHasAlpha(format1) || !FreeRDPColorHasAlpha(format2))
188 {
189 /* In case we have RGBA32 and RGBX32 or similar assume the alpha data is equal.
190 * This allows us to use the fast memcmp comparison. */
191 if ((bpp1 == 32) && FreeRDPAreColorFormatsEqualNoAlpha(format1, format2))
192 {
193 switch (format1)
194 {
195 case PIXEL_FORMAT_ARGB32:
196 case PIXEL_FORMAT_XRGB32:
197 case PIXEL_FORMAT_ABGR32:
198 case PIXEL_FORMAT_XBGR32:
199 return pixel_equal;
200 case PIXEL_FORMAT_RGBA32:
201 case PIXEL_FORMAT_RGBX32:
202 case PIXEL_FORMAT_BGRA32:
203 case PIXEL_FORMAT_BGRX32:
204 return pixel_equal;
205 default:
206 break;
207 }
208 }
209 return pixel_equal_no_alpha;
210 }
211 else
212 return pixel_equal_no_alpha;
213}
214
215int shadow_capture_compare_with_format(const BYTE* WINPR_RESTRICT pData1, UINT32 format1,
216 UINT32 nStep1, UINT32 nWidth, UINT32 nHeight,
217 const BYTE* WINPR_RESTRICT pData2, UINT32 format2,
218 UINT32 nStep2, RECTANGLE_16* WINPR_RESTRICT rect)
219{
220 pixel_equal_fn_t pixel_equal_fn = get_comparison_fn(format1, format2);
221 BOOL allEqual = TRUE;
222 UINT32 tw = 0;
223 const UINT32 nrow = (nHeight + 15) / 16;
224 const UINT32 ncol = (nWidth + 15) / 16;
225 UINT32 l = ncol + 1;
226 UINT32 t = nrow + 1;
227 UINT32 r = 0;
228 UINT32 b = 0;
229 const size_t bppA = FreeRDPGetBytesPerPixel(format1);
230 const size_t bppB = FreeRDPGetBytesPerPixel(format2);
231 const RECTANGLE_16 empty = { 0 };
232 WINPR_ASSERT(rect);
233
234 *rect = empty;
235
236 for (size_t ty = 0; ty < nrow; ty++)
237 {
238 BOOL rowEqual = TRUE;
239 size_t th = ((ty + 1) == nrow) ? (nHeight % 16) : 16;
240
241 if (!th)
242 th = 16;
243
244 for (size_t tx = 0; tx < ncol; tx++)
245 {
246 BOOL equal = TRUE;
247 tw = ((tx + 1) == ncol) ? (nWidth % 16) : 16;
248
249 if (!tw)
250 tw = 16;
251
252 const BYTE* p1 = &pData1[(ty * 16ULL * nStep1) + (tx * 16ull * bppA)];
253 const BYTE* p2 = &pData2[(ty * 16ULL * nStep2) + (tx * 16ull * bppB)];
254
255 for (size_t k = 0; k < th; k++)
256 {
257 if (!pixel_equal_fn(p1, format1, p2, format2, tw))
258 {
259 equal = FALSE;
260 break;
261 }
262
263 p1 += nStep1;
264 p2 += nStep2;
265 }
266
267 if (!equal)
268 {
269 rowEqual = FALSE;
270 if (l > tx)
271 l = (UINT32)tx;
272
273 if (r < tx)
274 r = (UINT32)tx;
275 }
276 }
277
278 if (!rowEqual)
279 {
280 allEqual = FALSE;
281
282 if (t > ty)
283 t = (UINT32)ty;
284
285 if (b < ty)
286 b = (UINT32)ty;
287 }
288 }
289
290 if (allEqual)
291 return 0;
292
293 WINPR_ASSERT(l * 16 <= UINT16_MAX);
294 WINPR_ASSERT(t * 16 <= UINT16_MAX);
295 WINPR_ASSERT((r + 1) * 16 <= UINT16_MAX);
296 WINPR_ASSERT((b + 1) * 16 <= UINT16_MAX);
297 rect->left = (UINT16)l * 16;
298 rect->top = (UINT16)t * 16;
299 rect->right = (UINT16)(r + 1) * 16;
300 rect->bottom = (UINT16)(b + 1) * 16;
301
302 WINPR_ASSERT(nWidth <= UINT16_MAX);
303 if (rect->right > nWidth)
304 rect->right = (UINT16)nWidth;
305
306 WINPR_ASSERT(nHeight <= UINT16_MAX);
307 if (rect->bottom > nHeight)
308 rect->bottom = (UINT16)nHeight;
309
310 return 1;
311}
312
313rdpShadowCapture* shadow_capture_new(rdpShadowServer* server)
314{
315 WINPR_ASSERT(server);
316
317 rdpShadowCapture* capture = (rdpShadowCapture*)calloc(1, sizeof(rdpShadowCapture));
318
319 if (!capture)
320 return NULL;
321
322 capture->server = server;
323
324 if (!InitializeCriticalSectionAndSpinCount(&(capture->lock), 4000))
325 {
326 WINPR_PRAGMA_DIAG_PUSH
327 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
328 shadow_capture_free(capture);
329 WINPR_PRAGMA_DIAG_POP
330 return NULL;
331 }
332
333 return capture;
334}
335
336void shadow_capture_free(rdpShadowCapture* capture)
337{
338 if (!capture)
339 return;
340
341 DeleteCriticalSection(&(capture->lock));
342 free(capture);
343}
RECTANGLE_16
Definition types.h:109