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