/src/FreeRDP/libfreerdp/codec/interleaved.c
Line | Count | Source (jump to first uncovered line) |
1 | | /** |
2 | | * FreeRDP: A Remote Desktop Protocol Implementation |
3 | | * Interleaved RLE Bitmap Codec |
4 | | * |
5 | | * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com> |
6 | | * Copyright 2015 Thincast Technologies GmbH |
7 | | * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com> |
8 | | * Copyright 2016 Armin Novak <armin.novak@thincast.com> |
9 | | * Copyright 2016 Thincast Technologies GmbH |
10 | | * |
11 | | * Licensed under the Apache License, Version 2.0 (the "License"); |
12 | | * you may not use this file except in compliance with the License. |
13 | | * You may obtain a copy of the License at |
14 | | * |
15 | | * http://www.apache.org/licenses/LICENSE-2.0 |
16 | | * |
17 | | * Unless required by applicable law or agreed to in writing, software |
18 | | * distributed under the License is distributed on an "AS IS" BASIS, |
19 | | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
20 | | * See the License for the specific language governing permissions and |
21 | | * limitations under the License. |
22 | | */ |
23 | | |
24 | | #include <winpr/assert.h> |
25 | | #include <freerdp/config.h> |
26 | | |
27 | | #include <freerdp/codec/interleaved.h> |
28 | | #include <freerdp/log.h> |
29 | | |
30 | | #define TAG FREERDP_TAG("codec") |
31 | | |
32 | | #define UNROLL_BODY(_exp, _count) \ |
33 | 0 | do \ |
34 | 0 | { \ |
35 | 0 | for (size_t x = 0; x < (_count); x++) \ |
36 | 0 | { \ |
37 | 0 | do \ |
38 | 0 | { \ |
39 | 0 | _exp \ |
40 | 0 | } while (FALSE); \ |
41 | 0 | } \ |
42 | 0 | } while (FALSE) |
43 | | |
44 | | #define UNROLL_MULTIPLE(_condition, _exp, _count) \ |
45 | 0 | do \ |
46 | 0 | { \ |
47 | 0 | while ((_condition) >= (_count)) \ |
48 | 0 | { \ |
49 | 0 | UNROLL_BODY(_exp, _count); \ |
50 | 0 | (_condition) -= (_count); \ |
51 | 0 | } \ |
52 | 0 | } while (FALSE) |
53 | | |
54 | | #define UNROLL(_condition, _exp) \ |
55 | 0 | do \ |
56 | 0 | { \ |
57 | 0 | UNROLL_MULTIPLE(_condition, _exp, 16); \ |
58 | 0 | UNROLL_MULTIPLE(_condition, _exp, 4); \ |
59 | 0 | UNROLL_MULTIPLE(_condition, _exp, 1); \ |
60 | 0 | } while (FALSE) |
61 | | |
62 | | /* |
63 | | RLE Compressed Bitmap Stream (RLE_BITMAP_STREAM) |
64 | | http://msdn.microsoft.com/en-us/library/cc240895%28v=prot.10%29.aspx |
65 | | pseudo-code |
66 | | http://msdn.microsoft.com/en-us/library/dd240593%28v=prot.10%29.aspx |
67 | | */ |
68 | | |
69 | 0 | #define REGULAR_BG_RUN 0x00 |
70 | 0 | #define MEGA_MEGA_BG_RUN 0xF0 |
71 | 0 | #define REGULAR_FG_RUN 0x01 |
72 | 0 | #define MEGA_MEGA_FG_RUN 0xF1 |
73 | 0 | #define LITE_SET_FG_FG_RUN 0x0C |
74 | 0 | #define MEGA_MEGA_SET_FG_RUN 0xF6 |
75 | 0 | #define LITE_DITHERED_RUN 0x0E |
76 | 0 | #define MEGA_MEGA_DITHERED_RUN 0xF8 |
77 | 0 | #define REGULAR_COLOR_RUN 0x03 |
78 | 0 | #define MEGA_MEGA_COLOR_RUN 0xF3 |
79 | 0 | #define REGULAR_FGBG_IMAGE 0x02 |
80 | 0 | #define MEGA_MEGA_FGBG_IMAGE 0xF2 |
81 | 0 | #define LITE_SET_FG_FGBG_IMAGE 0x0D |
82 | 0 | #define MEGA_MEGA_SET_FGBG_IMAGE 0xF7 |
83 | 0 | #define REGULAR_COLOR_IMAGE 0x04 |
84 | 0 | #define MEGA_MEGA_COLOR_IMAGE 0xF4 |
85 | 0 | #define SPECIAL_FGBG_1 0xF9 |
86 | 0 | #define SPECIAL_FGBG_2 0xFA |
87 | 0 | #define SPECIAL_WHITE 0xFD |
88 | 0 | #define SPECIAL_BLACK 0xFE |
89 | | |
90 | | #define BLACK_PIXEL 0x000000 |
91 | | |
92 | | typedef UINT32 PIXEL; |
93 | | |
94 | | static const BYTE g_MaskSpecialFgBg1 = 0x03; |
95 | | static const BYTE g_MaskSpecialFgBg2 = 0x05; |
96 | | |
97 | | static const BYTE g_MaskRegularRunLength = 0x1F; |
98 | | static const BYTE g_MaskLiteRunLength = 0x0F; |
99 | | |
100 | | static const char* rle_code_str(UINT32 code) |
101 | 0 | { |
102 | 0 | switch (code) |
103 | 0 | { |
104 | 0 | case REGULAR_BG_RUN: |
105 | 0 | return "REGULAR_BG_RUN"; |
106 | 0 | case MEGA_MEGA_BG_RUN: |
107 | 0 | return "MEGA_MEGA_BG_RUN"; |
108 | 0 | case REGULAR_FG_RUN: |
109 | 0 | return "REGULAR_FG_RUN"; |
110 | 0 | case MEGA_MEGA_FG_RUN: |
111 | 0 | return "MEGA_MEGA_FG_RUN"; |
112 | 0 | case LITE_SET_FG_FG_RUN: |
113 | 0 | return "LITE_SET_FG_FG_RUN"; |
114 | 0 | case MEGA_MEGA_SET_FG_RUN: |
115 | 0 | return "MEGA_MEGA_SET_FG_RUN"; |
116 | 0 | case LITE_DITHERED_RUN: |
117 | 0 | return "LITE_DITHERED_RUN"; |
118 | 0 | case MEGA_MEGA_DITHERED_RUN: |
119 | 0 | return "MEGA_MEGA_DITHERED_RUN"; |
120 | 0 | case REGULAR_COLOR_RUN: |
121 | 0 | return "REGULAR_COLOR_RUN"; |
122 | 0 | case MEGA_MEGA_COLOR_RUN: |
123 | 0 | return "MEGA_MEGA_COLOR_RUN"; |
124 | 0 | case REGULAR_FGBG_IMAGE: |
125 | 0 | return "REGULAR_FGBG_IMAGE"; |
126 | 0 | case MEGA_MEGA_FGBG_IMAGE: |
127 | 0 | return "MEGA_MEGA_FGBG_IMAGE"; |
128 | 0 | case LITE_SET_FG_FGBG_IMAGE: |
129 | 0 | return "LITE_SET_FG_FGBG_IMAGE"; |
130 | 0 | case MEGA_MEGA_SET_FGBG_IMAGE: |
131 | 0 | return "MEGA_MEGA_SET_FGBG_IMAGE"; |
132 | 0 | case REGULAR_COLOR_IMAGE: |
133 | 0 | return "REGULAR_COLOR_IMAGE"; |
134 | 0 | case MEGA_MEGA_COLOR_IMAGE: |
135 | 0 | return "MEGA_MEGA_COLOR_IMAGE"; |
136 | 0 | case SPECIAL_FGBG_1: |
137 | 0 | return "SPECIAL_FGBG_1"; |
138 | 0 | case SPECIAL_FGBG_2: |
139 | 0 | return "SPECIAL_FGBG_2"; |
140 | 0 | case SPECIAL_WHITE: |
141 | 0 | return "SPECIAL_WHITE"; |
142 | 0 | case SPECIAL_BLACK: |
143 | 0 | return "SPECIAL_BLACK"; |
144 | 0 | default: |
145 | 0 | return "UNKNOWN"; |
146 | 0 | } |
147 | 0 | } |
148 | | |
149 | | static const char* rle_code_str_buffer(UINT32 code, char* buffer, size_t size) |
150 | 0 | { |
151 | 0 | const char* str = rle_code_str(code); |
152 | 0 | (void)_snprintf(buffer, size, "%s [0x%08" PRIx32 "]", str, code); |
153 | 0 | return buffer; |
154 | 0 | } |
155 | | |
156 | | #define buffer_within_range(pbSrc, size, pbEnd) \ |
157 | 0 | buffer_within_range_((pbSrc), (size), (pbEnd), __func__, __FILE__, __LINE__) |
158 | | static INLINE BOOL buffer_within_range_(const void* pbSrc, size_t size, const void* pbEnd, |
159 | | const char* fkt, const char* file, size_t line) |
160 | 0 | { |
161 | 0 | WINPR_UNUSED(file); |
162 | 0 | WINPR_ASSERT(pbSrc); |
163 | 0 | WINPR_ASSERT(pbEnd); |
164 | | |
165 | 0 | if ((const char*)pbSrc + size > (const char*)pbEnd) |
166 | 0 | { |
167 | 0 | WLog_ERR(TAG, "[%s:%" PRIuz "] pbSrc=%p + %" PRIuz " > pbEnd=%p", fkt, line, pbSrc, size, |
168 | 0 | pbEnd); |
169 | 0 | return FALSE; |
170 | 0 | } |
171 | 0 | return TRUE; |
172 | 0 | } |
173 | | |
174 | | /** |
175 | | * Reads the supplied order header and extracts the compression |
176 | | * order code ID. |
177 | | */ |
178 | | static INLINE UINT32 ExtractCodeId(BYTE bOrderHdr) |
179 | 0 | { |
180 | 0 | if ((bOrderHdr & 0xC0U) != 0xC0U) |
181 | 0 | { |
182 | | /* REGULAR orders |
183 | | * (000x xxxx, 001x xxxx, 010x xxxx, 011x xxxx, 100x xxxx) |
184 | | */ |
185 | 0 | return bOrderHdr >> 5; |
186 | 0 | } |
187 | 0 | else if ((bOrderHdr & 0xF0U) == 0xF0U) |
188 | 0 | { |
189 | | /* MEGA and SPECIAL orders (0xF*) */ |
190 | 0 | return bOrderHdr; |
191 | 0 | } |
192 | 0 | else |
193 | 0 | { |
194 | | /* LITE orders |
195 | | * 1100 xxxx, 1101 xxxx, 1110 xxxx) |
196 | | */ |
197 | 0 | return bOrderHdr >> 4; |
198 | 0 | } |
199 | 0 | } |
200 | | |
201 | | /** |
202 | | * Extract the run length of a compression order. |
203 | | */ |
204 | | static UINT ExtractRunLengthRegularFgBg(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance) |
205 | 0 | { |
206 | 0 | UINT runLength = 0; |
207 | |
|
208 | 0 | WINPR_ASSERT(pbOrderHdr); |
209 | 0 | WINPR_ASSERT(pbEnd); |
210 | 0 | WINPR_ASSERT(advance); |
211 | | |
212 | 0 | runLength = (*pbOrderHdr) & g_MaskRegularRunLength; |
213 | 0 | if (runLength == 0) |
214 | 0 | { |
215 | 0 | if (!buffer_within_range(pbOrderHdr, 2, pbEnd)) |
216 | 0 | { |
217 | 0 | *advance = 0; |
218 | 0 | return 0; |
219 | 0 | } |
220 | 0 | runLength = *(pbOrderHdr + 1) + 1; |
221 | 0 | (*advance)++; |
222 | 0 | } |
223 | 0 | else |
224 | 0 | runLength = runLength * 8; |
225 | | |
226 | 0 | return runLength; |
227 | 0 | } |
228 | | |
229 | | static UINT ExtractRunLengthLiteFgBg(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance) |
230 | 0 | { |
231 | 0 | UINT runLength = 0; |
232 | |
|
233 | 0 | WINPR_ASSERT(pbOrderHdr); |
234 | 0 | WINPR_ASSERT(pbEnd); |
235 | 0 | WINPR_ASSERT(advance); |
236 | | |
237 | 0 | runLength = *pbOrderHdr & g_MaskLiteRunLength; |
238 | 0 | if (runLength == 0) |
239 | 0 | { |
240 | 0 | if (!buffer_within_range(pbOrderHdr, 2, pbEnd)) |
241 | 0 | { |
242 | 0 | *advance = 0; |
243 | 0 | return 0; |
244 | 0 | } |
245 | 0 | runLength = *(pbOrderHdr + 1) + 1; |
246 | 0 | (*advance)++; |
247 | 0 | } |
248 | 0 | else |
249 | 0 | runLength = runLength * 8; |
250 | | |
251 | 0 | return runLength; |
252 | 0 | } |
253 | | |
254 | | static UINT ExtractRunLengthRegular(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance) |
255 | 0 | { |
256 | 0 | UINT runLength = 0; |
257 | |
|
258 | 0 | WINPR_ASSERT(pbOrderHdr); |
259 | 0 | WINPR_ASSERT(pbEnd); |
260 | 0 | WINPR_ASSERT(advance); |
261 | | |
262 | 0 | runLength = *pbOrderHdr & g_MaskRegularRunLength; |
263 | 0 | if (runLength == 0) |
264 | 0 | { |
265 | 0 | if (!buffer_within_range(pbOrderHdr, 2, pbEnd)) |
266 | 0 | { |
267 | 0 | *advance = 0; |
268 | 0 | return 0; |
269 | 0 | } |
270 | 0 | runLength = *(pbOrderHdr + 1) + 32; |
271 | 0 | (*advance)++; |
272 | 0 | } |
273 | | |
274 | 0 | return runLength; |
275 | 0 | } |
276 | | |
277 | | static UINT ExtractRunLengthMegaMega(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance) |
278 | 0 | { |
279 | 0 | UINT runLength = 0; |
280 | |
|
281 | 0 | WINPR_ASSERT(pbOrderHdr); |
282 | 0 | WINPR_ASSERT(pbEnd); |
283 | 0 | WINPR_ASSERT(advance); |
284 | | |
285 | 0 | if (!buffer_within_range(pbOrderHdr, 3, pbEnd)) |
286 | 0 | { |
287 | 0 | *advance = 0; |
288 | 0 | return 0; |
289 | 0 | } |
290 | | |
291 | 0 | runLength = ((UINT16)pbOrderHdr[1]) | (((UINT16)pbOrderHdr[2]) << 8); |
292 | 0 | (*advance) += 2; |
293 | |
|
294 | 0 | return runLength; |
295 | 0 | } |
296 | | |
297 | | static UINT ExtractRunLengthLite(const BYTE* pbOrderHdr, const BYTE* pbEnd, UINT32* advance) |
298 | 0 | { |
299 | 0 | UINT runLength = 0; |
300 | |
|
301 | 0 | WINPR_ASSERT(pbOrderHdr); |
302 | 0 | WINPR_ASSERT(pbEnd); |
303 | 0 | WINPR_ASSERT(advance); |
304 | | |
305 | 0 | runLength = *pbOrderHdr & g_MaskLiteRunLength; |
306 | 0 | if (runLength == 0) |
307 | 0 | { |
308 | 0 | if (!buffer_within_range(pbOrderHdr, 2, pbEnd)) |
309 | 0 | { |
310 | 0 | *advance = 0; |
311 | 0 | return 0; |
312 | 0 | } |
313 | 0 | runLength = *(pbOrderHdr + 1) + 16; |
314 | 0 | (*advance)++; |
315 | 0 | } |
316 | 0 | return runLength; |
317 | 0 | } |
318 | | |
319 | | static INLINE UINT32 ExtractRunLength(UINT32 code, const BYTE* pbOrderHdr, const BYTE* pbEnd, |
320 | | UINT32* advance) |
321 | 0 | { |
322 | 0 | UINT32 runLength = 0; |
323 | 0 | UINT32 ladvance = 1; |
324 | |
|
325 | 0 | WINPR_ASSERT(pbOrderHdr); |
326 | 0 | WINPR_ASSERT(pbEnd); |
327 | 0 | WINPR_ASSERT(advance); |
328 | | |
329 | 0 | *advance = 0; |
330 | 0 | if (!buffer_within_range(pbOrderHdr, 0, pbEnd)) |
331 | 0 | return 0; |
332 | | |
333 | 0 | switch (code) |
334 | 0 | { |
335 | 0 | case REGULAR_FGBG_IMAGE: |
336 | 0 | runLength = ExtractRunLengthRegularFgBg(pbOrderHdr, pbEnd, &ladvance); |
337 | 0 | break; |
338 | | |
339 | 0 | case LITE_SET_FG_FGBG_IMAGE: |
340 | 0 | runLength = ExtractRunLengthLiteFgBg(pbOrderHdr, pbEnd, &ladvance); |
341 | 0 | break; |
342 | | |
343 | 0 | case REGULAR_BG_RUN: |
344 | 0 | case REGULAR_FG_RUN: |
345 | 0 | case REGULAR_COLOR_RUN: |
346 | 0 | case REGULAR_COLOR_IMAGE: |
347 | 0 | runLength = ExtractRunLengthRegular(pbOrderHdr, pbEnd, &ladvance); |
348 | 0 | break; |
349 | | |
350 | 0 | case LITE_SET_FG_FG_RUN: |
351 | 0 | case LITE_DITHERED_RUN: |
352 | 0 | runLength = ExtractRunLengthLite(pbOrderHdr, pbEnd, &ladvance); |
353 | 0 | break; |
354 | | |
355 | 0 | case MEGA_MEGA_BG_RUN: |
356 | 0 | case MEGA_MEGA_FG_RUN: |
357 | 0 | case MEGA_MEGA_SET_FG_RUN: |
358 | 0 | case MEGA_MEGA_DITHERED_RUN: |
359 | 0 | case MEGA_MEGA_COLOR_RUN: |
360 | 0 | case MEGA_MEGA_FGBG_IMAGE: |
361 | 0 | case MEGA_MEGA_SET_FGBG_IMAGE: |
362 | 0 | case MEGA_MEGA_COLOR_IMAGE: |
363 | 0 | runLength = ExtractRunLengthMegaMega(pbOrderHdr, pbEnd, &ladvance); |
364 | 0 | break; |
365 | | |
366 | 0 | default: |
367 | 0 | runLength = 0; |
368 | 0 | ladvance = 0; |
369 | 0 | break; |
370 | 0 | } |
371 | | |
372 | 0 | *advance = ladvance; |
373 | 0 | return runLength; |
374 | 0 | } |
375 | | |
376 | | #define ensure_capacity(start, end, size, base) \ |
377 | 0 | ensure_capacity_((start), (end), (size), (base), __func__, __FILE__, __LINE__) |
378 | | static INLINE BOOL ensure_capacity_(const BYTE* start, const BYTE* end, size_t size, size_t base, |
379 | | const char* fkt, const char* file, size_t line) |
380 | 0 | { |
381 | 0 | const size_t available = (uintptr_t)end - (uintptr_t)start; |
382 | 0 | const BOOL rc = available >= size * base; |
383 | 0 | const BOOL res = rc && (start <= end); |
384 | |
|
385 | 0 | if (!res) |
386 | 0 | WLog_ERR(TAG, |
387 | 0 | "[%s:%" PRIuz "] failed: start=%p <= end=%p, available=%" PRIuz " >= size=%" PRIuz |
388 | 0 | " * base=%" PRIuz, |
389 | 0 | fkt, line, start, end, available, size, base); |
390 | 0 | return res; |
391 | 0 | } |
392 | | |
393 | | static INLINE void write_pixel_8(BYTE* _buf, BYTE _pix) |
394 | 0 | { |
395 | 0 | WINPR_ASSERT(_buf); |
396 | 0 | *_buf = _pix; |
397 | 0 | } |
398 | | |
399 | | static INLINE void write_pixel_24(BYTE* _buf, UINT32 _pix) |
400 | 0 | { |
401 | 0 | WINPR_ASSERT(_buf); |
402 | 0 | (_buf)[0] = (BYTE)(_pix); |
403 | 0 | (_buf)[1] = (BYTE)((_pix) >> 8); |
404 | 0 | (_buf)[2] = (BYTE)((_pix) >> 16); |
405 | 0 | } |
406 | | |
407 | | static INLINE void write_pixel_16(BYTE* _buf, UINT16 _pix) |
408 | 0 | { |
409 | 0 | WINPR_ASSERT(_buf); |
410 | 0 | _buf[0] = _pix & 0xFF; |
411 | 0 | _buf[1] = (_pix >> 8) & 0xFF; |
412 | 0 | } |
413 | | |
414 | | #undef DESTWRITEPIXEL |
415 | | #undef DESTREADPIXEL |
416 | | #undef SRCREADPIXEL |
417 | | #undef WRITEFGBGIMAGE |
418 | | #undef WRITEFIRSTLINEFGBGIMAGE |
419 | | #undef RLEDECOMPRESS |
420 | | #undef RLEEXTRA |
421 | | #undef WHITE_PIXEL |
422 | | #undef PIXEL_SIZE |
423 | | #undef PIXEL |
424 | | #define PIXEL_SIZE 1 |
425 | 0 | #define PIXEL BYTE |
426 | 0 | #define WHITE_PIXEL 0xFF |
427 | | #define DESTWRITEPIXEL(_buf, _pix) \ |
428 | 0 | do \ |
429 | 0 | { \ |
430 | 0 | write_pixel_8(_buf, _pix); \ |
431 | 0 | (_buf) += 1; \ |
432 | 0 | } while (0) |
433 | 0 | #define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0] |
434 | | #define SRCREADPIXEL(_pix, _buf) \ |
435 | 0 | do \ |
436 | 0 | { \ |
437 | 0 | (_pix) = (_buf)[0]; \ |
438 | 0 | (_buf) += 1; \ |
439 | 0 | } while (0) |
440 | | |
441 | 0 | #define WRITEFGBGIMAGE WriteFgBgImage8to8 |
442 | 0 | #define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage8to8 |
443 | | #define RLEDECOMPRESS RleDecompress8to8 |
444 | | #define RLEEXTRA |
445 | | #undef ENSURE_CAPACITY |
446 | 0 | #define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 1) |
447 | | #include "include/bitmap.h" |
448 | | |
449 | | #undef DESTWRITEPIXEL |
450 | | #undef DESTREADPIXEL |
451 | | #undef SRCREADPIXEL |
452 | | #undef WRITEFGBGIMAGE |
453 | | #undef WRITEFIRSTLINEFGBGIMAGE |
454 | | #undef RLEDECOMPRESS |
455 | | #undef RLEEXTRA |
456 | | #undef WHITE_PIXEL |
457 | | #undef PIXEL_SIZE |
458 | | #undef PIXEL |
459 | | #define PIXEL_SIZE 2 |
460 | 0 | #define PIXEL UINT16 |
461 | 0 | #define WHITE_PIXEL 0xFFFF |
462 | | #define DESTWRITEPIXEL(_buf, _pix) \ |
463 | 0 | do \ |
464 | 0 | { \ |
465 | 0 | write_pixel_16(_buf, _pix); \ |
466 | 0 | (_buf) += 2; \ |
467 | 0 | } while (0) |
468 | 0 | #define DESTREADPIXEL(_pix, _buf) _pix = ((UINT16*)(_buf))[0] |
469 | | #define SRCREADPIXEL(_pix, _buf) \ |
470 | 0 | do \ |
471 | 0 | { \ |
472 | 0 | (_pix) = (_buf)[0] | ((_buf)[1] << 8); \ |
473 | 0 | (_buf) += 2; \ |
474 | 0 | } while (0) |
475 | 0 | #define WRITEFGBGIMAGE WriteFgBgImage16to16 |
476 | 0 | #define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage16to16 |
477 | | #define RLEDECOMPRESS RleDecompress16to16 |
478 | | #define RLEEXTRA |
479 | | #undef ENSURE_CAPACITY |
480 | 0 | #define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 2) |
481 | | #include "include/bitmap.h" |
482 | | |
483 | | #undef DESTWRITEPIXEL |
484 | | #undef DESTREADPIXEL |
485 | | #undef SRCREADPIXEL |
486 | | #undef WRITEFGBGIMAGE |
487 | | #undef WRITEFIRSTLINEFGBGIMAGE |
488 | | #undef RLEDECOMPRESS |
489 | | #undef RLEEXTRA |
490 | | #undef WHITE_PIXEL |
491 | | #undef PIXEL_SIZE |
492 | | #undef PIXEL |
493 | | #define PIXEL_SIZE 3 |
494 | 0 | #define PIXEL UINT32 |
495 | 0 | #define WHITE_PIXEL 0xffffff |
496 | | #define DESTWRITEPIXEL(_buf, _pix) \ |
497 | 0 | do \ |
498 | 0 | { \ |
499 | 0 | write_pixel_24(_buf, _pix); \ |
500 | 0 | (_buf) += 3; \ |
501 | 0 | } while (0) |
502 | 0 | #define DESTREADPIXEL(_pix, _buf) _pix = (_buf)[0] | ((_buf)[1] << 8) | ((_buf)[2] << 16) |
503 | | #define SRCREADPIXEL(_pix, _buf) \ |
504 | 0 | do \ |
505 | 0 | { \ |
506 | 0 | (_pix) = (_buf)[0] | ((_buf)[1] << 8) | ((_buf)[2] << 16); \ |
507 | 0 | (_buf) += 3; \ |
508 | 0 | } while (0) |
509 | | |
510 | 0 | #define WRITEFGBGIMAGE WriteFgBgImage24to24 |
511 | 0 | #define WRITEFIRSTLINEFGBGIMAGE WriteFirstLineFgBgImage24to24 |
512 | | #define RLEDECOMPRESS RleDecompress24to24 |
513 | | #define RLEEXTRA |
514 | | #undef ENSURE_CAPACITY |
515 | 0 | #define ENSURE_CAPACITY(_start, _end, _size) ensure_capacity(_start, _end, _size, 3) |
516 | | #include "include/bitmap.h" |
517 | | |
518 | | struct S_BITMAP_INTERLEAVED_CONTEXT |
519 | | { |
520 | | BOOL Compressor; |
521 | | |
522 | | UINT32 TempSize; |
523 | | BYTE* TempBuffer; |
524 | | |
525 | | wStream* bts; |
526 | | }; |
527 | | |
528 | | BOOL interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved, |
529 | | const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 nSrcWidth, |
530 | | UINT32 nSrcHeight, UINT32 bpp, BYTE* WINPR_RESTRICT pDstData, |
531 | | UINT32 DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, |
532 | | UINT32 nDstWidth, UINT32 nDstHeight, |
533 | | const gdiPalette* WINPR_RESTRICT palette) |
534 | 0 | { |
535 | 0 | UINT32 scanline = 0; |
536 | 0 | UINT32 SrcFormat = 0; |
537 | 0 | UINT32 BufferSize = 0; |
538 | |
|
539 | 0 | if (!interleaved || !pSrcData || !pDstData) |
540 | 0 | { |
541 | 0 | WLog_ERR(TAG, "invalid arguments: interleaved=%p, pSrcData=%p, pDstData=%p", interleaved, |
542 | 0 | pSrcData, pDstData); |
543 | 0 | return FALSE; |
544 | 0 | } |
545 | | |
546 | 0 | switch (bpp) |
547 | 0 | { |
548 | 0 | case 24: |
549 | 0 | scanline = nSrcWidth * 3; |
550 | 0 | SrcFormat = PIXEL_FORMAT_BGR24; |
551 | 0 | break; |
552 | | |
553 | 0 | case 16: |
554 | 0 | scanline = nSrcWidth * 2; |
555 | 0 | SrcFormat = PIXEL_FORMAT_RGB16; |
556 | 0 | break; |
557 | | |
558 | 0 | case 15: |
559 | 0 | scanline = nSrcWidth * 2; |
560 | 0 | SrcFormat = PIXEL_FORMAT_RGB15; |
561 | 0 | break; |
562 | | |
563 | 0 | case 8: |
564 | 0 | scanline = nSrcWidth; |
565 | 0 | SrcFormat = PIXEL_FORMAT_RGB8; |
566 | 0 | break; |
567 | | |
568 | 0 | default: |
569 | 0 | WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp); |
570 | 0 | return FALSE; |
571 | 0 | } |
572 | | |
573 | 0 | BufferSize = scanline * nSrcHeight; |
574 | |
|
575 | 0 | if (BufferSize > interleaved->TempSize) |
576 | 0 | { |
577 | 0 | interleaved->TempBuffer = |
578 | 0 | winpr_aligned_recalloc(interleaved->TempBuffer, BufferSize, sizeof(BYTE), 16); |
579 | 0 | interleaved->TempSize = BufferSize; |
580 | 0 | } |
581 | |
|
582 | 0 | if (!interleaved->TempBuffer) |
583 | 0 | { |
584 | 0 | WLog_ERR(TAG, "interleaved->TempBuffer=%p", interleaved->TempBuffer); |
585 | 0 | return FALSE; |
586 | 0 | } |
587 | | |
588 | 0 | switch (bpp) |
589 | 0 | { |
590 | 0 | case 24: |
591 | 0 | if (!RleDecompress24to24(pSrcData, SrcSize, interleaved->TempBuffer, scanline, |
592 | 0 | nSrcWidth, nSrcHeight)) |
593 | 0 | { |
594 | 0 | WLog_ERR(TAG, "RleDecompress24to24 failed"); |
595 | 0 | return FALSE; |
596 | 0 | } |
597 | | |
598 | 0 | break; |
599 | | |
600 | 0 | case 16: |
601 | 0 | case 15: |
602 | 0 | if (!RleDecompress16to16(pSrcData, SrcSize, interleaved->TempBuffer, scanline, |
603 | 0 | nSrcWidth, nSrcHeight)) |
604 | 0 | { |
605 | 0 | WLog_ERR(TAG, "RleDecompress16to16 failed"); |
606 | 0 | return FALSE; |
607 | 0 | } |
608 | | |
609 | 0 | break; |
610 | | |
611 | 0 | case 8: |
612 | 0 | if (!RleDecompress8to8(pSrcData, SrcSize, interleaved->TempBuffer, scanline, nSrcWidth, |
613 | 0 | nSrcHeight)) |
614 | 0 | { |
615 | 0 | WLog_ERR(TAG, "RleDecompress8to8 failed"); |
616 | 0 | return FALSE; |
617 | 0 | } |
618 | | |
619 | 0 | break; |
620 | | |
621 | 0 | default: |
622 | 0 | WLog_ERR(TAG, "Invalid color depth %" PRIu32 "", bpp); |
623 | 0 | return FALSE; |
624 | 0 | } |
625 | | |
626 | 0 | if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStep, nXDst, nYDst, nDstWidth, |
627 | 0 | nDstHeight, interleaved->TempBuffer, SrcFormat, scanline, 0, |
628 | 0 | 0, palette, FREERDP_FLIP_VERTICAL | FREERDP_KEEP_DST_ALPHA)) |
629 | 0 | { |
630 | 0 | WLog_ERR(TAG, "freerdp_image_copy failed"); |
631 | 0 | return FALSE; |
632 | 0 | } |
633 | 0 | return TRUE; |
634 | 0 | } |
635 | | |
636 | | BOOL interleaved_compress(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved, |
637 | | BYTE* WINPR_RESTRICT pDstData, UINT32* pDstSize, UINT32 nWidth, |
638 | | UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcFormat, |
639 | | UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, |
640 | | const gdiPalette* WINPR_RESTRICT palette, UINT32 bpp) |
641 | 0 | { |
642 | 0 | BOOL status = 0; |
643 | 0 | wStream* s = NULL; |
644 | 0 | UINT32 DstFormat = 0; |
645 | 0 | const UINT32 maxSize = 64 * 64 * 4; |
646 | |
|
647 | 0 | if (!interleaved || !pDstData || !pSrcData) |
648 | 0 | return FALSE; |
649 | | |
650 | 0 | if ((nWidth == 0) || (nHeight == 0)) |
651 | 0 | return FALSE; |
652 | | |
653 | 0 | if (nWidth % 4) |
654 | 0 | { |
655 | 0 | WLog_ERR(TAG, "interleaved_compress: width is not a multiple of 4"); |
656 | 0 | return FALSE; |
657 | 0 | } |
658 | | |
659 | 0 | if ((nWidth > 64) || (nHeight > 64)) |
660 | 0 | { |
661 | 0 | WLog_ERR(TAG, |
662 | 0 | "interleaved_compress: width (%" PRIu32 ") or height (%" PRIu32 |
663 | 0 | ") is greater than 64", |
664 | 0 | nWidth, nHeight); |
665 | 0 | return FALSE; |
666 | 0 | } |
667 | | |
668 | 0 | switch (bpp) |
669 | 0 | { |
670 | 0 | case 24: |
671 | 0 | DstFormat = PIXEL_FORMAT_BGRX32; |
672 | 0 | break; |
673 | | |
674 | 0 | case 16: |
675 | 0 | DstFormat = PIXEL_FORMAT_RGB16; |
676 | 0 | break; |
677 | | |
678 | 0 | case 15: |
679 | 0 | DstFormat = PIXEL_FORMAT_RGB15; |
680 | 0 | break; |
681 | | |
682 | 0 | default: |
683 | 0 | return FALSE; |
684 | 0 | } |
685 | | |
686 | 0 | if (!freerdp_image_copy_no_overlap(interleaved->TempBuffer, DstFormat, 0, 0, 0, nWidth, nHeight, |
687 | 0 | pSrcData, SrcFormat, nSrcStep, nXSrc, nYSrc, palette, |
688 | 0 | FREERDP_KEEP_DST_ALPHA)) |
689 | 0 | return FALSE; |
690 | | |
691 | 0 | s = Stream_New(pDstData, *pDstSize); |
692 | |
|
693 | 0 | if (!s) |
694 | 0 | return FALSE; |
695 | | |
696 | 0 | Stream_SetPosition(interleaved->bts, 0); |
697 | |
|
698 | 0 | if (freerdp_bitmap_compress(interleaved->TempBuffer, nWidth, nHeight, s, bpp, maxSize, |
699 | 0 | nHeight - 1, interleaved->bts, 0) < 0) |
700 | 0 | status = FALSE; |
701 | 0 | else |
702 | 0 | status = TRUE; |
703 | |
|
704 | 0 | Stream_SealLength(s); |
705 | 0 | *pDstSize = (UINT32)Stream_Length(s); |
706 | 0 | Stream_Free(s, FALSE); |
707 | 0 | return status; |
708 | 0 | } |
709 | | |
710 | | BOOL bitmap_interleaved_context_reset(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved) |
711 | 0 | { |
712 | 0 | if (!interleaved) |
713 | 0 | return FALSE; |
714 | | |
715 | 0 | return TRUE; |
716 | 0 | } |
717 | | |
718 | | BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(BOOL Compressor) |
719 | 0 | { |
720 | 0 | BITMAP_INTERLEAVED_CONTEXT* interleaved = NULL; |
721 | 0 | interleaved = (BITMAP_INTERLEAVED_CONTEXT*)winpr_aligned_recalloc( |
722 | 0 | NULL, 1, sizeof(BITMAP_INTERLEAVED_CONTEXT), 32); |
723 | |
|
724 | 0 | if (interleaved) |
725 | 0 | { |
726 | 0 | interleaved->TempSize = 64 * 64 * 4; |
727 | 0 | interleaved->TempBuffer = winpr_aligned_calloc(interleaved->TempSize, sizeof(BYTE), 16); |
728 | |
|
729 | 0 | if (!interleaved->TempBuffer) |
730 | 0 | goto fail; |
731 | | |
732 | 0 | interleaved->bts = Stream_New(NULL, interleaved->TempSize); |
733 | |
|
734 | 0 | if (!interleaved->bts) |
735 | 0 | goto fail; |
736 | 0 | } |
737 | | |
738 | 0 | return interleaved; |
739 | | |
740 | 0 | fail: |
741 | 0 | WINPR_PRAGMA_DIAG_PUSH |
742 | 0 | WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC |
743 | 0 | bitmap_interleaved_context_free(interleaved); |
744 | 0 | WINPR_PRAGMA_DIAG_POP |
745 | 0 | return NULL; |
746 | 0 | } |
747 | | |
748 | | void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* WINPR_RESTRICT interleaved) |
749 | 0 | { |
750 | 0 | if (!interleaved) |
751 | 0 | return; |
752 | | |
753 | 0 | winpr_aligned_free(interleaved->TempBuffer); |
754 | 0 | Stream_Free(interleaved->bts, TRUE); |
755 | 0 | winpr_aligned_free(interleaved); |
756 | 0 | } |