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