FreeRDP
Loading...
Searching...
No Matches
rfx.c
1
22#include <freerdp/config.h>
23
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27
28#include <winpr/assert.h>
29#include <winpr/cast.h>
30#include <winpr/crt.h>
31#include <winpr/tchar.h>
32#include <winpr/sysinfo.h>
33#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
34#include <winpr/registry.h>
35#endif
36
37#include <freerdp/log.h>
38#include <freerdp/settings.h>
39#include <freerdp/codec/rfx.h>
40#include <freerdp/constants.h>
41#include <freerdp/primitives.h>
42#include <freerdp/codec/region.h>
43#include <freerdp/build-config.h>
44#include <freerdp/utils/helpers.h>
45#include <winpr/config-readers.h>
46
47#include "rfx_constants.h"
48#include "rfx_types.h"
49#include "rfx_decode.h"
50#include "rfx_encode.h"
51#include "rfx_quantization.h"
52#include "rfx_dwt.h"
53#include "rfx_rlgr.h"
54#include "../core/utils.h"
55
56#include "sse/rfx_sse2.h"
57#include "neon/rfx_neon.h"
58
59#define TAG FREERDP_TAG("codec")
60
61#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
62#define RFX_KEY "Software\\%s\\RemoteFX"
63#endif
76static const UINT32 rfx_default_quantization_values[] = { 6, 6, 6, 6, 7, 7, 8, 8, 8, 9 };
77
78static inline BOOL rfx_write_progressive_tile_simple(RFX_CONTEXT* WINPR_RESTRICT rfx,
79 wStream* WINPR_RESTRICT s,
80 const RFX_TILE* WINPR_RESTRICT tile);
81static BOOL rfx_message_clear(RFX_CONTEXT* WINPR_RESTRICT context,
82 RFX_MESSAGE* WINPR_RESTRICT message);
83
84static inline void rfx_profiler_create(RFX_CONTEXT* WINPR_RESTRICT context)
85{
86 if (!context || !context->priv)
87 return;
88 PROFILER_CREATE(context->priv->prof_rfx_decode_rgb, "rfx_decode_rgb")
89 PROFILER_CREATE(context->priv->prof_rfx_decode_component, "rfx_decode_component")
90 PROFILER_CREATE(context->priv->prof_rfx_rlgr_decode, "rfx_rlgr_decode")
91 PROFILER_CREATE(context->priv->prof_rfx_differential_decode, "rfx_differential_decode")
92 PROFILER_CREATE(context->priv->prof_rfx_quantization_decode, "rfx_quantization_decode")
93 PROFILER_CREATE(context->priv->prof_rfx_dwt_2d_decode, "rfx_dwt_2d_decode")
94 PROFILER_CREATE(context->priv->prof_rfx_ycbcr_to_rgb, "prims->yCbCrToRGB")
95 PROFILER_CREATE(context->priv->prof_rfx_encode_rgb, "rfx_encode_rgb")
96 PROFILER_CREATE(context->priv->prof_rfx_encode_component, "rfx_encode_component")
97 PROFILER_CREATE(context->priv->prof_rfx_rlgr_encode, "rfx_rlgr_encode")
98 PROFILER_CREATE(context->priv->prof_rfx_differential_encode, "rfx_differential_encode")
99 PROFILER_CREATE(context->priv->prof_rfx_quantization_encode, "rfx_quantization_encode")
100 PROFILER_CREATE(context->priv->prof_rfx_dwt_2d_encode, "rfx_dwt_2d_encode")
101 PROFILER_CREATE(context->priv->prof_rfx_rgb_to_ycbcr, "prims->RGBToYCbCr")
102 PROFILER_CREATE(context->priv->prof_rfx_encode_format_rgb, "rfx_encode_format_rgb")
103}
104
105static inline void rfx_profiler_free(RFX_CONTEXT* WINPR_RESTRICT context)
106{
107 if (!context || !context->priv)
108 return;
109 PROFILER_FREE(context->priv->prof_rfx_decode_rgb)
110 PROFILER_FREE(context->priv->prof_rfx_decode_component)
111 PROFILER_FREE(context->priv->prof_rfx_rlgr_decode)
112 PROFILER_FREE(context->priv->prof_rfx_differential_decode)
113 PROFILER_FREE(context->priv->prof_rfx_quantization_decode)
114 PROFILER_FREE(context->priv->prof_rfx_dwt_2d_decode)
115 PROFILER_FREE(context->priv->prof_rfx_ycbcr_to_rgb)
116 PROFILER_FREE(context->priv->prof_rfx_encode_rgb)
117 PROFILER_FREE(context->priv->prof_rfx_encode_component)
118 PROFILER_FREE(context->priv->prof_rfx_rlgr_encode)
119 PROFILER_FREE(context->priv->prof_rfx_differential_encode)
120 PROFILER_FREE(context->priv->prof_rfx_quantization_encode)
121 PROFILER_FREE(context->priv->prof_rfx_dwt_2d_encode)
122 PROFILER_FREE(context->priv->prof_rfx_rgb_to_ycbcr)
123 PROFILER_FREE(context->priv->prof_rfx_encode_format_rgb)
124}
125
126static inline void rfx_profiler_print(RFX_CONTEXT* WINPR_RESTRICT context)
127{
128 if (!context || !context->priv)
129 return;
130
131 PROFILER_PRINT_HEADER
132 PROFILER_PRINT(context->priv->prof_rfx_decode_rgb)
133 PROFILER_PRINT(context->priv->prof_rfx_decode_component)
134 PROFILER_PRINT(context->priv->prof_rfx_rlgr_decode)
135 PROFILER_PRINT(context->priv->prof_rfx_differential_decode)
136 PROFILER_PRINT(context->priv->prof_rfx_quantization_decode)
137 PROFILER_PRINT(context->priv->prof_rfx_dwt_2d_decode)
138 PROFILER_PRINT(context->priv->prof_rfx_ycbcr_to_rgb)
139 PROFILER_PRINT(context->priv->prof_rfx_encode_rgb)
140 PROFILER_PRINT(context->priv->prof_rfx_encode_component)
141 PROFILER_PRINT(context->priv->prof_rfx_rlgr_encode)
142 PROFILER_PRINT(context->priv->prof_rfx_differential_encode)
143 PROFILER_PRINT(context->priv->prof_rfx_quantization_encode)
144 PROFILER_PRINT(context->priv->prof_rfx_dwt_2d_encode)
145 PROFILER_PRINT(context->priv->prof_rfx_rgb_to_ycbcr)
146 PROFILER_PRINT(context->priv->prof_rfx_encode_format_rgb)
147 PROFILER_PRINT_FOOTER
148}
149
150static inline void rfx_tile_init(void* obj)
151{
152 RFX_TILE* tile = (RFX_TILE*)obj;
153 if (tile)
154 {
155 tile->x = 0;
156 tile->y = 0;
157 tile->YLen = 0;
158 tile->YData = nullptr;
159 tile->CbLen = 0;
160 tile->CbData = nullptr;
161 tile->CrLen = 0;
162 tile->CrData = nullptr;
163 }
164}
165
166static inline void* rfx_decoder_tile_new(const void* val)
167{
168 const size_t size = 4ULL * 64ULL * 64ULL;
169 RFX_TILE* tile = nullptr;
170 WINPR_UNUSED(val);
171
172 if (!(tile = (RFX_TILE*)winpr_aligned_calloc(1, sizeof(RFX_TILE), 32)))
173 return nullptr;
174
175 if (!(tile->data = (BYTE*)winpr_aligned_calloc(1, size, 16)))
176 {
177 winpr_aligned_free(tile);
178 return nullptr;
179 }
180 memset(tile->data, 0xff, size);
181 tile->allocated = TRUE;
182 return tile;
183}
184
185static inline void rfx_decoder_tile_free(void* obj)
186{
187 RFX_TILE* tile = (RFX_TILE*)obj;
188
189 if (tile)
190 {
191 if (tile->allocated)
192 winpr_aligned_free(tile->data);
193
194 winpr_aligned_free(tile);
195 }
196}
197
198static inline void* rfx_encoder_tile_new(const void* val)
199{
200 WINPR_UNUSED(val);
201 return winpr_aligned_calloc(1, sizeof(RFX_TILE), 32);
202}
203
204static inline void rfx_encoder_tile_free(void* obj)
205{
206 winpr_aligned_free(obj);
207}
208
209RFX_CONTEXT* rfx_context_new(BOOL encoder)
210{
211 return rfx_context_new_ex(encoder, 0);
212}
213
214RFX_CONTEXT* rfx_context_new_ex(BOOL encoder, UINT32 ThreadingFlags)
215{
216 RFX_CONTEXT_PRIV* priv = nullptr;
217 RFX_CONTEXT* context = (RFX_CONTEXT*)winpr_aligned_calloc(1, sizeof(RFX_CONTEXT), 32);
218
219 if (!context)
220 return nullptr;
221
222 context->encoder = encoder;
223 context->currentMessage.freeArray = TRUE;
224 context->priv = priv = (RFX_CONTEXT_PRIV*)winpr_aligned_calloc(1, sizeof(RFX_CONTEXT_PRIV), 32);
225
226 if (!priv)
227 goto fail;
228
229 priv->log = WLog_Get("com.freerdp.codec.rfx");
230 priv->TilePool = ObjectPool_New(TRUE);
231
232 if (!priv->TilePool)
233 goto fail;
234
235 {
236 wObject* pool = ObjectPool_Object(priv->TilePool);
237 pool->fnObjectInit = rfx_tile_init;
238
239 if (context->encoder)
240 {
241 pool->fnObjectNew = rfx_encoder_tile_new;
242 pool->fnObjectFree = rfx_encoder_tile_free;
243 }
244 else
245 {
246 pool->fnObjectNew = rfx_decoder_tile_new;
247 pool->fnObjectFree = rfx_decoder_tile_free;
248 }
249 }
250
251 /*
252 * align buffers to 16 byte boundary (needed for SSE/NEON instructions)
253 *
254 * y_r_buffer, cb_g_buffer, cr_b_buffer: 64 * 64 * sizeof(INT16) = 8192 (0x2000)
255 * dwt_buffer: 32 * 32 * 2 * 2 * sizeof(INT16) = 8192, maximum sub-band width is 32
256 *
257 * Additionally we add 32 bytes (16 in front and 16 at the back of the buffer)
258 * in order to allow optimized functions (SEE, NEON) to read from positions
259 * that are actually in front/beyond the buffer. Offset calculations are
260 * performed at the BufferPool_Take function calls in rfx_encode/decode.c.
261 *
262 * We then multiply by 3 to use a single, partionned buffer for all 3 channels.
263 */
264 priv->BufferPool = BufferPool_New(TRUE, (8192ULL + 32ULL) * 3ULL, 16);
265
266 if (!priv->BufferPool)
267 goto fail;
268
269 priv->UseThreads = FALSE;
270
271 const char config[] = "remotefx.json";
272 if (!(ThreadingFlags & THREADING_FLAGS_DISABLE_THREADS))
273 priv->UseThreads = TRUE;
274
275#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
276 {
277 char* key = freerdp_getApplicatonDetailsRegKey(RFX_KEY);
278 if (key)
279 {
280 HKEY hKey = nullptr;
281 const LONG status =
282 RegOpenKeyExA(HKEY_LOCAL_MACHINE, RFX_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
283 free(key);
284
285 if (status == ERROR_SUCCESS)
286 {
287 WLog_WARN(TAG, "HKLM.reg is deprecated since 3.33.0. ATTENTION: Use %s instead!",
288 config);
289 DWORD dwType = 0;
290 DWORD dwValue = 0;
291 DWORD dwSize = sizeof(dwValue);
292
293 if (RegQueryValueEx(hKey, _T("UseThreads"), nullptr, &dwType, (BYTE*)&dwValue,
294 &dwSize) == ERROR_SUCCESS)
295 priv->UseThreads = dwValue ? 1 : 0;
296
297 RegCloseKey(hKey);
298 }
299 }
300 }
301#endif
302 {
303 WINPR_JSON* json = freerdp_GetJSONConfigFile(TRUE, config);
304 if (json)
305 {
306 winpr_config_apply_bool(config, json, "UseThreads", &priv->UseThreads);
307 WINPR_JSON_Delete(json);
308 }
309 }
310
311 if (priv->UseThreads)
312 {
313 /* Call primitives_get here in order to avoid race conditions when using primitives_get */
314 /* from multiple threads. This call will initialize all function pointers correctly */
315 /* before any decoding threads are started */
316 if (!primitives_get())
317 goto fail;
318 }
319
320 /* initialize the default pixel format */
321 rfx_context_set_pixel_format(context, PIXEL_FORMAT_BGRX32);
322 /* create profilers for default decoding routines */
323 rfx_profiler_create(context);
324 /* set up default routines */
325 context->quantization_decode = rfx_quantization_decode;
326 context->quantization_encode = rfx_quantization_encode;
327 context->dwt_2d_decode = rfx_dwt_2d_decode;
328 context->dwt_2d_extrapolate_decode = rfx_dwt_2d_extrapolate_decode;
329 context->dwt_2d_encode = rfx_dwt_2d_encode;
330 context->rlgr_decode = rfx_rlgr_decode;
331 context->rlgr_encode = rfx_rlgr_encode;
332 rfx_init_sse2(context);
333 rfx_init_neon(context);
334 context->state = RFX_STATE_SEND_HEADERS;
335 context->expectedDataBlockType = WBT_FRAME_BEGIN;
336 return context;
337fail:
338 WINPR_PRAGMA_DIAG_PUSH
339 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
340 rfx_context_free(context);
341 WINPR_PRAGMA_DIAG_POP
342 return nullptr;
343}
344
345void rfx_context_free(RFX_CONTEXT* context)
346{
347 RFX_CONTEXT_PRIV* priv = nullptr;
348
349 if (!context)
350 return;
351
352 WINPR_ASSERT(nullptr != context);
353
354 priv = context->priv;
355 WINPR_ASSERT(nullptr != priv);
356 WINPR_ASSERT(nullptr != priv->TilePool);
357 WINPR_ASSERT(nullptr != priv->BufferPool);
358
359 /* coverity[address_free] */
360 rfx_message_clear(context, &context->currentMessage);
361 winpr_aligned_free(context->quants);
362 rfx_profiler_print(context);
363 rfx_profiler_free(context);
364
365 if (priv)
366 {
367 ObjectPool_Free(priv->TilePool);
368 if (priv->UseThreads)
369 {
370 winpr_aligned_free((void*)priv->workObjects);
371 winpr_aligned_free(priv->tileWorkParams);
372#ifdef WITH_PROFILER
373 WLog_VRB(
374 TAG,
375 "WARNING: Profiling results probably unusable with multithreaded RemoteFX codec!");
376#endif
377 }
378
379 BufferPool_Free(priv->BufferPool);
380 winpr_aligned_free(priv);
381 }
382 winpr_aligned_free(context);
383}
384
385static inline RFX_TILE* rfx_message_get_tile(RFX_MESSAGE* WINPR_RESTRICT message, UINT32 index)
386{
387 WINPR_ASSERT(message);
388 WINPR_ASSERT(message->tiles);
389 WINPR_ASSERT(index < message->numTiles);
390 return message->tiles[index];
391}
392
393static inline const RFX_RECT* rfx_message_get_rect_const(const RFX_MESSAGE* WINPR_RESTRICT message,
394 UINT32 index)
395{
396 WINPR_ASSERT(message);
397 WINPR_ASSERT(message->rects);
398 WINPR_ASSERT(index < message->numRects);
399 return &message->rects[index];
400}
401
402static inline RFX_RECT* rfx_message_get_rect(RFX_MESSAGE* WINPR_RESTRICT message, UINT32 index)
403{
404 WINPR_ASSERT(message);
405 WINPR_ASSERT(message->rects);
406 WINPR_ASSERT(index < message->numRects);
407 return &message->rects[index];
408}
409
410void rfx_context_set_pixel_format(RFX_CONTEXT* WINPR_RESTRICT context, UINT32 pixel_format)
411{
412 WINPR_ASSERT(context);
413 context->pixel_format = pixel_format;
414 const UINT32 bpp = FreeRDPGetBitsPerPixel(pixel_format);
415 context->bits_per_pixel = WINPR_ASSERTING_INT_CAST(UINT8, bpp);
416}
417
418UINT32 rfx_context_get_pixel_format(RFX_CONTEXT* WINPR_RESTRICT context)
419{
420 WINPR_ASSERT(context);
421 return context->pixel_format;
422}
423
424void rfx_context_set_palette(RFX_CONTEXT* WINPR_RESTRICT context,
425 const BYTE* WINPR_RESTRICT palette)
426{
427 WINPR_ASSERT(context);
428 context->palette = palette;
429}
430
431const BYTE* rfx_context_get_palette(RFX_CONTEXT* WINPR_RESTRICT context)
432{
433 WINPR_ASSERT(context);
434 return context->palette;
435}
436
437BOOL rfx_context_reset(RFX_CONTEXT* WINPR_RESTRICT context, UINT32 width, UINT32 height)
438{
439 if (!context)
440 return FALSE;
441
442 context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
443 context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
444 context->state = RFX_STATE_SEND_HEADERS;
445 context->expectedDataBlockType = WBT_FRAME_BEGIN;
446 context->frameIdx = 0;
447 return TRUE;
448}
449
450static inline BOOL rfx_process_message_sync(RFX_CONTEXT* WINPR_RESTRICT context,
451 wStream* WINPR_RESTRICT s)
452{
453 UINT32 magic = 0;
454
455 WINPR_ASSERT(context);
456 WINPR_ASSERT(context->priv);
457 context->decodedHeaderBlocks &= (uint32_t)~RFX_DECODED_SYNC;
458
459 /* RFX_SYNC */
460 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 6))
461 return FALSE;
462
463 Stream_Read_UINT32(s, magic); /* magic (4 bytes), 0xCACCACCA */
464 if (magic != WF_MAGIC)
465 {
466 WLog_Print(context->priv->log, WLOG_ERROR, "invalid magic number 0x%08" PRIX32 "", magic);
467 return FALSE;
468 }
469
470 Stream_Read_UINT16(s, context->version); /* version (2 bytes), WF_VERSION_1_0 (0x0100) */
471 if (context->version != WF_VERSION_1_0)
472 {
473 WLog_Print(context->priv->log, WLOG_ERROR, "invalid version number 0x%08" PRIX32 "",
474 context->version);
475 return FALSE;
476 }
477
478 WLog_Print(context->priv->log, WLOG_DEBUG, "version 0x%08" PRIX32 "", context->version);
479 context->decodedHeaderBlocks |= RFX_DECODED_SYNC;
480 return TRUE;
481}
482
483static inline BOOL rfx_process_message_codec_versions(RFX_CONTEXT* WINPR_RESTRICT context,
484 wStream* WINPR_RESTRICT s)
485{
486 BYTE numCodecs = 0;
487
488 WINPR_ASSERT(context);
489 WINPR_ASSERT(context->priv);
490 context->decodedHeaderBlocks &= (uint32_t)~RFX_DECODED_VERSIONS;
491
492 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 4))
493 return FALSE;
494
495 Stream_Read_UINT8(s, numCodecs); /* numCodecs (1 byte), must be set to 0x01 */
496 Stream_Read_UINT8(s, context->codec_id); /* codecId (1 byte), must be set to 0x01 */
497 Stream_Read_UINT16(
498 s, context->codec_version); /* version (2 bytes), must be set to WF_VERSION_1_0 (0x0100) */
499
500 if (numCodecs != 1)
501 {
502 WLog_Print(context->priv->log, WLOG_ERROR, "numCodes is 0x%02" PRIX8 " (must be 0x01)",
503 numCodecs);
504 return FALSE;
505 }
506
507 if (context->codec_id != 0x01)
508 {
509 WLog_Print(context->priv->log, WLOG_ERROR, "invalid codec id (0x%02" PRIX32 ")",
510 context->codec_id);
511 return FALSE;
512 }
513
514 if (context->codec_version != WF_VERSION_1_0)
515 {
516 WLog_Print(context->priv->log, WLOG_ERROR, "invalid codec version (0x%08" PRIX32 ")",
517 context->codec_version);
518 return FALSE;
519 }
520
521 WLog_Print(context->priv->log, WLOG_DEBUG, "id %" PRIu32 " version 0x%" PRIX32 ".",
522 context->codec_id, context->codec_version);
523 context->decodedHeaderBlocks |= RFX_DECODED_VERSIONS;
524 return TRUE;
525}
526
527static inline BOOL rfx_process_message_channels(RFX_CONTEXT* WINPR_RESTRICT context,
528 wStream* WINPR_RESTRICT s)
529{
530 BYTE channelId = 0;
531 BYTE numChannels = 0;
532
533 WINPR_ASSERT(context);
534 WINPR_ASSERT(context->priv);
535 context->decodedHeaderBlocks &= (uint32_t)~RFX_DECODED_CHANNELS;
536
537 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 1))
538 return FALSE;
539
540 Stream_Read_UINT8(s, numChannels); /* numChannels (1 byte), must bet set to 0x01 */
541
542 /* In RDVH sessions, numChannels will represent the number of virtual monitors
543 * configured and does not always be set to 0x01 as [MS-RDPRFX] said.
544 */
545 if (numChannels < 1)
546 {
547 WLog_Print(context->priv->log, WLOG_ERROR, "no channels announced");
548 return FALSE;
549 }
550
551 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(context->priv->log, s, numChannels, 5ull))
552 return FALSE;
553
554 /* RFX_CHANNELT */
555 Stream_Read_UINT8(s, channelId); /* channelId (1 byte), must be set to 0x00 */
556
557 if (channelId != 0x00)
558 {
559 WLog_Print(context->priv->log, WLOG_ERROR, "channelId:0x%02" PRIX8 ", expected:0x00",
560 channelId);
561 return FALSE;
562 }
563
564 Stream_Read_UINT16(s, context->width); /* width (2 bytes) */
565 Stream_Read_UINT16(s, context->height); /* height (2 bytes) */
566
567 if (!context->width || !context->height)
568 {
569 WLog_Print(context->priv->log, WLOG_ERROR,
570 "invalid channel with/height: %" PRIu16 "x%" PRIu16 "", context->width,
571 context->height);
572 return FALSE;
573 }
574
575 /* Now, only the first monitor can be used, therefore the other channels will be ignored. */
576 Stream_Seek(s, 5ULL * (numChannels - 1));
577 WLog_Print(context->priv->log, WLOG_DEBUG,
578 "numChannels %" PRIu8 " id %" PRIu8 ", %" PRIu16 "x%" PRIu16 ".", numChannels,
579 channelId, context->width, context->height);
580 context->decodedHeaderBlocks |= RFX_DECODED_CHANNELS;
581 return TRUE;
582}
583
584static inline BOOL rfx_process_message_context(RFX_CONTEXT* WINPR_RESTRICT context,
585 wStream* WINPR_RESTRICT s)
586{
587 BYTE ctxId = 0;
588 UINT16 tileSize = 0;
589 UINT16 properties = 0;
590
591 WINPR_ASSERT(context);
592 WINPR_ASSERT(context->priv);
593 context->decodedHeaderBlocks &= (uint32_t)~RFX_DECODED_CONTEXT;
594
595 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 5))
596 return FALSE;
597
598 Stream_Read_UINT8(s, ctxId); /* ctxId (1 byte), must be set to 0x00 */
599 Stream_Read_UINT16(s, tileSize); /* tileSize (2 bytes), must be set to CT_TILE_64x64 (0x0040) */
600 Stream_Read_UINT16(s, properties); /* properties (2 bytes) */
601 WLog_Print(context->priv->log, WLOG_DEBUG,
602 "ctxId %" PRIu8 " tileSize %" PRIu16 " properties 0x%04" PRIX16 ".", ctxId, tileSize,
603 properties);
604 context->properties = properties;
605 context->flags = (properties & 0x0007);
606
607 if (context->flags == CODEC_MODE)
608 {
609 WLog_Print(context->priv->log, WLOG_DEBUG, "codec is in image mode.");
610 }
611 else
612 {
613 WLog_Print(context->priv->log, WLOG_DEBUG, "codec is in video mode.");
614 }
615
616 switch ((properties & 0x1E00) >> 9)
617 {
618 case CLW_ENTROPY_RLGR1:
619 context->mode = RLGR1;
620 WLog_Print(context->priv->log, WLOG_DEBUG, "RLGR1.");
621 break;
622
623 case CLW_ENTROPY_RLGR3:
624 context->mode = RLGR3;
625 WLog_Print(context->priv->log, WLOG_DEBUG, "RLGR3.");
626 break;
627
628 default:
629 WLog_Print(context->priv->log, WLOG_ERROR, "unknown RLGR algorithm.");
630 return FALSE;
631 }
632
633 context->decodedHeaderBlocks |= RFX_DECODED_CONTEXT;
634 return TRUE;
635}
636
637static inline BOOL rfx_process_message_frame_begin(
638 RFX_CONTEXT* WINPR_RESTRICT context, WINPR_ATTR_UNUSED RFX_MESSAGE* WINPR_RESTRICT message,
639 wStream* WINPR_RESTRICT s, UINT16* WINPR_RESTRICT pExpectedBlockType)
640{
641 UINT32 frameIdx = 0;
642 UINT16 numRegions = 0;
643
644 WINPR_ASSERT(context);
645 WINPR_ASSERT(context->priv);
646 WINPR_ASSERT(message);
647 WINPR_ASSERT(pExpectedBlockType);
648
649 if (*pExpectedBlockType != WBT_FRAME_BEGIN)
650 {
651 WLog_Print(context->priv->log, WLOG_ERROR, "message unexpected wants WBT_FRAME_BEGIN");
652 return FALSE;
653 }
654
655 *pExpectedBlockType = WBT_REGION;
656
657 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 6))
658 return FALSE;
659
660 Stream_Read_UINT32(
661 s, frameIdx); /* frameIdx (4 bytes), if codec is in video mode, must be ignored */
662 Stream_Read_UINT16(s, numRegions); /* numRegions (2 bytes) */
663 WLog_Print(context->priv->log, WLOG_DEBUG,
664 "RFX_FRAME_BEGIN: frameIdx: %" PRIu32 " numRegions: %" PRIu16 "", frameIdx,
665 numRegions);
666 return TRUE;
667}
668
669static inline BOOL rfx_process_message_frame_end(
670 RFX_CONTEXT* WINPR_RESTRICT context, WINPR_ATTR_UNUSED RFX_MESSAGE* WINPR_RESTRICT message,
671 WINPR_ATTR_UNUSED wStream* WINPR_RESTRICT s, UINT16* WINPR_RESTRICT pExpectedBlockType)
672{
673 WINPR_ASSERT(context);
674 WINPR_ASSERT(context->priv);
675 WINPR_ASSERT(message);
676 WINPR_ASSERT(s);
677 WINPR_ASSERT(pExpectedBlockType);
678
679 if (*pExpectedBlockType != WBT_FRAME_END)
680 {
681 WLog_Print(context->priv->log, WLOG_ERROR, "message unexpected, wants WBT_FRAME_END");
682 return FALSE;
683 }
684
685 *pExpectedBlockType = WBT_FRAME_BEGIN;
686 WLog_Print(context->priv->log, WLOG_DEBUG, "RFX_FRAME_END");
687 return TRUE;
688}
689
690static inline BOOL rfx_resize_rects(RFX_MESSAGE* WINPR_RESTRICT message)
691{
692 WINPR_ASSERT(message);
693
694 RFX_RECT* tmpRects =
695 winpr_aligned_recalloc(message->rects, message->numRects, sizeof(RFX_RECT), 32);
696 if (!tmpRects)
697 return FALSE;
698 message->rects = tmpRects;
699 return TRUE;
700}
701
702static inline BOOL rfx_process_message_region(RFX_CONTEXT* WINPR_RESTRICT context,
703 RFX_MESSAGE* WINPR_RESTRICT message,
704 wStream* WINPR_RESTRICT s,
705 UINT16* WINPR_RESTRICT pExpectedBlockType)
706{
707 UINT16 regionType = 0;
708 UINT16 numTileSets = 0;
709
710 WINPR_ASSERT(context);
711 WINPR_ASSERT(context->priv);
712 WINPR_ASSERT(message);
713 WINPR_ASSERT(pExpectedBlockType);
714
715 if (*pExpectedBlockType != WBT_REGION)
716 {
717 WLog_Print(context->priv->log, WLOG_ERROR, "message unexpected wants WBT_REGION");
718 return FALSE;
719 }
720
721 *pExpectedBlockType = WBT_EXTENSION;
722
723 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 3))
724 return FALSE;
725
726 Stream_Seek_UINT8(s); /* regionFlags (1 byte) */
727 Stream_Read_UINT16(s, message->numRects); /* numRects (2 bytes) */
728
729 if (message->numRects < 1)
730 {
731 /*
732 If numRects is zero the decoder must generate a rectangle with
733 coordinates (0, 0, width, height).
734 See [MS-RDPRFX] (revision >= 17.0) 2.2.2.3.3 TS_RFX_REGION
735 https://msdn.microsoft.com/en-us/library/ff635233.aspx
736 */
737 message->numRects = 1;
738 if (!rfx_resize_rects(message))
739 return FALSE;
740
741 message->rects->x = 0;
742 message->rects->y = 0;
743 message->rects->width = context->width;
744 message->rects->height = context->height;
745 return TRUE;
746 }
747
748 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(context->priv->log, s, message->numRects, 8ull))
749 return FALSE;
750
751 if (!rfx_resize_rects(message))
752 return FALSE;
753
754 /* rects */
755 for (UINT16 i = 0; i < message->numRects; i++)
756 {
757 RFX_RECT* rect = rfx_message_get_rect(message, i);
758 /* RFX_RECT */
759 Stream_Read_UINT16(s, rect->x); /* x (2 bytes) */
760 Stream_Read_UINT16(s, rect->y); /* y (2 bytes) */
761 Stream_Read_UINT16(s, rect->width); /* width (2 bytes) */
762 Stream_Read_UINT16(s, rect->height); /* height (2 bytes) */
763 WLog_Print(context->priv->log, WLOG_DEBUG,
764 "rect %" PRIu16 " (x,y=%" PRIu16 ",%" PRIu16 " w,h=%" PRIu16 " %" PRIu16 ").", i,
765 rect->x, rect->y, rect->width, rect->height);
766 }
767
768 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 4))
769 return FALSE;
770
771 Stream_Read_UINT16(s, regionType); /*regionType (2 bytes): MUST be set to CBT_REGION (0xCAC1)*/
772 Stream_Read_UINT16(s, numTileSets); /*numTilesets (2 bytes): MUST be set to 0x0001.*/
773
774 if (regionType != CBT_REGION)
775 {
776 WLog_Print(context->priv->log, WLOG_ERROR, "invalid region type 0x%04" PRIX16 "",
777 regionType);
778 return TRUE;
779 }
780
781 if (numTileSets != 0x0001)
782 {
783 WLog_Print(context->priv->log, WLOG_ERROR, "invalid number of tilesets (%" PRIu16 ")",
784 numTileSets);
785 return FALSE;
786 }
787
788 return TRUE;
789}
790
791typedef struct
792{
793 RFX_TILE* tile;
794 RFX_CONTEXT* context;
795} RFX_TILE_PROCESS_WORK_PARAM;
796
797static inline void CALLBACK
798rfx_process_message_tile_work_callback(WINPR_ATTR_UNUSED PTP_CALLBACK_INSTANCE instance,
799 void* context, WINPR_ATTR_UNUSED PTP_WORK work)
800{
801 RFX_TILE_PROCESS_WORK_PARAM* param = (RFX_TILE_PROCESS_WORK_PARAM*)context;
802 WINPR_ASSERT(param);
803 WINPR_ASSERT(param->context);
804 WINPR_ASSERT(param->context->priv);
805
806 if (!rfx_decode_rgb(param->context, param->tile, param->tile->data, 64 * 4))
807 WLog_Print(param->context->priv->log, WLOG_ERROR, "rfx_decode_rgb failed");
808}
809
810static inline BOOL rfx_allocate_tiles(RFX_MESSAGE* WINPR_RESTRICT message, size_t count,
811 BOOL allocOnly)
812{
813 WINPR_ASSERT(message);
814
815 RFX_TILE** tmpTiles =
816 (RFX_TILE**)winpr_aligned_recalloc((void*)message->tiles, count, sizeof(RFX_TILE*), 32);
817 if (!tmpTiles && (count != 0))
818 return FALSE;
819
820 message->tiles = tmpTiles;
821 if (!allocOnly)
822 message->numTiles = WINPR_ASSERTING_INT_CAST(UINT16, count);
823 else
824 {
825 WINPR_ASSERT(message->numTiles <= count);
826 }
827 message->allocatedTiles = count;
828
829 return TRUE;
830}
831
832static inline BOOL rfx_process_message_tileset(RFX_CONTEXT* WINPR_RESTRICT context,
833 RFX_MESSAGE* WINPR_RESTRICT message,
834 wStream* WINPR_RESTRICT s,
835 UINT16* WINPR_RESTRICT pExpectedBlockType)
836{
837 BOOL rc = 0;
838 size_t close_cnt = 0;
839 BYTE quant = 0;
840 RFX_TILE* tile = nullptr;
841 UINT32* quants = nullptr;
842 UINT16 subtype = 0;
843 UINT16 numTiles = 0;
844 UINT32 blockLen = 0;
845 UINT32 blockType = 0;
846 UINT32 tilesDataSize = 0;
847 PTP_WORK* work_objects = nullptr;
848 RFX_TILE_PROCESS_WORK_PARAM* params = nullptr;
849 void* pmem = nullptr;
850
851 WINPR_ASSERT(context);
852 WINPR_ASSERT(context->priv);
853 WINPR_ASSERT(message);
854 WINPR_ASSERT(pExpectedBlockType);
855
856 if (*pExpectedBlockType != WBT_EXTENSION)
857 {
858 WLog_Print(context->priv->log, WLOG_ERROR, "message unexpected wants a tileset");
859 return FALSE;
860 }
861
862 *pExpectedBlockType = WBT_FRAME_END;
863
864 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 14))
865 return FALSE;
866
867 Stream_Read_UINT16(s, subtype); /* subtype (2 bytes) must be set to CBT_TILESET (0xCAC2) */
868 if (subtype != CBT_TILESET)
869 {
870 WLog_Print(context->priv->log, WLOG_ERROR, "invalid subtype, expected CBT_TILESET.");
871 return FALSE;
872 }
873
874 Stream_Seek_UINT16(s); /* idx (2 bytes), must be set to 0x0000 */
875 Stream_Seek_UINT16(s); /* properties (2 bytes) */
876 Stream_Read_UINT8(s, context->numQuant); /* numQuant (1 byte) */
877 Stream_Seek_UINT8(s); /* tileSize (1 byte), must be set to 0x40 */
878
879 if (context->numQuant < 1)
880 {
881 WLog_Print(context->priv->log, WLOG_ERROR, "no quantization value.");
882 return FALSE;
883 }
884
885 Stream_Read_UINT16(s, numTiles); /* numTiles (2 bytes) */
886 if (numTiles < 1)
887 {
888 /* Windows Server 2012 (not R2) can send empty tile sets */
889 return TRUE;
890 }
891
892 Stream_Read_UINT32(s, tilesDataSize); /* tilesDataSize (4 bytes) */
893
894 if (!(pmem = winpr_aligned_recalloc(context->quants, context->numQuant,
895 NR_QUANT_VALUES * sizeof(UINT32), 32)))
896 return FALSE;
897
898 quants = context->quants = (UINT32*)pmem;
899
900 /* quantVals */
901 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(context->priv->log, s, context->numQuant, 5ull))
902 return FALSE;
903
904 for (size_t i = 0; i < context->numQuant; i++)
905 {
906 /* RFX_CODEC_QUANT */
907 Stream_Read_UINT8(s, quant);
908 *quants++ = (quant & 0x0F);
909 *quants++ = (quant >> 4);
910 Stream_Read_UINT8(s, quant);
911 *quants++ = (quant & 0x0F);
912 *quants++ = (quant >> 4);
913 Stream_Read_UINT8(s, quant);
914 *quants++ = (quant & 0x0F);
915 *quants++ = (quant >> 4);
916 Stream_Read_UINT8(s, quant);
917 *quants++ = (quant & 0x0F);
918 *quants++ = (quant >> 4);
919 Stream_Read_UINT8(s, quant);
920 *quants++ = (quant & 0x0F);
921 *quants++ = (quant >> 4);
922 WLog_Print(
923 context->priv->log, WLOG_DEBUG,
924 "quant %" PRIuz " (%" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32
925 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32 ").",
926 i, context->quants[i * NR_QUANT_VALUES], context->quants[i * NR_QUANT_VALUES + 1],
927 context->quants[i * NR_QUANT_VALUES + 2], context->quants[i * NR_QUANT_VALUES + 3],
928 context->quants[i * NR_QUANT_VALUES + 4], context->quants[i * NR_QUANT_VALUES + 5],
929 context->quants[i * NR_QUANT_VALUES + 6], context->quants[i * NR_QUANT_VALUES + 7],
930 context->quants[i * NR_QUANT_VALUES + 8], context->quants[i * NR_QUANT_VALUES + 9]);
931 }
932
933 for (size_t i = 0; i < message->numTiles; i++)
934 {
935 ObjectPool_Return(context->priv->TilePool, message->tiles[i]);
936 message->tiles[i] = nullptr;
937 }
938
939 if (!rfx_allocate_tiles(message, numTiles, FALSE))
940 return FALSE;
941
942 if (context->priv->UseThreads)
943 {
944 work_objects = (PTP_WORK*)winpr_aligned_calloc(message->numTiles, sizeof(PTP_WORK), 32);
945 params = (RFX_TILE_PROCESS_WORK_PARAM*)winpr_aligned_recalloc(
946 nullptr, message->numTiles, sizeof(RFX_TILE_PROCESS_WORK_PARAM), 32);
947
948 if (!work_objects)
949 {
950 winpr_aligned_free(params);
951 return FALSE;
952 }
953
954 if (!params)
955 {
956 winpr_aligned_free((void*)work_objects);
957 return FALSE;
958 }
959 }
960
961 /* tiles */
962 close_cnt = 0;
963 rc = FALSE;
964
965 if (Stream_GetRemainingLength(s) >= tilesDataSize)
966 {
967 rc = TRUE;
968 for (size_t i = 0; i < message->numTiles; i++)
969 {
970 wStream subBuffer;
971 wStream* sub = nullptr;
972
973 if (!(tile = (RFX_TILE*)ObjectPool_Take(context->priv->TilePool)))
974 {
975 WLog_Print(context->priv->log, WLOG_ERROR,
976 "RfxMessageTileSet failed to get tile from object pool");
977 rc = FALSE;
978 break;
979 }
980
981 message->tiles[i] = tile;
982
983 /* RFX_TILE */
984 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 6))
985 {
986 WLog_Print(context->priv->log, WLOG_ERROR,
987 "RfxMessageTileSet packet too small to read tile %" PRIuz "/%" PRIu16 "",
988 i, message->numTiles);
989 rc = FALSE;
990 break;
991 }
992
993 sub = Stream_StaticInit(&subBuffer, Stream_Pointer(s), Stream_GetRemainingLength(s));
994 Stream_Read_UINT16(
995 sub, blockType); /* blockType (2 bytes), must be set to CBT_TILE (0xCAC3) */
996 Stream_Read_UINT32(sub, blockLen); /* blockLen (4 bytes) */
997
998 if (!Stream_SafeSeek(s, blockLen))
999 {
1000 rc = FALSE;
1001 break;
1002 }
1003 if ((blockLen < 6 + 13) ||
1004 (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, sub, blockLen - 6)))
1005 {
1006 WLog_Print(context->priv->log, WLOG_ERROR,
1007 "RfxMessageTileSet not enough bytes to read tile %" PRIuz "/%" PRIu16
1008 " with blocklen=%" PRIu32 "",
1009 i, message->numTiles, blockLen);
1010 rc = FALSE;
1011 break;
1012 }
1013
1014 if (blockType != CBT_TILE)
1015 {
1016 WLog_Print(context->priv->log, WLOG_ERROR,
1017 "unknown block type 0x%" PRIX32 ", expected CBT_TILE (0xCAC3).",
1018 blockType);
1019 rc = FALSE;
1020 break;
1021 }
1022
1023 Stream_Read_UINT8(sub, tile->quantIdxY); /* quantIdxY (1 byte) */
1024 Stream_Read_UINT8(sub, tile->quantIdxCb); /* quantIdxCb (1 byte) */
1025 Stream_Read_UINT8(sub, tile->quantIdxCr); /* quantIdxCr (1 byte) */
1026 if (tile->quantIdxY >= context->numQuant)
1027 {
1028 WLog_Print(context->priv->log, WLOG_ERROR,
1029 "quantIdxY %" PRIu8 " >= numQuant %" PRIu8, tile->quantIdxY,
1030 context->numQuant);
1031 rc = FALSE;
1032 break;
1033 }
1034 if (tile->quantIdxCb >= context->numQuant)
1035 {
1036 WLog_Print(context->priv->log, WLOG_ERROR,
1037 "quantIdxCb %" PRIu8 " >= numQuant %" PRIu8, tile->quantIdxCb,
1038 context->numQuant);
1039 rc = FALSE;
1040 break;
1041 }
1042 if (tile->quantIdxCr >= context->numQuant)
1043 {
1044 WLog_Print(context->priv->log, WLOG_ERROR,
1045 "quantIdxCr %" PRIu8 " >= numQuant %" PRIu8, tile->quantIdxCr,
1046 context->numQuant);
1047 rc = FALSE;
1048 break;
1049 }
1050
1051 Stream_Read_UINT16(sub, tile->xIdx); /* xIdx (2 bytes) */
1052 Stream_Read_UINT16(sub, tile->yIdx); /* yIdx (2 bytes) */
1053 Stream_Read_UINT16(sub, tile->YLen); /* YLen (2 bytes) */
1054 Stream_Read_UINT16(sub, tile->CbLen); /* CbLen (2 bytes) */
1055 Stream_Read_UINT16(sub, tile->CrLen); /* CrLen (2 bytes) */
1056 tile->YData = Stream_PointerAs(sub, BYTE);
1057 if (!Stream_SafeSeek(sub, tile->YLen))
1058 {
1059 rc = FALSE;
1060 break;
1061 }
1062 tile->CbData = Stream_PointerAs(sub, BYTE);
1063 if (!Stream_SafeSeek(sub, tile->CbLen))
1064 {
1065 rc = FALSE;
1066 break;
1067 }
1068 tile->CrData = Stream_PointerAs(sub, BYTE);
1069 if (!Stream_SafeSeek(sub, tile->CrLen))
1070 {
1071 rc = FALSE;
1072 break;
1073 }
1074 tile->x = tile->xIdx * 64;
1075 tile->y = tile->yIdx * 64;
1076
1077 if (context->priv->UseThreads)
1078 {
1079 if (!params)
1080 {
1081 rc = FALSE;
1082 break;
1083 }
1084
1085 params[i].context = context;
1086 params[i].tile = message->tiles[i];
1087
1088 if (!(work_objects[i] = CreateThreadpoolWork(rfx_process_message_tile_work_callback,
1089 (void*)&params[i], nullptr)))
1090 {
1091 WLog_Print(context->priv->log, WLOG_ERROR, "CreateThreadpoolWork failed.");
1092 rc = FALSE;
1093 break;
1094 }
1095
1096 SubmitThreadpoolWork(work_objects[i]);
1097 close_cnt = i + 1;
1098 }
1099 else
1100 {
1101 if (!rfx_decode_rgb(context, tile, tile->data, 64 * 4))
1102 {
1103 rc = FALSE;
1104 break;
1105 }
1106 }
1107 }
1108 }
1109
1110 if (context->priv->UseThreads)
1111 {
1112 for (size_t i = 0; i < close_cnt; i++)
1113 {
1114 WaitForThreadpoolWorkCallbacks(work_objects[i], FALSE);
1115 CloseThreadpoolWork(work_objects[i]);
1116 }
1117 }
1118
1119 winpr_aligned_free((void*)work_objects);
1120 winpr_aligned_free(params);
1121
1122 for (size_t i = 0; i < message->numTiles; i++)
1123 {
1124 if (!(tile = message->tiles[i]))
1125 continue;
1126
1127 tile->YLen = tile->CbLen = tile->CrLen = 0;
1128 tile->YData = tile->CbData = tile->CrData = nullptr;
1129 }
1130
1131 return rc;
1132}
1133
1134WINPR_ATTR_NODISCARD
1135static BOOL rect_is_valid(const RFX_RECT* rect, UINT32 left, UINT32 top,
1136 const RECTANGLE_16* clippingRect)
1137{
1138 WINPR_ASSERT(clippingRect);
1139
1140 if (!rect)
1141 {
1142 WLog_ERR(TAG, "rect=NULL");
1143 return FALSE;
1144 }
1145 if (left > UINT16_MAX - 1u * rect->x)
1146 {
1147 WLog_ERR(TAG, "left(%" PRIu32 ") + rect->x(%d) > %d", left, rect->x, UINT16_MAX);
1148 return FALSE;
1149 }
1150 if (top > UINT16_MAX - 1u * rect->y)
1151 {
1152 WLog_ERR(TAG, "top(%" PRIu32 ") + rect->y(%d) > %d", top, rect->y, UINT16_MAX);
1153 return FALSE;
1154 }
1155 if (clippingRect->left > UINT16_MAX - rect->width)
1156 {
1157 WLog_ERR(TAG, "clippingRect->left(%" PRIu32 ") + rect->width(%d) > %d", clippingRect->left,
1158 rect->width, UINT16_MAX);
1159 return FALSE;
1160 }
1161 if (clippingRect->top > UINT16_MAX - rect->height)
1162 {
1163 WLog_ERR(TAG, "clippingRect->top(%" PRIu32 ") + rect->height(%d) > %d", clippingRect->top,
1164 rect->height, UINT16_MAX);
1165 return FALSE;
1166 }
1167 return TRUE;
1168}
1169
1170BOOL rfx_process_message(RFX_CONTEXT* WINPR_RESTRICT context, const BYTE* WINPR_RESTRICT data,
1171 UINT32 length, UINT32 left, UINT32 top, BYTE* WINPR_RESTRICT dst,
1172 UINT32 dstFormat, UINT32 dstStride, UINT32 dstHeight,
1173 REGION16* WINPR_RESTRICT invalidRegion)
1174{
1175 REGION16 updateRegion = WINPR_C_ARRAY_INIT;
1176 wStream inStream = WINPR_C_ARRAY_INIT;
1177 BOOL ok = TRUE;
1178
1179 if (!context || !data || !length)
1180 return FALSE;
1181
1182 WINPR_ASSERT(context->priv);
1183 RFX_MESSAGE* message = &context->currentMessage;
1184
1185 wStream* s = Stream_StaticConstInit(&inStream, data, length);
1186
1187 while (ok && Stream_GetRemainingLength(s) > 6)
1188 {
1189 wStream subStreamBuffer = WINPR_C_ARRAY_INIT;
1190 size_t extraBlockLen = 0;
1191 UINT32 blockLen = 0;
1192 UINT32 blockType = 0;
1193
1194 /* RFX_BLOCKT */
1195 Stream_Read_UINT16(s, blockType); /* blockType (2 bytes) */
1196 Stream_Read_UINT32(s, blockLen); /* blockLen (4 bytes) */
1197 WLog_Print(context->priv->log, WLOG_DEBUG, "blockType 0x%" PRIX32 " blockLen %" PRIu32 "",
1198 blockType, blockLen);
1199
1200 if (blockLen < 6)
1201 {
1202 WLog_Print(context->priv->log, WLOG_ERROR, "blockLen too small(%" PRIu32 ")", blockLen);
1203 return FALSE;
1204 }
1205
1206 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, blockLen - 6))
1207 return FALSE;
1208
1209 if (blockType > WBT_CONTEXT && context->decodedHeaderBlocks != RFX_DECODED_HEADERS)
1210 {
1211 WLog_Print(context->priv->log, WLOG_ERROR, "incomplete header blocks processing");
1212 return FALSE;
1213 }
1214
1215 if (blockType >= WBT_CONTEXT && blockType <= WBT_EXTENSION)
1216 {
1217 /* RFX_CODEC_CHANNELT */
1218 UINT8 codecId = 0;
1219 UINT8 channelId = 0;
1220
1221 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 2))
1222 return FALSE;
1223
1224 extraBlockLen = 2;
1225 Stream_Read_UINT8(s, codecId); /* codecId (1 byte) must be set to 0x01 */
1226 Stream_Read_UINT8(s, channelId); /* channelId (1 byte) 0xFF or 0x00, see below */
1227
1228 if (codecId != 0x01)
1229 {
1230 WLog_Print(context->priv->log, WLOG_ERROR, "invalid codecId 0x%02" PRIX8 "",
1231 codecId);
1232 return FALSE;
1233 }
1234
1235 if (blockType == WBT_CONTEXT)
1236 {
1237 /* If the blockType is set to WBT_CONTEXT, then channelId MUST be set to 0xFF.*/
1238 if (channelId != 0xFF)
1239 {
1240 WLog_Print(context->priv->log, WLOG_ERROR,
1241 "invalid channelId 0x%02" PRIX8 " for blockType 0x%08" PRIX32 "",
1242 channelId, blockType);
1243 return FALSE;
1244 }
1245 }
1246 else
1247 {
1248 /* For all other values of blockType, channelId MUST be set to 0x00. */
1249 if (channelId != 0x00)
1250 {
1251 WLog_Print(context->priv->log, WLOG_ERROR,
1252 "invalid channelId 0x%02" PRIX8 " for blockType WBT_CONTEXT",
1253 channelId);
1254 return FALSE;
1255 }
1256 }
1257 }
1258
1259 const size_t blockLenNoHeader = blockLen - 6;
1260 if (blockLenNoHeader < extraBlockLen)
1261 {
1262 WLog_Print(context->priv->log, WLOG_ERROR,
1263 "blockLen too small(%" PRIu32 "), must be >= 6 + %" PRIuz, blockLen,
1264 extraBlockLen);
1265 return FALSE;
1266 }
1267
1268 const size_t subStreamLen = blockLenNoHeader - extraBlockLen;
1269 wStream* subStream = Stream_StaticInit(&subStreamBuffer, Stream_Pointer(s), subStreamLen);
1270 Stream_Seek(s, subStreamLen);
1271
1272 switch (blockType)
1273 {
1274 /* Header messages:
1275 * The stream MUST start with the header messages and any of these headers can appear
1276 * in the stream at a later stage. The header messages can be repeated.
1277 */
1278 case WBT_SYNC:
1279 ok = rfx_process_message_sync(context, subStream);
1280 break;
1281
1282 case WBT_CONTEXT:
1283 ok = rfx_process_message_context(context, subStream);
1284 break;
1285
1286 case WBT_CODEC_VERSIONS:
1287 ok = rfx_process_message_codec_versions(context, subStream);
1288 break;
1289
1290 case WBT_CHANNELS:
1291 ok = rfx_process_message_channels(context, subStream);
1292 break;
1293
1294 /* Data messages:
1295 * The data associated with each encoded frame or image is always bracketed by the
1296 * TS_RFX_FRAME_BEGIN (section 2.2.2.3.1) and TS_RFX_FRAME_END (section 2.2.2.3.2)
1297 * messages. There MUST only be one TS_RFX_REGION (section 2.2.2.3.3) message per
1298 * frame and one TS_RFX_TILESET (section 2.2.2.3.4) message per TS_RFX_REGION.
1299 */
1300
1301 case WBT_FRAME_BEGIN:
1302 ok = rfx_process_message_frame_begin(context, message, subStream,
1303 &context->expectedDataBlockType);
1304 break;
1305
1306 case WBT_REGION:
1307 ok = rfx_process_message_region(context, message, subStream,
1308 &context->expectedDataBlockType);
1309 break;
1310
1311 case WBT_EXTENSION:
1312 ok = rfx_process_message_tileset(context, message, subStream,
1313 &context->expectedDataBlockType);
1314 break;
1315
1316 case WBT_FRAME_END:
1317 ok = rfx_process_message_frame_end(context, message, subStream,
1318 &context->expectedDataBlockType);
1319 break;
1320
1321 default:
1322 WLog_Print(context->priv->log, WLOG_ERROR, "unknown blockType 0x%" PRIX32 "",
1323 blockType);
1324 return FALSE;
1325 }
1326 }
1327
1328 if (ok)
1329 {
1330 UINT32 nbUpdateRects = 0;
1331 REGION16 clippingRects = WINPR_C_ARRAY_INIT;
1332 const RECTANGLE_16* updateRects = nullptr;
1333 const DWORD formatSize = FreeRDPGetBytesPerPixel(context->pixel_format);
1334 const UINT32 dstWidth = dstStride / FreeRDPGetBytesPerPixel(dstFormat);
1335 region16_init(&clippingRects);
1336
1337 WINPR_ASSERT(dstWidth <= UINT16_MAX);
1338 WINPR_ASSERT(dstHeight <= UINT16_MAX);
1339 for (UINT32 i = 0; i < message->numRects; i++)
1340 {
1341 RECTANGLE_16 clippingRect = WINPR_C_ARRAY_INIT;
1342 const RFX_RECT* rect = &(message->rects[i]);
1343
1344 if (!rect_is_valid(rect, left, top, &clippingRect))
1345 {
1346 region16_uninit(&updateRegion);
1347 region16_uninit(&clippingRects);
1348 return FALSE;
1349 }
1350
1351 clippingRect.left = WINPR_ASSERTING_INT_CAST(UINT16, MIN(left + rect->x, dstWidth));
1352 clippingRect.top = WINPR_ASSERTING_INT_CAST(UINT16, MIN(top + rect->y, dstHeight));
1353
1354 const UINT32 rw = 1UL * clippingRect.left + rect->width;
1355 const UINT32 rh = 1UL * clippingRect.top + rect->height;
1356 const uint16_t right = WINPR_ASSERTING_INT_CAST(UINT16, MIN(rw, dstWidth));
1357 const uint16_t bottom = WINPR_ASSERTING_INT_CAST(UINT16, MIN(rh, dstHeight));
1358 clippingRect.right = right;
1359 clippingRect.bottom = bottom;
1360 if (!region16_union_rect(&clippingRects, &clippingRects, &clippingRect))
1361 {
1362 region16_uninit(&updateRegion);
1363 region16_uninit(&clippingRects);
1364 return FALSE;
1365 }
1366 }
1367
1368 for (UINT32 i = 0; i < message->numTiles; i++)
1369 {
1370 RECTANGLE_16 updateRect = WINPR_C_ARRAY_INIT;
1371 const RFX_TILE* tile = rfx_message_get_tile(message, i);
1372
1373 WINPR_ASSERT(left + tile->x <= UINT16_MAX);
1374 WINPR_ASSERT(top + tile->y <= UINT16_MAX);
1375
1376 updateRect.left = (UINT16)left + tile->x;
1377 updateRect.top = (UINT16)top + tile->y;
1378 updateRect.right = updateRect.left + 64;
1379 updateRect.bottom = updateRect.top + 64;
1380 region16_init(&updateRegion);
1381 if (!region16_intersect_rect(&updateRegion, &clippingRects, &updateRect))
1382 {
1383 region16_uninit(&updateRegion);
1384 region16_uninit(&clippingRects);
1385 return FALSE;
1386 }
1387 updateRects = region16_rects(&updateRegion, &nbUpdateRects);
1388
1389 for (UINT32 j = 0; j < nbUpdateRects; j++)
1390 {
1391 const RECTANGLE_16* cur = &updateRects[j];
1392 const UINT32 stride = 64 * formatSize;
1393 const UINT32 nXDst = cur->left;
1394 const UINT32 nYDst = cur->top;
1395 const UINT32 nXSrc = nXDst - updateRect.left;
1396 const UINT32 nYSrc = nYDst - updateRect.top;
1397 const UINT32 nWidth = cur->right - cur->left;
1398 const UINT32 nHeight = cur->bottom - cur->top;
1399
1400 if (!freerdp_image_copy_no_overlap(
1401 dst, dstFormat, dstStride, nXDst, nYDst, nWidth, nHeight, tile->data,
1402 context->pixel_format, stride, nXSrc, nYSrc, nullptr, FREERDP_FLIP_NONE))
1403 {
1404 region16_uninit(&updateRegion);
1405 region16_uninit(&clippingRects);
1406 WLog_Print(context->priv->log, WLOG_ERROR,
1407 "nbUpdateRectx[%" PRIu32 " (%" PRIu32 ")] freerdp_image_copy failed",
1408 j, nbUpdateRects);
1409 return FALSE;
1410 }
1411
1412 if (invalidRegion)
1413 {
1414 if (!region16_union_rect(invalidRegion, invalidRegion, cur))
1415 {
1416 region16_uninit(&updateRegion);
1417 region16_uninit(&clippingRects);
1418 return FALSE;
1419 }
1420 }
1421 }
1422
1423 region16_uninit(&updateRegion);
1424 }
1425
1426 region16_uninit(&clippingRects);
1427 return TRUE;
1428 }
1429 else
1430 {
1431 rfx_message_clear(context, message);
1432 context->currentMessage.freeArray = TRUE;
1433 }
1434
1435 WLog_Print(context->priv->log, WLOG_ERROR, "failed");
1436 return FALSE;
1437}
1438
1439const UINT32* rfx_message_get_quants(const RFX_MESSAGE* WINPR_RESTRICT message,
1440 UINT16* WINPR_RESTRICT numQuantVals)
1441{
1442 WINPR_ASSERT(message);
1443 if (numQuantVals)
1444 *numQuantVals = message->numQuant;
1445 return message->quantVals;
1446}
1447
1448const RFX_TILE** rfx_message_get_tiles(const RFX_MESSAGE* WINPR_RESTRICT message,
1449 UINT16* WINPR_RESTRICT numTiles)
1450{
1451 WINPR_ASSERT(message);
1452 if (numTiles)
1453 *numTiles = message->numTiles;
1454
1455 union
1456 {
1457 RFX_TILE** pp;
1458 const RFX_TILE** ppc;
1459 } cnv;
1460 cnv.pp = message->tiles;
1461 return cnv.ppc;
1462}
1463
1464UINT16 rfx_message_get_tile_count(const RFX_MESSAGE* WINPR_RESTRICT message)
1465{
1466 WINPR_ASSERT(message);
1467 return message->numTiles;
1468}
1469
1470const RFX_RECT* rfx_message_get_rects(const RFX_MESSAGE* WINPR_RESTRICT message,
1471 UINT16* WINPR_RESTRICT numRects)
1472{
1473 WINPR_ASSERT(message);
1474 if (numRects)
1475 *numRects = message->numRects;
1476 return message->rects;
1477}
1478
1479UINT16 rfx_message_get_rect_count(const RFX_MESSAGE* WINPR_RESTRICT message)
1480{
1481 WINPR_ASSERT(message);
1482 return message->numRects;
1483}
1484
1485static BOOL rfx_message_clear(RFX_CONTEXT* WINPR_RESTRICT context,
1486 RFX_MESSAGE* WINPR_RESTRICT message)
1487{
1488 if (!message)
1489 return FALSE;
1490
1491 winpr_aligned_free(message->rects);
1492
1493 if (message->tiles)
1494 {
1495 for (size_t i = 0; i < message->numTiles; i++)
1496 {
1497 RFX_TILE* tile = message->tiles[i];
1498 if (!tile)
1499 continue;
1500
1501 if (tile->YCbCrData)
1502 {
1503 BufferPool_Return(context->priv->BufferPool, tile->YCbCrData);
1504 tile->YCbCrData = nullptr;
1505 }
1506
1507 ObjectPool_Return(context->priv->TilePool, (void*)tile);
1508 }
1509
1510 rfx_allocate_tiles(message, 0, FALSE);
1511 }
1512
1513 const BOOL freeArray = message->freeArray;
1514 const RFX_MESSAGE empty = WINPR_C_ARRAY_INIT;
1515 *message = empty;
1516 return freeArray;
1517}
1518
1519void rfx_message_free(RFX_CONTEXT* WINPR_RESTRICT context, RFX_MESSAGE* WINPR_RESTRICT message)
1520{
1521 if (!rfx_message_clear(context, message))
1522 winpr_aligned_free(message);
1523}
1524
1525static inline void rfx_update_context_properties(RFX_CONTEXT* WINPR_RESTRICT context)
1526{
1527 UINT16 properties = 0;
1528
1529 WINPR_ASSERT(context);
1530 /* properties in tilesets: note that this has different format from the one in TS_RFX_CONTEXT */
1531 properties = 1; /* lt */
1532 properties |= (context->flags << 1); /* flags */
1533 properties |= (COL_CONV_ICT << 4); /* cct */
1534 properties |= (CLW_XFORM_DWT_53_A << 6); /* xft */
1535 properties |= ((context->mode == RLGR1 ? CLW_ENTROPY_RLGR1 : CLW_ENTROPY_RLGR3) << 10); /* et */
1536 properties |= (SCALAR_QUANTIZATION << 14); /* qt */
1537 context->properties = properties;
1538}
1539
1540static inline void
1541rfx_write_message_sync(WINPR_ATTR_UNUSED const RFX_CONTEXT* WINPR_RESTRICT context,
1542 WINPR_ATTR_UNUSED wStream* WINPR_RESTRICT s)
1543{
1544 WINPR_ASSERT(context);
1545
1546 Stream_Write_UINT16(s, WBT_SYNC); /* BlockT.blockType (2 bytes) */
1547 Stream_Write_UINT32(s, 12); /* BlockT.blockLen (4 bytes) */
1548 Stream_Write_UINT32(s, WF_MAGIC); /* magic (4 bytes) */
1549 Stream_Write_UINT16(s, WF_VERSION_1_0); /* version (2 bytes) */
1550}
1551
1552static inline void
1553rfx_write_message_codec_versions(WINPR_ATTR_UNUSED const RFX_CONTEXT* WINPR_RESTRICT context,
1554 wStream* WINPR_RESTRICT s)
1555{
1556 WINPR_ASSERT(context);
1557
1558 Stream_Write_UINT16(s, WBT_CODEC_VERSIONS); /* BlockT.blockType (2 bytes) */
1559 Stream_Write_UINT32(s, 10); /* BlockT.blockLen (4 bytes) */
1560 Stream_Write_UINT8(s, 1); /* numCodecs (1 byte) */
1561 Stream_Write_UINT8(s, 1); /* codecs.codecId (1 byte) */
1562 Stream_Write_UINT16(s, WF_VERSION_1_0); /* codecs.version (2 bytes) */
1563}
1564
1565static inline void rfx_write_message_channels(const RFX_CONTEXT* WINPR_RESTRICT context,
1566 wStream* WINPR_RESTRICT s)
1567{
1568 WINPR_ASSERT(context);
1569
1570 Stream_Write_UINT16(s, WBT_CHANNELS); /* BlockT.blockType (2 bytes) */
1571 Stream_Write_UINT32(s, 12); /* BlockT.blockLen (4 bytes) */
1572 Stream_Write_UINT8(s, 1); /* numChannels (1 byte) */
1573 Stream_Write_UINT8(s, 0); /* Channel.channelId (1 byte) */
1574 Stream_Write_UINT16(s, context->width); /* Channel.width (2 bytes) */
1575 Stream_Write_UINT16(s, context->height); /* Channel.height (2 bytes) */
1576}
1577
1578static inline void rfx_write_message_context(RFX_CONTEXT* WINPR_RESTRICT context,
1579 wStream* WINPR_RESTRICT s)
1580{
1581 UINT16 properties = 0;
1582 WINPR_ASSERT(context);
1583
1584 Stream_Write_UINT16(s, WBT_CONTEXT); /* CodecChannelT.blockType (2 bytes) */
1585 Stream_Write_UINT32(s, 13); /* CodecChannelT.blockLen (4 bytes) */
1586 Stream_Write_UINT8(s, 1); /* CodecChannelT.codecId (1 byte) */
1587 Stream_Write_UINT8(s, 0xFF); /* CodecChannelT.channelId (1 byte) */
1588 Stream_Write_UINT8(s, 0); /* ctxId (1 byte) */
1589 Stream_Write_UINT16(s, CT_TILE_64x64); /* tileSize (2 bytes) */
1590 /* properties */
1591 properties = context->flags; /* flags */
1592 properties |= (COL_CONV_ICT << 3); /* cct */
1593 properties |= (CLW_XFORM_DWT_53_A << 5); /* xft */
1594 properties |= ((context->mode == RLGR1 ? CLW_ENTROPY_RLGR1 : CLW_ENTROPY_RLGR3) << 9); /* et */
1595 properties |= (SCALAR_QUANTIZATION << 13); /* qt */
1596 Stream_Write_UINT16(s, properties); /* properties (2 bytes) */
1597 rfx_update_context_properties(context);
1598}
1599
1600static inline BOOL rfx_compose_message_header(RFX_CONTEXT* WINPR_RESTRICT context,
1601 wStream* WINPR_RESTRICT s)
1602{
1603 WINPR_ASSERT(context);
1604 if (!Stream_EnsureRemainingCapacity(s, 12ull + 10ull + 12ull + 13ull))
1605 return FALSE;
1606
1607 rfx_write_message_sync(context, s);
1608 rfx_write_message_context(context, s);
1609 rfx_write_message_codec_versions(context, s);
1610 rfx_write_message_channels(context, s);
1611 return TRUE;
1612}
1613
1614static inline size_t rfx_tile_length(const RFX_TILE* WINPR_RESTRICT tile)
1615{
1616 WINPR_ASSERT(tile);
1617 return 19ull + tile->YLen + tile->CbLen + tile->CrLen;
1618}
1619
1620static inline BOOL rfx_write_tile(wStream* WINPR_RESTRICT s, const RFX_TILE* WINPR_RESTRICT tile)
1621{
1622 const size_t blockLen = rfx_tile_length(tile);
1623 if (blockLen > UINT32_MAX)
1624 return FALSE;
1625 if (!Stream_EnsureRemainingCapacity(s, blockLen))
1626 return FALSE;
1627
1628 Stream_Write_UINT16(s, CBT_TILE); /* BlockT.blockType (2 bytes) */
1629 Stream_Write_UINT32(s, (UINT32)blockLen); /* BlockT.blockLen (4 bytes) */
1630 Stream_Write_UINT8(s, tile->quantIdxY); /* quantIdxY (1 byte) */
1631 Stream_Write_UINT8(s, tile->quantIdxCb); /* quantIdxCb (1 byte) */
1632 Stream_Write_UINT8(s, tile->quantIdxCr); /* quantIdxCr (1 byte) */
1633 Stream_Write_UINT16(s, tile->xIdx); /* xIdx (2 bytes) */
1634 Stream_Write_UINT16(s, tile->yIdx); /* yIdx (2 bytes) */
1635 Stream_Write_UINT16(s, tile->YLen); /* YLen (2 bytes) */
1636 Stream_Write_UINT16(s, tile->CbLen); /* CbLen (2 bytes) */
1637 Stream_Write_UINT16(s, tile->CrLen); /* CrLen (2 bytes) */
1638 Stream_Write(s, tile->YData, tile->YLen); /* YData */
1639 Stream_Write(s, tile->CbData, tile->CbLen); /* CbData */
1640 Stream_Write(s, tile->CrData, tile->CrLen); /* CrData */
1641 return TRUE;
1642}
1643
1644struct S_RFX_TILE_COMPOSE_WORK_PARAM
1645{
1646 RFX_TILE* tile;
1647 RFX_CONTEXT* context;
1648};
1649
1650static inline void CALLBACK
1651rfx_compose_message_tile_work_callback(WINPR_ATTR_UNUSED PTP_CALLBACK_INSTANCE instance,
1652 void* context, WINPR_ATTR_UNUSED PTP_WORK work)
1653{
1654 RFX_TILE_COMPOSE_WORK_PARAM* param = (RFX_TILE_COMPOSE_WORK_PARAM*)context;
1655 WINPR_ASSERT(param);
1656 WINPR_ASSERT(param->context);
1657 WINPR_ASSERT(param->context->priv);
1658
1659 if (!rfx_encode_rgb(param->context, param->tile))
1660 WLog_Print(param->context->priv->log, WLOG_ERROR, "rfx_encode_rgb failed");
1661}
1662
1663static inline BOOL computeRegion(const RFX_RECT* WINPR_RESTRICT rects, size_t numRects,
1664 REGION16* WINPR_RESTRICT region, size_t width, size_t height)
1665{
1666 const RECTANGLE_16 mainRect = { 0, 0, WINPR_ASSERTING_INT_CAST(UINT16, width),
1667 WINPR_ASSERTING_INT_CAST(UINT16, height) };
1668
1669 WINPR_ASSERT(rects);
1670 for (size_t i = 0; i < numRects; i++)
1671 {
1672 const RFX_RECT* rect = &rects[i];
1673 RECTANGLE_16 rect16 = WINPR_C_ARRAY_INIT;
1674 rect16.left = rect->x;
1675 rect16.top = rect->y;
1676 rect16.right = rect->x + rect->width;
1677 rect16.bottom = rect->y + rect->height;
1678
1679 if (!region16_union_rect(region, region, &rect16))
1680 return FALSE;
1681 }
1682
1683 return region16_intersect_rect(region, region, &mainRect);
1684}
1685
1686#define TILE_NO(v) ((v) / 64)
1687
1688static inline BOOL setupWorkers(RFX_CONTEXT* WINPR_RESTRICT context, size_t nbTiles)
1689{
1690 WINPR_ASSERT(context);
1691
1692 RFX_CONTEXT_PRIV* priv = context->priv;
1693 WINPR_ASSERT(priv);
1694
1695 void* pmem = nullptr;
1696
1697 if (!context->priv->UseThreads)
1698 return TRUE;
1699
1700 if (!(pmem = winpr_aligned_recalloc((void*)priv->workObjects, nbTiles, sizeof(PTP_WORK), 32)))
1701 return FALSE;
1702
1703 priv->workObjects = (PTP_WORK*)pmem;
1704
1705 if (!(pmem = winpr_aligned_recalloc(priv->tileWorkParams, nbTiles,
1706 sizeof(RFX_TILE_COMPOSE_WORK_PARAM), 32)))
1707 return FALSE;
1708
1709 priv->tileWorkParams = (RFX_TILE_COMPOSE_WORK_PARAM*)pmem;
1710 return TRUE;
1711}
1712
1713static inline BOOL rfx_ensure_tiles(RFX_MESSAGE* WINPR_RESTRICT message, size_t count)
1714{
1715 WINPR_ASSERT(message);
1716
1717 if (message->numTiles + count <= message->allocatedTiles)
1718 return TRUE;
1719
1720 const size_t alloc = MAX(message->allocatedTiles + 1024, message->numTiles + count);
1721 return rfx_allocate_tiles(message, alloc, TRUE);
1722}
1723
1724RFX_MESSAGE* rfx_encode_message(RFX_CONTEXT* WINPR_RESTRICT context,
1725 const RFX_RECT* WINPR_RESTRICT rects, size_t numRects,
1726 const BYTE* WINPR_RESTRICT data, UINT32 w, UINT32 h, size_t s)
1727{
1728 const UINT32 width = w;
1729 const UINT32 height = h;
1730 const UINT32 scanline = (UINT32)s;
1731 RFX_MESSAGE* message = nullptr;
1732 PTP_WORK* workObject = nullptr;
1733 RFX_TILE_COMPOSE_WORK_PARAM* workParam = nullptr;
1734 BOOL success = FALSE;
1735 REGION16 rectsRegion = WINPR_C_ARRAY_INIT;
1736 REGION16 tilesRegion = WINPR_C_ARRAY_INIT;
1737 RECTANGLE_16 currentTileRect = WINPR_C_ARRAY_INIT;
1738 const RECTANGLE_16* regionRect = nullptr;
1739
1740 WINPR_ASSERT(data);
1741 WINPR_ASSERT(rects);
1742 WINPR_ASSERT(numRects > 0);
1743 WINPR_ASSERT(w > 0);
1744 WINPR_ASSERT(h > 0);
1745 WINPR_ASSERT(s > 0);
1746
1747 if (!(message = (RFX_MESSAGE*)winpr_aligned_calloc(1, sizeof(RFX_MESSAGE), 32)))
1748 return nullptr;
1749
1750 region16_init(&tilesRegion);
1751 region16_init(&rectsRegion);
1752
1753 if (context->state == RFX_STATE_SEND_HEADERS)
1754 rfx_update_context_properties(context);
1755
1756 message->frameIdx = context->frameIdx++;
1757
1758 if (!context->numQuant)
1759 {
1760 WINPR_ASSERT(context->quants == nullptr);
1761 WINPR_ASSERT(NR_QUANT_VALUES == ARRAYSIZE(rfx_default_quantization_values));
1762 if (!(context->quants =
1763 (UINT32*)winpr_aligned_calloc(1, sizeof(rfx_default_quantization_values), 32)))
1764 goto skip_encoding_loop;
1765
1766 CopyMemory(context->quants, &rfx_default_quantization_values,
1767 sizeof(rfx_default_quantization_values));
1768 context->numQuant = 1;
1769 context->quantIdxY = 0;
1770 context->quantIdxCb = 0;
1771 context->quantIdxCr = 0;
1772 }
1773
1774 message->numQuant = context->numQuant;
1775 message->quantVals = context->quants;
1776
1777 {
1778 const UINT32 bytesPerPixel = (context->bits_per_pixel / 8);
1779 if (!computeRegion(rects, numRects, &rectsRegion, width, height))
1780 goto skip_encoding_loop;
1781
1782 {
1783 const RECTANGLE_16* extents = region16_extents(&rectsRegion);
1784 WINPR_ASSERT((INT32)extents->right - extents->left > 0);
1785 WINPR_ASSERT((INT32)extents->bottom - extents->top > 0);
1786 const UINT32 maxTilesX = 1 + TILE_NO(extents->right - 1) - TILE_NO(extents->left);
1787 const UINT32 maxTilesY = 1 + TILE_NO(extents->bottom - 1) - TILE_NO(extents->top);
1788 const UINT32 maxNbTiles = maxTilesX * maxTilesY;
1789
1790 if (!rfx_ensure_tiles(message, maxNbTiles))
1791 goto skip_encoding_loop;
1792
1793 if (!setupWorkers(context, maxNbTiles))
1794 goto skip_encoding_loop;
1795 }
1796
1797 if (context->priv->UseThreads)
1798 {
1799 workObject = context->priv->workObjects;
1800 workParam = context->priv->tileWorkParams;
1801 }
1802
1803 {
1804 UINT32 regionNbRects = 0;
1805 regionRect = region16_rects(&rectsRegion, &regionNbRects);
1806
1807 if (!(message->rects = winpr_aligned_calloc(regionNbRects, sizeof(RFX_RECT), 32)))
1808 goto skip_encoding_loop;
1809
1810 message->numRects = WINPR_ASSERTING_INT_CAST(UINT16, regionNbRects);
1811
1812 for (UINT32 i = 0; i < regionNbRects; i++, regionRect++)
1813 {
1814 RFX_RECT* rfxRect = &message->rects[i];
1815 UINT32 startTileX = regionRect->left / 64;
1816 UINT32 endTileX = (regionRect->right - 1) / 64;
1817 UINT32 startTileY = regionRect->top / 64;
1818 UINT32 endTileY = (regionRect->bottom - 1) / 64;
1819 rfxRect->x = regionRect->left;
1820 rfxRect->y = regionRect->top;
1821 rfxRect->width = (regionRect->right - regionRect->left);
1822 rfxRect->height = (regionRect->bottom - regionRect->top);
1823
1824 for (UINT32 yIdx = startTileY, gridRelY = startTileY * 64; yIdx <= endTileY;
1825 yIdx++, gridRelY += 64)
1826 {
1827 UINT32 tileHeight = 64;
1828
1829 if ((yIdx == endTileY) && (gridRelY + 64 > height))
1830 tileHeight = height - gridRelY;
1831
1832 currentTileRect.top = WINPR_ASSERTING_INT_CAST(UINT16, gridRelY);
1833 currentTileRect.bottom =
1834 WINPR_ASSERTING_INT_CAST(UINT16, gridRelY + tileHeight);
1835
1836 for (UINT32 xIdx = startTileX, gridRelX = startTileX * 64; xIdx <= endTileX;
1837 xIdx++, gridRelX += 64)
1838 {
1839 union
1840 {
1841 const BYTE* cpv;
1842 BYTE* pv;
1843 } cnv;
1844 UINT32 tileWidth = 64;
1845
1846 if ((xIdx == endTileX) && (gridRelX + 64 > width))
1847 {
1848 tileWidth = (width - gridRelX);
1849 }
1850
1851 currentTileRect.left = WINPR_ASSERTING_INT_CAST(UINT16, gridRelX);
1852 currentTileRect.right =
1853 WINPR_ASSERTING_INT_CAST(UINT16, gridRelX + tileWidth);
1854
1855 /* checks if this tile is already treated */
1856 if (region16_intersects_rect(&tilesRegion, &currentTileRect))
1857 continue;
1858
1859 RFX_TILE* tile = (RFX_TILE*)ObjectPool_Take(context->priv->TilePool);
1860 if (!tile)
1861 goto skip_encoding_loop;
1862
1863 tile->xIdx = WINPR_ASSERTING_INT_CAST(UINT16, xIdx);
1864 tile->yIdx = WINPR_ASSERTING_INT_CAST(UINT16, yIdx);
1865 tile->x = WINPR_ASSERTING_INT_CAST(UINT16, gridRelX);
1866 tile->y = WINPR_ASSERTING_INT_CAST(UINT16, gridRelY);
1867 tile->scanline = scanline;
1868
1869 tile->width = tileWidth;
1870 tile->height = tileHeight;
1871 const UINT32 ax = gridRelX;
1872 const UINT32 ay = gridRelY;
1873
1874 if (tile->data && tile->allocated)
1875 {
1876 winpr_aligned_free(tile->data);
1877 tile->allocated = FALSE;
1878 }
1879
1880 /* Cast away const */
1881 cnv.cpv = &data[(ay * scanline) + (ax * bytesPerPixel)];
1882 tile->data = cnv.pv;
1883 tile->quantIdxY = context->quantIdxY;
1884 tile->quantIdxCb = context->quantIdxCb;
1885 tile->quantIdxCr = context->quantIdxCr;
1886 tile->YLen = tile->CbLen = tile->CrLen = 0;
1887
1888 if (!(tile->YCbCrData =
1889 (BYTE*)BufferPool_Take(context->priv->BufferPool, -1)))
1890 goto skip_encoding_loop;
1891
1892 tile->YData = &(tile->YCbCrData[((8192 + 32) * 0) + 16]);
1893 tile->CbData = &(tile->YCbCrData[((8192 + 32) * 1) + 16]);
1894 tile->CrData = &(tile->YCbCrData[((8192 + 32) * 2) + 16]);
1895
1896 if (!rfx_ensure_tiles(message, 1))
1897 goto skip_encoding_loop;
1898 message->tiles[message->numTiles++] = tile;
1899
1900 if (context->priv->UseThreads)
1901 {
1902 workParam->context = context;
1903 workParam->tile = tile;
1904
1905 if (!(*workObject =
1906 CreateThreadpoolWork(rfx_compose_message_tile_work_callback,
1907 (void*)workParam, nullptr)))
1908 {
1909 goto skip_encoding_loop;
1910 }
1911
1912 SubmitThreadpoolWork(*workObject);
1913 workObject++;
1914 workParam++;
1915 }
1916 else
1917 {
1918 if (!rfx_encode_rgb(context, tile))
1919 goto skip_encoding_loop;
1920 }
1921
1922 if (!region16_union_rect(&tilesRegion, &tilesRegion, &currentTileRect))
1923 goto skip_encoding_loop;
1924 } /* xIdx */
1925 } /* yIdx */
1926 } /* rects */
1927 }
1928 }
1929
1930 success = TRUE;
1931skip_encoding_loop:
1932
1933 /* when using threads ensure all computations are done */
1934 if (success)
1935 {
1936 message->tilesDataSize = 0;
1937 workObject = context->priv->workObjects;
1938
1939 for (UINT32 i = 0; i < message->numTiles; i++)
1940 {
1941 if (context->priv->UseThreads)
1942 {
1943 if (*workObject)
1944 {
1945 WaitForThreadpoolWorkCallbacks(*workObject, FALSE);
1946 CloseThreadpoolWork(*workObject);
1947 }
1948
1949 workObject++;
1950 }
1951
1952 const RFX_TILE* tile = message->tiles[i];
1953 const size_t tlen = rfx_tile_length(tile);
1954 message->tilesDataSize += WINPR_ASSERTING_INT_CAST(uint32_t, tlen);
1955 }
1956
1957 region16_uninit(&tilesRegion);
1958 region16_uninit(&rectsRegion);
1959
1960 return message;
1961 }
1962
1963 WLog_Print(context->priv->log, WLOG_ERROR, "failed");
1964
1965 rfx_message_free(context, message);
1966 region16_uninit(&tilesRegion);
1967 region16_uninit(&rectsRegion);
1968 return nullptr;
1969}
1970
1971static inline BOOL rfx_clone_rects(RFX_MESSAGE* WINPR_RESTRICT dst,
1972 const RFX_MESSAGE* WINPR_RESTRICT src)
1973{
1974 WINPR_ASSERT(dst);
1975 WINPR_ASSERT(src);
1976
1977 WINPR_ASSERT(dst->rects == nullptr);
1978 WINPR_ASSERT(dst->numRects == 0);
1979
1980 if (src->numRects == 0)
1981 return TRUE;
1982
1983 dst->rects = winpr_aligned_calloc(src->numRects, sizeof(RFX_RECT), 32);
1984 if (!dst->rects)
1985 return FALSE;
1986 dst->numRects = src->numRects;
1987 for (size_t x = 0; x < src->numRects; x++)
1988 {
1989 dst->rects[x] = src->rects[x];
1990 }
1991 return TRUE;
1992}
1993
1994static inline BOOL rfx_clone_quants(RFX_MESSAGE* WINPR_RESTRICT dst,
1995 const RFX_MESSAGE* WINPR_RESTRICT src)
1996{
1997 WINPR_ASSERT(dst);
1998 WINPR_ASSERT(src);
1999
2000 WINPR_ASSERT(dst->quantVals == nullptr);
2001 WINPR_ASSERT(dst->numQuant == 0);
2002
2003 if (src->numQuant == 0)
2004 return TRUE;
2005
2006 /* quantVals are part of context */
2007 dst->quantVals = src->quantVals;
2008 dst->numQuant = src->numQuant;
2009
2010 return TRUE;
2011}
2012
2013static inline RFX_MESSAGE* rfx_split_message(RFX_CONTEXT* WINPR_RESTRICT context,
2014 RFX_MESSAGE* WINPR_RESTRICT message,
2015 size_t* WINPR_RESTRICT numMessages, size_t maxDataSize)
2016{
2017 WINPR_ASSERT(context);
2018 WINPR_ASSERT(message);
2019 WINPR_ASSERT(numMessages);
2020
2021 if (maxDataSize <= 1024)
2022 return nullptr;
2023
2024 maxDataSize -= 1024; /* reserve enough space for headers */
2025 *numMessages = ((message->tilesDataSize + maxDataSize) / maxDataSize) * 4ull;
2026
2027 RFX_MESSAGE* messages =
2028 (RFX_MESSAGE*)winpr_aligned_calloc((*numMessages), sizeof(RFX_MESSAGE), 32);
2029 if (!messages)
2030 return nullptr;
2031
2032 UINT32 j = 0;
2033 for (UINT16 i = 0; i < message->numTiles; i++)
2034 {
2035 RFX_TILE* tile = message->tiles[i];
2036 RFX_MESSAGE* msg = &messages[j];
2037
2038 WINPR_ASSERT(tile);
2039 WINPR_ASSERT(msg);
2040
2041 const size_t tileDataSize = rfx_tile_length(tile);
2042
2043 if ((msg->tilesDataSize + tileDataSize) > ((UINT32)maxDataSize))
2044 j++;
2045
2046 if (msg->numTiles == 0)
2047 {
2048 msg->frameIdx = message->frameIdx + j;
2049 if (!rfx_clone_quants(msg, message))
2050 goto free_messages;
2051 if (!rfx_clone_rects(msg, message))
2052 goto free_messages;
2053 msg->freeArray = TRUE;
2054 if (!rfx_allocate_tiles(msg, message->numTiles, TRUE))
2055 goto free_messages;
2056 }
2057
2058 msg->tilesDataSize += WINPR_ASSERTING_INT_CAST(uint32_t, tileDataSize);
2059
2060 WINPR_ASSERT(msg->numTiles < msg->allocatedTiles);
2061 msg->tiles[msg->numTiles++] = message->tiles[i];
2062 message->tiles[i] = nullptr;
2063 }
2064
2065 *numMessages = j + 1ULL;
2066 context->frameIdx += j;
2067 message->numTiles = 0;
2068 return messages;
2069free_messages:
2070
2071 for (size_t i = 0; i < j; i++)
2072 rfx_allocate_tiles(&messages[i], 0, FALSE);
2073
2074 winpr_aligned_free(messages);
2075 return nullptr;
2076}
2077
2078const RFX_MESSAGE* rfx_message_list_get(const RFX_MESSAGE_LIST* WINPR_RESTRICT messages, size_t idx)
2079{
2080 WINPR_ASSERT(messages);
2081 if (idx >= messages->count)
2082 return nullptr;
2083 WINPR_ASSERT(messages->list);
2084 return &messages->list[idx];
2085}
2086
2087void rfx_message_list_free(RFX_MESSAGE_LIST* messages)
2088{
2089 if (!messages)
2090 return;
2091 for (size_t x = 0; x < messages->count; x++)
2092 rfx_message_clear(messages->context, &messages->list[x]);
2093 free(messages);
2094}
2095
2096static inline RFX_MESSAGE_LIST* rfx_message_list_new(RFX_CONTEXT* WINPR_RESTRICT context,
2097 RFX_MESSAGE* WINPR_RESTRICT messages,
2098 size_t count)
2099{
2100 WINPR_ASSERT(context);
2101 RFX_MESSAGE_LIST* msg = calloc(1, sizeof(RFX_MESSAGE_LIST));
2102 WINPR_ASSERT(msg);
2103
2104 msg->context = context;
2105 msg->count = count;
2106 msg->list = messages;
2107 return msg;
2108}
2109
2110RFX_MESSAGE_LIST* rfx_encode_messages(RFX_CONTEXT* WINPR_RESTRICT context,
2111 const RFX_RECT* WINPR_RESTRICT rects, size_t numRects,
2112 const BYTE* WINPR_RESTRICT data, UINT32 width, UINT32 height,
2113 UINT32 scanline, size_t* WINPR_RESTRICT numMessages,
2114 size_t maxDataSize)
2115{
2116 WINPR_ASSERT(context);
2117 WINPR_ASSERT(numMessages);
2118
2119 RFX_MESSAGE* message =
2120 rfx_encode_message(context, rects, numRects, data, width, height, scanline);
2121 if (!message)
2122 return nullptr;
2123
2124 RFX_MESSAGE* list = rfx_split_message(context, message, numMessages, maxDataSize);
2125 rfx_message_free(context, message);
2126 if (!list)
2127 return nullptr;
2128
2129 return rfx_message_list_new(context, list, *numMessages);
2130}
2131
2132static inline BOOL rfx_write_message_tileset(RFX_CONTEXT* WINPR_RESTRICT context,
2133 wStream* WINPR_RESTRICT s,
2134 const RFX_MESSAGE* WINPR_RESTRICT message)
2135{
2136 WINPR_ASSERT(context);
2137 WINPR_ASSERT(message);
2138
2139 const UINT32 blockLen = 22 + (message->numQuant * 5) + message->tilesDataSize;
2140
2141 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2142 return FALSE;
2143
2144 Stream_Write_UINT16(s, WBT_EXTENSION); /* CodecChannelT.blockType (2 bytes) */
2145 Stream_Write_UINT32(s, blockLen); /* set CodecChannelT.blockLen (4 bytes) */
2146 Stream_Write_UINT8(s, 1); /* CodecChannelT.codecId (1 byte) */
2147 Stream_Write_UINT8(s, 0); /* CodecChannelT.channelId (1 byte) */
2148 Stream_Write_UINT16(s, CBT_TILESET); /* subtype (2 bytes) */
2149 Stream_Write_UINT16(s, 0); /* idx (2 bytes) */
2150 Stream_Write_UINT16(s, context->properties); /* properties (2 bytes) */
2151 Stream_Write_UINT8(
2152 s, WINPR_ASSERTING_INT_CAST(uint8_t, message->numQuant)); /* numQuant (1 byte) */
2153 Stream_Write_UINT8(s, 0x40); /* tileSize (1 byte) */
2154 Stream_Write_UINT16(s, message->numTiles); /* numTiles (2 bytes) */
2155 Stream_Write_UINT32(s, message->tilesDataSize); /* tilesDataSize (4 bytes) */
2156
2157 UINT32* quantVals = message->quantVals;
2158 for (size_t i = 0; i < message->numQuant * 5ul; i++)
2159 {
2160 WINPR_ASSERT(quantVals);
2161 Stream_Write_UINT8(s,
2162 WINPR_ASSERTING_INT_CAST(uint8_t, quantVals[0] + (quantVals[1] << 4)));
2163 quantVals += 2;
2164 }
2165
2166 for (size_t i = 0; i < message->numTiles; i++)
2167 {
2168 RFX_TILE* tile = message->tiles[i];
2169 if (!tile)
2170 return FALSE;
2171
2172 if (!rfx_write_tile(s, tile))
2173 return FALSE;
2174 }
2175
2176#ifdef WITH_DEBUG_RFX
2177 WLog_Print(context->priv->log, WLOG_DEBUG,
2178 "numQuant: %" PRIu16 " numTiles: %" PRIu16 " tilesDataSize: %" PRIu32 "",
2179 message->numQuant, message->numTiles, message->tilesDataSize);
2180#endif
2181 return TRUE;
2182}
2183
2184static inline BOOL
2185rfx_write_message_frame_begin(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT context,
2186 wStream* WINPR_RESTRICT s, const RFX_MESSAGE* WINPR_RESTRICT message)
2187{
2188 WINPR_ASSERT(context);
2189 WINPR_ASSERT(message);
2190
2191 if (!Stream_EnsureRemainingCapacity(s, 14))
2192 return FALSE;
2193
2194 Stream_Write_UINT16(s, WBT_FRAME_BEGIN); /* CodecChannelT.blockType */
2195 Stream_Write_UINT32(s, 14); /* CodecChannelT.blockLen */
2196 Stream_Write_UINT8(s, 1); /* CodecChannelT.codecId */
2197 Stream_Write_UINT8(s, 0); /* CodecChannelT.channelId */
2198 Stream_Write_UINT32(s, message->frameIdx); /* frameIdx */
2199 Stream_Write_UINT16(s, 1); /* numRegions */
2200 return TRUE;
2201}
2202
2203static inline BOOL rfx_write_message_region(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT context,
2204 wStream* WINPR_RESTRICT s,
2205 const RFX_MESSAGE* WINPR_RESTRICT message)
2206{
2207 WINPR_ASSERT(context);
2208 WINPR_ASSERT(message);
2209
2210 const size_t blockLen = 15 + (message->numRects * 8);
2211 if (blockLen > UINT32_MAX)
2212 return FALSE;
2213
2214 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2215 return FALSE;
2216
2217 Stream_Write_UINT16(s, WBT_REGION); /* CodecChannelT.blockType (2 bytes) */
2218 Stream_Write_UINT32(s, (UINT32)blockLen); /* set CodecChannelT.blockLen (4 bytes) */
2219 Stream_Write_UINT8(s, 1); /* CodecChannelT.codecId (1 byte) */
2220 Stream_Write_UINT8(s, 0); /* CodecChannelT.channelId (1 byte) */
2221 Stream_Write_UINT8(s, 1); /* regionFlags (1 byte) */
2222 Stream_Write_UINT16(s, message->numRects); /* numRects (2 bytes) */
2223
2224 for (UINT16 i = 0; i < message->numRects; i++)
2225 {
2226 const RFX_RECT* rect = rfx_message_get_rect_const(message, i);
2227 WINPR_ASSERT(rect);
2228
2229 /* Clipping rectangles are relative to destLeft, destTop */
2230 Stream_Write_UINT16(s, rect->x); /* x (2 bytes) */
2231 Stream_Write_UINT16(s, rect->y); /* y (2 bytes) */
2232 Stream_Write_UINT16(s, rect->width); /* width (2 bytes) */
2233 Stream_Write_UINT16(s, rect->height); /* height (2 bytes) */
2234 }
2235
2236 Stream_Write_UINT16(s, CBT_REGION); /* regionType (2 bytes) */
2237 Stream_Write_UINT16(s, 1); /* numTilesets (2 bytes) */
2238 return TRUE;
2239}
2240
2241static inline BOOL
2242rfx_write_message_frame_end(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT context,
2243 wStream* WINPR_RESTRICT s,
2244 WINPR_ATTR_UNUSED const RFX_MESSAGE* WINPR_RESTRICT message)
2245{
2246 WINPR_ASSERT(context);
2247 WINPR_ASSERT(message);
2248
2249 if (!Stream_EnsureRemainingCapacity(s, 8))
2250 return FALSE;
2251
2252 Stream_Write_UINT16(s, WBT_FRAME_END); /* CodecChannelT.blockType */
2253 Stream_Write_UINT32(s, 8); /* CodecChannelT.blockLen */
2254 Stream_Write_UINT8(s, 1); /* CodecChannelT.codecId */
2255 Stream_Write_UINT8(s, 0); /* CodecChannelT.channelId */
2256 return TRUE;
2257}
2258
2259BOOL rfx_write_message(RFX_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s,
2260 const RFX_MESSAGE* WINPR_RESTRICT message)
2261{
2262 WINPR_ASSERT(context);
2263 WINPR_ASSERT(message);
2264
2265 if (context->state == RFX_STATE_SEND_HEADERS)
2266 {
2267 if (!rfx_compose_message_header(context, s))
2268 return FALSE;
2269
2270 context->state = RFX_STATE_SEND_FRAME_DATA;
2271 }
2272
2273 if (!rfx_write_message_frame_begin(context, s, message) ||
2274 !rfx_write_message_region(context, s, message) ||
2275 !rfx_write_message_tileset(context, s, message) ||
2276 !rfx_write_message_frame_end(context, s, message))
2277 {
2278 return FALSE;
2279 }
2280
2281 return TRUE;
2282}
2283
2284BOOL rfx_compose_message(RFX_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s,
2285 const RFX_RECT* WINPR_RESTRICT rects, size_t numRects,
2286 const BYTE* WINPR_RESTRICT data, UINT32 width, UINT32 height,
2287 UINT32 scanline)
2288{
2289 WINPR_ASSERT(context);
2290 RFX_MESSAGE* message =
2291 rfx_encode_message(context, rects, numRects, data, width, height, scanline);
2292 if (!message)
2293 return FALSE;
2294
2295 const BOOL ret = rfx_write_message(context, s, message);
2296 rfx_message_free(context, message);
2297 return ret;
2298}
2299
2300BOOL rfx_context_set_mode(RFX_CONTEXT* WINPR_RESTRICT context, RLGR_MODE mode)
2301{
2302 WINPR_ASSERT(context);
2303 context->mode = mode;
2304 return TRUE;
2305}
2306
2307RLGR_MODE rfx_context_get_mode(RFX_CONTEXT* WINPR_RESTRICT context)
2308{
2309 WINPR_ASSERT(context);
2310 return context->mode;
2311}
2312
2313UINT32 rfx_context_get_frame_idx(const RFX_CONTEXT* WINPR_RESTRICT context)
2314{
2315 WINPR_ASSERT(context);
2316 return context->frameIdx;
2317}
2318
2319UINT32 rfx_message_get_frame_idx(const RFX_MESSAGE* WINPR_RESTRICT message)
2320{
2321 WINPR_ASSERT(message);
2322 return message->frameIdx;
2323}
2324
2325static inline BOOL rfx_write_progressive_wb_sync(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT rfx,
2326 wStream* WINPR_RESTRICT s)
2327{
2328 const UINT32 blockLen = 12;
2329 WINPR_ASSERT(rfx);
2330 WINPR_ASSERT(s);
2331
2332 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2333 return FALSE;
2334
2335 Stream_Write_UINT16(s, PROGRESSIVE_WBT_SYNC); /* blockType (2 bytes) */
2336 Stream_Write_UINT32(s, blockLen); /* blockLen (4 bytes) */
2337 Stream_Write_UINT32(s, 0xCACCACCA); /* magic (4 bytes) */
2338 Stream_Write_UINT16(s, 0x0100); /* version (2 bytes) */
2339 return TRUE;
2340}
2341
2342static inline BOOL
2343rfx_write_progressive_wb_context(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT rfx,
2344 wStream* WINPR_RESTRICT s)
2345{
2346 const UINT32 blockLen = 10;
2347 WINPR_ASSERT(rfx);
2348 WINPR_ASSERT(s);
2349
2350 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2351 return FALSE;
2352
2353 Stream_Write_UINT16(s, PROGRESSIVE_WBT_CONTEXT); /* blockType (2 bytes) */
2354 Stream_Write_UINT32(s, blockLen); /* blockLen (4 bytes) */
2355 Stream_Write_UINT8(s, 0); /* ctxId (1 byte) */
2356 Stream_Write_UINT16(s, 64); /* tileSize (2 bytes) */
2357 Stream_Write_UINT8(s, 0); /* flags (1 byte) */
2358 return TRUE;
2359}
2360
2361static inline BOOL rfx_write_progressive_region(RFX_CONTEXT* WINPR_RESTRICT rfx,
2362 wStream* WINPR_RESTRICT s,
2363 const RFX_MESSAGE* WINPR_RESTRICT msg)
2364{
2365 /* RFX_REGION */
2366 UINT32 blockLen = 18;
2367 UINT32 tilesDataSize = 0;
2368 const size_t start = Stream_GetPosition(s);
2369
2370 WINPR_ASSERT(rfx);
2371 WINPR_ASSERT(s);
2372 WINPR_ASSERT(msg);
2373
2374 blockLen += msg->numRects * 8;
2375 blockLen += msg->numQuant * 5;
2376 tilesDataSize = msg->numTiles * 22UL;
2377 for (UINT16 i = 0; i < msg->numTiles; i++)
2378 {
2379 const RFX_TILE* tile = msg->tiles[i];
2380 WINPR_ASSERT(tile);
2381 tilesDataSize += tile->YLen + tile->CbLen + tile->CrLen;
2382 }
2383 blockLen += tilesDataSize;
2384
2385 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2386 return FALSE;
2387
2388 Stream_Write_UINT16(s, PROGRESSIVE_WBT_REGION); /* blockType (2 bytes) */
2389 Stream_Write_UINT32(s, blockLen); /* blockLen (4 bytes) */
2390 Stream_Write_UINT8(s, 64); /* tileSize (1 byte) */
2391 Stream_Write_UINT16(s, msg->numRects); /* numRects (2 bytes) */
2392 WINPR_ASSERT(msg->numQuant <= UINT8_MAX);
2393 Stream_Write_UINT8(s, (UINT8)msg->numQuant); /* numQuant (1 byte) */
2394 Stream_Write_UINT8(s, 0); /* numProgQuant (1 byte) */
2395 Stream_Write_UINT8(s, 0); /* flags (1 byte) */
2396 Stream_Write_UINT16(s, msg->numTiles); /* numTiles (2 bytes) */
2397 Stream_Write_UINT32(s, tilesDataSize); /* tilesDataSize (4 bytes) */
2398
2399 for (UINT16 i = 0; i < msg->numRects; i++)
2400 {
2401 /* TS_RFX_RECT */
2402 const RFX_RECT* r = &msg->rects[i];
2403 Stream_Write_UINT16(s, r->x); /* x (2 bytes) */
2404 Stream_Write_UINT16(s, r->y); /* y (2 bytes) */
2405 Stream_Write_UINT16(s, r->width); /* width (2 bytes) */
2406 Stream_Write_UINT16(s, r->height); /* height (2 bytes) */
2407 }
2408
2417 for (UINT16 i = 0; i < msg->numQuant; i++)
2418 {
2419 const UINT32* qv = &msg->quantVals[10ULL * i];
2420 /* RFX_COMPONENT_CODEC_QUANT */
2421 Stream_Write_UINT8(s, (UINT8)(qv[0] + (qv[2] << 4))); /* LL3 (4-bit), HL3 (4-bit) */
2422 Stream_Write_UINT8(s, (UINT8)(qv[1] + (qv[3] << 4))); /* LH3 (4-bit), HH3 (4-bit) */
2423 Stream_Write_UINT8(s, (UINT8)(qv[5] + (qv[4] << 4))); /* HL2 (4-bit), LH2 (4-bit) */
2424 Stream_Write_UINT8(s, (UINT8)(qv[6] + (qv[8] << 4))); /* HH2 (4-bit), HL1 (4-bit) */
2425 Stream_Write_UINT8(s, (UINT8)(qv[7] + (qv[9] << 4))); /* LH1 (4-bit), HH1 (4-bit) */
2426 }
2427
2428 for (UINT16 i = 0; i < msg->numTiles; i++)
2429 {
2430 const RFX_TILE* tile = msg->tiles[i];
2431 if (!rfx_write_progressive_tile_simple(rfx, s, tile))
2432 return FALSE;
2433 }
2434
2435 const size_t end = Stream_GetPosition(s);
2436 const size_t used = end - start;
2437 return (used == blockLen);
2438}
2439
2440static inline BOOL
2441rfx_write_progressive_frame_begin(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT rfx,
2442 wStream* WINPR_RESTRICT s, const RFX_MESSAGE* WINPR_RESTRICT msg)
2443{
2444 const UINT32 blockLen = 12;
2445 WINPR_ASSERT(rfx);
2446 WINPR_ASSERT(s);
2447 WINPR_ASSERT(msg);
2448
2449 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2450 return FALSE;
2451
2452 Stream_Write_UINT16(s, PROGRESSIVE_WBT_FRAME_BEGIN); /* blockType (2 bytes) */
2453 Stream_Write_UINT32(s, blockLen); /* blockLen (4 bytes) */
2454 Stream_Write_UINT32(s, msg->frameIdx); /* frameIndex (4 bytes) */
2455 Stream_Write_UINT16(s, 1); /* regionCount (2 bytes) */
2456
2457 return TRUE;
2458}
2459
2460static inline BOOL
2461rfx_write_progressive_frame_end(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT rfx,
2462 wStream* WINPR_RESTRICT s)
2463{
2464 const UINT32 blockLen = 6;
2465 WINPR_ASSERT(rfx);
2466 WINPR_ASSERT(s);
2467
2468 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2469 return FALSE;
2470
2471 Stream_Write_UINT16(s, PROGRESSIVE_WBT_FRAME_END); /* blockType (2 bytes) */
2472 Stream_Write_UINT32(s, blockLen); /* blockLen (4 bytes) */
2473
2474 return TRUE;
2475}
2476
2477static inline BOOL
2478rfx_write_progressive_tile_simple(WINPR_ATTR_UNUSED RFX_CONTEXT* WINPR_RESTRICT rfx,
2479 wStream* WINPR_RESTRICT s, const RFX_TILE* WINPR_RESTRICT tile)
2480{
2481 UINT32 blockLen = 0;
2482 WINPR_ASSERT(rfx);
2483 WINPR_ASSERT(s);
2484 WINPR_ASSERT(tile);
2485
2486 blockLen = 22 + tile->YLen + tile->CbLen + tile->CrLen;
2487 if (!Stream_EnsureRemainingCapacity(s, blockLen))
2488 return FALSE;
2489
2490 Stream_Write_UINT16(s, PROGRESSIVE_WBT_TILE_SIMPLE); /* blockType (2 bytes) */
2491 Stream_Write_UINT32(s, blockLen); /* blockLen (4 bytes) */
2492 Stream_Write_UINT8(s, tile->quantIdxY); /* quantIdxY (1 byte) */
2493 Stream_Write_UINT8(s, tile->quantIdxCb); /* quantIdxCb (1 byte) */
2494 Stream_Write_UINT8(s, tile->quantIdxCr); /* quantIdxCr (1 byte) */
2495 Stream_Write_UINT16(s, tile->xIdx); /* xIdx (2 bytes) */
2496 Stream_Write_UINT16(s, tile->yIdx); /* yIdx (2 bytes) */
2497 Stream_Write_UINT8(s, 0); /* flags (1 byte) */
2498 Stream_Write_UINT16(s, tile->YLen); /* YLen (2 bytes) */
2499 Stream_Write_UINT16(s, tile->CbLen); /* CbLen (2 bytes) */
2500 Stream_Write_UINT16(s, tile->CrLen); /* CrLen (2 bytes) */
2501 Stream_Write_UINT16(s, 0); /* tailLen (2 bytes) */
2502 Stream_Write(s, tile->YData, tile->YLen); /* YData */
2503 Stream_Write(s, tile->CbData, tile->CbLen); /* CbData */
2504 Stream_Write(s, tile->CrData, tile->CrLen); /* CrData */
2505
2506 return TRUE;
2507}
2508
2509const char* rfx_get_progressive_block_type_string(UINT16 blockType)
2510{
2511 switch (blockType)
2512 {
2513 case PROGRESSIVE_WBT_SYNC:
2514 return "PROGRESSIVE_WBT_SYNC";
2515
2516 case PROGRESSIVE_WBT_FRAME_BEGIN:
2517 return "PROGRESSIVE_WBT_FRAME_BEGIN";
2518
2519 case PROGRESSIVE_WBT_FRAME_END:
2520 return "PROGRESSIVE_WBT_FRAME_END";
2521
2522 case PROGRESSIVE_WBT_CONTEXT:
2523 return "PROGRESSIVE_WBT_CONTEXT";
2524
2525 case PROGRESSIVE_WBT_REGION:
2526 return "PROGRESSIVE_WBT_REGION";
2527
2528 case PROGRESSIVE_WBT_TILE_SIMPLE:
2529 return "PROGRESSIVE_WBT_TILE_SIMPLE";
2530
2531 case PROGRESSIVE_WBT_TILE_FIRST:
2532 return "PROGRESSIVE_WBT_TILE_FIRST";
2533
2534 case PROGRESSIVE_WBT_TILE_UPGRADE:
2535 return "PROGRESSIVE_WBT_TILE_UPGRADE";
2536
2537 default:
2538 return "PROGRESSIVE_WBT_UNKNOWN";
2539 }
2540}
2541
2542BOOL rfx_write_message_progressive_simple(RFX_CONTEXT* WINPR_RESTRICT rfx,
2543 wStream* WINPR_RESTRICT s,
2544 const RFX_MESSAGE* WINPR_RESTRICT msg)
2545{
2546 WINPR_ASSERT(s);
2547 WINPR_ASSERT(msg);
2548 WINPR_ASSERT(rfx);
2549
2550 if (rfx->mode != RLGR1)
2551 {
2552 WLog_ERR(TAG, "error, RLGR1 mode is required!");
2553 return FALSE;
2554 }
2555
2556 if (!rfx_write_progressive_wb_sync(rfx, s))
2557 return FALSE;
2558
2559 if (!rfx_write_progressive_wb_context(rfx, s))
2560 return FALSE;
2561
2562 if (!rfx_write_progressive_frame_begin(rfx, s, msg))
2563 return FALSE;
2564
2565 if (!rfx_write_progressive_region(rfx, s, msg))
2566 return FALSE;
2567
2568 if (!rfx_write_progressive_frame_end(rfx, s))
2569 return FALSE;
2570
2571 return TRUE;
2572}
WINPR_JSON_Delete
WINPR_API void WINPR_JSON_Delete(WINPR_JSON *item)
Delete a WinPR JSON wrapper object.
Definition c-json.c:103
RECTANGLE_16
Definition types.h:109
RFX_RECT
Definition rfx.h:44
RFX_TILE
Definition rfx.h:52
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59
wObject::fnObjectNew
WINPR_ATTR_NODISCARD OBJECT_NEW_FN fnObjectNew
Definition collections.h:54
wObject::fnObjectInit
OBJECT_INIT_FN fnObjectInit
Definition collections.h:56