FreeRDP
Loading...
Searching...
No Matches
progressive.c
1
22#include <freerdp/config.h>
23
24#include <winpr/assert.h>
25#include <winpr/cast.h>
26#include <winpr/crt.h>
27#include <winpr/print.h>
28#include <winpr/bitstream.h>
29
30#include <freerdp/primitives.h>
31#include <freerdp/codec/color.h>
32#include <freerdp/codec/progressive.h>
33#include <freerdp/codec/region.h>
34#include <freerdp/log.h>
35
36#include "rfx_differential.h"
37#include "rfx_quantization.h"
38#include "rfx_dwt.h"
39#include "rfx_rlgr.h"
40#include "rfx_constants.h"
41#include "rfx_types.h"
42#include "progressive.h"
43
44#define TAG FREERDP_TAG("codec.progressive")
45
46typedef struct
47{
48 BOOL nonLL;
49 wBitStream* srl;
50 wBitStream* raw;
51
52 /* SRL state */
53
54 UINT32 kp;
55 int nz;
56 BOOL mode;
57} RFX_PROGRESSIVE_UPGRADE_STATE;
58
59static inline void
60progressive_component_codec_quant_read(wStream* WINPR_RESTRICT s,
61 RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT quantVal)
62{
63 BYTE b = 0;
64 Stream_Read_UINT8(s, b);
65 quantVal->LL3 = b & 0x0F;
66 quantVal->HL3 = b >> 4;
67 Stream_Read_UINT8(s, b);
68 quantVal->LH3 = b & 0x0F;
69 quantVal->HH3 = b >> 4;
70 Stream_Read_UINT8(s, b);
71 quantVal->HL2 = b & 0x0F;
72 quantVal->LH2 = b >> 4;
73 Stream_Read_UINT8(s, b);
74 quantVal->HH2 = b & 0x0F;
75 quantVal->HL1 = b >> 4;
76 Stream_Read_UINT8(s, b);
77 quantVal->LH1 = b & 0x0F;
78 quantVal->HH1 = b >> 4;
79}
80
81static inline void progressive_rfx_quant_add(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
82 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2,
83 RFX_COMPONENT_CODEC_QUANT* dst)
84{
85 dst->HL1 = q1->HL1 + q2->HL1; /* HL1 */
86 dst->LH1 = q1->LH1 + q2->LH1; /* LH1 */
87 dst->HH1 = q1->HH1 + q2->HH1; /* HH1 */
88 dst->HL2 = q1->HL2 + q2->HL2; /* HL2 */
89 dst->LH2 = q1->LH2 + q2->LH2; /* LH2 */
90 dst->HH2 = q1->HH2 + q2->HH2; /* HH2 */
91 dst->HL3 = q1->HL3 + q2->HL3; /* HL3 */
92 dst->LH3 = q1->LH3 + q2->LH3; /* LH3 */
93 dst->HH3 = q1->HH3 + q2->HH3; /* HH3 */
94 dst->LL3 = q1->LL3 + q2->LL3; /* LL3 */
95}
96
97WINPR_ATTR_NODISCARD
98static inline BOOL progressive_rfx_quant_lsub(RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q, int val)
99{
100 if (q->HL1 < val)
101 return FALSE;
102 q->HL1 -= val; /* HL1 */
103
104 if (q->LH1 < val)
105 return FALSE;
106 q->LH1 -= val; /* LH1 */
107
108 if (q->HH1 < val)
109 return FALSE;
110 q->HH1 -= val; /* HH1 */
111
112 if (q->HL2 < val)
113 return FALSE;
114 q->HL2 -= val; /* HL2 */
115
116 if (q->LH2 < val)
117 return FALSE;
118 q->LH2 -= val; /* LH2 */
119
120 if (q->HH2 < val)
121 return FALSE;
122 q->HH2 -= val; /* HH2 */
123
124 if (q->HL3 < val)
125 return FALSE;
126 q->HL3 -= val; /* HL3 */
127
128 if (q->LH3 < val)
129 return FALSE;
130 q->LH3 -= val; /* LH3 */
131
132 if (q->HH3 < val)
133 return FALSE;
134 q->HH3 -= val; /* HH3 */
135
136 if (q->LL3 < val)
137 return FALSE;
138 q->LL3 -= val; /* LL3 */
139 return TRUE;
140}
141
142WINPR_ATTR_NODISCARD
143static inline BOOL progressive_rfx_quant_sub(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
144 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2,
145 RFX_COMPONENT_CODEC_QUANT* dst)
146{
147 if (q1->HL1 < q2->HL1)
148 return FALSE;
149 dst->HL1 = q1->HL1 - q2->HL1; /* HL1 */
150
151 if (q1->LH1 < q2->LH1)
152 return FALSE;
153 dst->LH1 = q1->LH1 - q2->LH1; /* LH1 */
154
155 if (q1->HH1 < q2->HH1)
156 return FALSE;
157 dst->HH1 = q1->HH1 - q2->HH1; /* HH1 */
158
159 if (q1->HL2 < q2->HL2)
160 return FALSE;
161 dst->HL2 = q1->HL2 - q2->HL2; /* HL2 */
162
163 if (q1->LH2 < q2->LH2)
164 return FALSE;
165 dst->LH2 = q1->LH2 - q2->LH2; /* LH2 */
166
167 if (q1->HH2 < q2->HH2)
168 return FALSE;
169 dst->HH2 = q1->HH2 - q2->HH2; /* HH2 */
170
171 if (q1->HL3 < q2->HL3)
172 return FALSE;
173 dst->HL3 = q1->HL3 - q2->HL3; /* HL3 */
174
175 if (q1->LH3 < q2->LH3)
176 return FALSE;
177 dst->LH3 = q1->LH3 - q2->LH3; /* LH3 */
178
179 if (q1->HH3 < q2->HH3)
180 return FALSE;
181 dst->HH3 = q1->HH3 - q2->HH3; /* HH3 */
182
183 if (q1->LL3 < q2->LL3)
184 return FALSE;
185 dst->LL3 = q1->LL3 - q2->LL3; /* LL3 */
186
187 return TRUE;
188}
189
190static inline BOOL
191progressive_rfx_quant_lcmp_less_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q, int val)
192{
193 if (q->HL1 > val)
194 return FALSE; /* HL1 */
195
196 if (q->LH1 > val)
197 return FALSE; /* LH1 */
198
199 if (q->HH1 > val)
200 return FALSE; /* HH1 */
201
202 if (q->HL2 > val)
203 return FALSE; /* HL2 */
204
205 if (q->LH2 > val)
206 return FALSE; /* LH2 */
207
208 if (q->HH2 > val)
209 return FALSE; /* HH2 */
210
211 if (q->HL3 > val)
212 return FALSE; /* HL3 */
213
214 if (q->LH3 > val)
215 return FALSE; /* LH3 */
216
217 if (q->HH3 > val)
218 return FALSE; /* HH3 */
219
220 if (q->LL3 > val)
221 return FALSE; /* LL3 */
222
223 return TRUE;
224}
225
226static inline BOOL
227progressive_rfx_quant_lcmp_greater_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q, int val)
228{
229 if (q->HL1 < val)
230 return FALSE; /* HL1 */
231
232 if (q->LH1 < val)
233 return FALSE; /* LH1 */
234
235 if (q->HH1 < val)
236 return FALSE; /* HH1 */
237
238 if (q->HL2 < val)
239 return FALSE; /* HL2 */
240
241 if (q->LH2 < val)
242 return FALSE; /* LH2 */
243
244 if (q->HH2 < val)
245 return FALSE; /* HH2 */
246
247 if (q->HL3 < val)
248 return FALSE; /* HL3 */
249
250 if (q->LH3 < val)
251 return FALSE; /* LH3 */
252
253 if (q->HH3 < val)
254 return FALSE; /* HH3 */
255
256 if (q->LL3 < val)
257 return FALSE; /* LL3 */
258
259 return TRUE;
260}
261
262static inline BOOL
263progressive_rfx_quant_cmp_equal(const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q1,
264 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT q2)
265{
266 if (q1->HL1 != q2->HL1)
267 return FALSE; /* HL1 */
268
269 if (q1->LH1 != q2->LH1)
270 return FALSE; /* LH1 */
271
272 if (q1->HH1 != q2->HH1)
273 return FALSE; /* HH1 */
274
275 if (q1->HL2 != q2->HL2)
276 return FALSE; /* HL2 */
277
278 if (q1->LH2 != q2->LH2)
279 return FALSE; /* LH2 */
280
281 if (q1->HH2 != q2->HH2)
282 return FALSE; /* HH2 */
283
284 if (q1->HL3 != q2->HL3)
285 return FALSE; /* HL3 */
286
287 if (q1->LH3 != q2->LH3)
288 return FALSE; /* LH3 */
289
290 if (q1->HH3 != q2->HH3)
291 return FALSE; /* HH3 */
292
293 if (q1->LL3 != q2->LL3)
294 return FALSE; /* LL3 */
295
296 return TRUE;
297}
298
299static inline BOOL progressive_set_surface_data(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
300 UINT16 surfaceId,
301 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT pData)
302{
303 ULONG_PTR key = 0;
304 key = ((ULONG_PTR)surfaceId) + 1;
305
306 if (pData)
307 return HashTable_Insert(progressive->SurfaceContexts, (void*)key, pData);
308
309 HashTable_Remove(progressive->SurfaceContexts, (void*)key);
310 return TRUE;
311}
312
313static inline PROGRESSIVE_SURFACE_CONTEXT*
314progressive_get_surface_data(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, UINT16 surfaceId)
315{
316 void* key = (void*)(((ULONG_PTR)surfaceId) + 1);
317
318 if (!progressive)
319 return nullptr;
320
321 return HashTable_GetItemValue(progressive->SurfaceContexts, key);
322}
323
324static void progressive_tile_free(RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile)
325{
326 if (tile)
327 {
328 winpr_aligned_free(tile->sign);
329 winpr_aligned_free(tile->current);
330 winpr_aligned_free(tile->data);
331 winpr_aligned_free(tile);
332 }
333}
334
335static void progressive_surface_context_free(void* ptr)
336{
337 PROGRESSIVE_SURFACE_CONTEXT* surface = ptr;
338
339 if (!surface)
340 return;
341
342 if (surface->tiles)
343 {
344 for (size_t index = 0; index < surface->tilesSize; index++)
345 {
346 RFX_PROGRESSIVE_TILE* tile = surface->tiles[index];
347 progressive_tile_free(tile);
348 }
349 }
350
351 winpr_aligned_free((void*)surface->tiles);
352 winpr_aligned_free(surface->updatedTileIndices);
353 winpr_aligned_free(surface);
354}
355
356static inline RFX_PROGRESSIVE_TILE* progressive_tile_new(void)
357{
358 RFX_PROGRESSIVE_TILE* tile = winpr_aligned_calloc(1, sizeof(RFX_PROGRESSIVE_TILE), 32);
359 if (!tile)
360 goto fail;
361
362 tile->width = 64;
363 tile->height = 64;
364 tile->stride = 4 * tile->width;
365
366 {
367 const size_t dataLen = 1ull * tile->stride * tile->height;
368 tile->data = (BYTE*)winpr_aligned_malloc(dataLen, 16);
369 if (!tile->data)
370 goto fail;
371 memset(tile->data, 0xFF, dataLen);
372 }
373
374 {
375 const size_t signLen = (8192ULL + 32ULL) * 3ULL;
376 tile->sign = (BYTE*)winpr_aligned_malloc(signLen, 16);
377 }
378
379 if (!tile->sign)
380 goto fail;
381
382 {
383 const size_t currentLen = (8192ULL + 32ULL) * 3ULL;
384 tile->current = (BYTE*)winpr_aligned_malloc(currentLen, 16);
385 }
386 if (!tile->current)
387 goto fail;
388
389 return tile;
390
391fail:
392 progressive_tile_free(tile);
393 return nullptr;
394}
395
396static inline BOOL
397progressive_allocate_tile_cache(PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface, size_t min)
398{
399 size_t oldIndex = 0;
400
401 WINPR_ASSERT(surface);
402 WINPR_ASSERT(surface->gridSize > 0);
403
404 if (surface->tiles)
405 {
406 oldIndex = surface->gridSize;
407 while (surface->gridSize < min)
408 surface->gridSize += 1024;
409 }
410
411 void* tmp = winpr_aligned_recalloc((void*)surface->tiles, surface->gridSize,
412 sizeof(RFX_PROGRESSIVE_TILE*), 32);
413 if (!tmp)
414 return FALSE;
415 surface->tilesSize = surface->gridSize;
416 surface->tiles = (RFX_PROGRESSIVE_TILE**)tmp;
417
418 for (size_t x = oldIndex; x < surface->tilesSize; x++)
419 {
420 surface->tiles[x] = progressive_tile_new();
421 if (!surface->tiles[x])
422 return FALSE;
423 }
424
425 tmp =
426 winpr_aligned_recalloc(surface->updatedTileIndices, surface->gridSize, sizeof(UINT32), 32);
427 if (!tmp)
428 return FALSE;
429
430 surface->updatedTileIndices = tmp;
431
432 return TRUE;
433}
434
435static PROGRESSIVE_SURFACE_CONTEXT* progressive_surface_context_new(UINT16 surfaceId, UINT32 width,
436 UINT32 height)
437{
438 PROGRESSIVE_SURFACE_CONTEXT* surface = (PROGRESSIVE_SURFACE_CONTEXT*)winpr_aligned_calloc(
439 1, sizeof(PROGRESSIVE_SURFACE_CONTEXT), 32);
440
441 if (!surface)
442 return nullptr;
443
444 surface->id = surfaceId;
445 surface->width = width;
446 surface->height = height;
447 surface->gridWidth = (width + (64 - width % 64)) / 64;
448 surface->gridHeight = (height + (64 - height % 64)) / 64;
449 surface->gridSize = surface->gridWidth * surface->gridHeight;
450
451 if (!progressive_allocate_tile_cache(surface, surface->gridSize))
452 {
453 progressive_surface_context_free(surface);
454 return nullptr;
455 }
456
457 return surface;
458}
459
460static inline BOOL
461progressive_surface_tile_replace(PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
462 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
463 const RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile, BOOL upgrade)
464{
465 RFX_PROGRESSIVE_TILE* t = nullptr;
466
467 size_t zIdx = 0;
468 if (!surface || !tile)
469 return FALSE;
470
471 zIdx = (tile->yIdx * surface->gridWidth) + tile->xIdx;
472
473 if (zIdx >= surface->tilesSize)
474 {
475 WLog_ERR(TAG, "Invalid zIndex %" PRIuz, zIdx);
476 return FALSE;
477 }
478
479 t = surface->tiles[zIdx];
480
481 t->blockType = tile->blockType;
482 t->blockLen = tile->blockLen;
483 t->quantIdxY = tile->quantIdxY;
484 t->quantIdxCb = tile->quantIdxCb;
485 t->quantIdxCr = tile->quantIdxCr;
486 t->xIdx = tile->xIdx;
487 t->yIdx = tile->yIdx;
488 t->flags = tile->flags;
489 t->quality = tile->quality;
490 t->x = tile->xIdx * t->width;
491 t->y = tile->yIdx * t->height;
492
493 if (upgrade)
494 {
495 t->ySrlLen = tile->ySrlLen;
496 t->yRawLen = tile->yRawLen;
497 t->cbSrlLen = tile->cbSrlLen;
498 t->cbRawLen = tile->cbRawLen;
499 t->crSrlLen = tile->crSrlLen;
500 t->crRawLen = tile->crRawLen;
501 t->ySrlData = tile->ySrlData;
502 t->yRawData = tile->yRawData;
503 t->cbSrlData = tile->cbSrlData;
504 t->cbRawData = tile->cbRawData;
505 t->crSrlData = tile->crSrlData;
506 t->crRawData = tile->crRawData;
507 }
508 else
509 {
510 t->yLen = tile->yLen;
511 t->cbLen = tile->cbLen;
512 t->crLen = tile->crLen;
513 t->tailLen = tile->tailLen;
514 t->yData = tile->yData;
515 t->cbData = tile->cbData;
516 t->crData = tile->crData;
517 t->tailData = tile->tailData;
518 }
519
520 if (region->usedTiles >= region->numTiles)
521 {
522 WLog_ERR(TAG, "Invalid tile count, only expected %" PRIu16 ", got %" PRIu16,
523 region->numTiles, region->usedTiles);
524 return FALSE;
525 }
526
527 region->tiles[region->usedTiles++] = t;
528 if (!t->dirty)
529 {
530 if (surface->numUpdatedTiles >= surface->gridSize)
531 {
532 if (!progressive_allocate_tile_cache(surface, surface->numUpdatedTiles + 1))
533 return FALSE;
534 }
535
536 surface->updatedTileIndices[surface->numUpdatedTiles++] = (UINT32)zIdx;
537 }
538
539 t->dirty = TRUE;
540 return TRUE;
541}
542
543INT32 progressive_create_surface_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
544 UINT16 surfaceId, UINT32 width, UINT32 height)
545{
546 PROGRESSIVE_SURFACE_CONTEXT* surface = progressive_get_surface_data(progressive, surfaceId);
547
548 if (!surface)
549 {
550 surface = progressive_surface_context_new(surfaceId, width, height);
551
552 if (!surface)
553 return -1;
554
555 if (!progressive_set_surface_data(progressive, surfaceId, (void*)surface))
556 {
557 progressive_surface_context_free(surface);
558 return -1;
559 }
560 }
561
562 return 1;
563}
564
565int progressive_delete_surface_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
566 UINT16 surfaceId)
567{
568 progressive_set_surface_data(progressive, surfaceId, nullptr);
569
570 return 1;
571}
572
573/*
574 * Band Offset Dimensions Size
575 *
576 * HL1 0 31x33 1023
577 * LH1 1023 33x31 1023
578 * HH1 2046 31x31 961
579 *
580 * HL2 3007 16x17 272
581 * LH2 3279 17x16 272
582 * HH2 3551 16x16 256
583 *
584 * HL3 3807 8x9 72
585 * LH3 3879 9x8 72
586 * HH3 3951 8x8 64
587 *
588 * LL3 4015 9x9 81
589 */
590
591static int16_t clampi16(int val)
592{
593 if (val < INT16_MIN)
594 return INT16_MIN;
595 if (val > INT16_MAX)
596 return INT16_MAX;
597 return (int16_t)val;
598}
599
600static inline void progressive_rfx_idwt_x(const INT16* WINPR_RESTRICT pLowBand, size_t nLowStep,
601 const INT16* WINPR_RESTRICT pHighBand, size_t nHighStep,
602 INT16* WINPR_RESTRICT pDstBand, size_t nDstStep,
603 size_t nLowCount, size_t nHighCount, size_t nDstCount)
604{
605 INT16 H1 = 0;
606 INT16 X1 = 0;
607
608 for (size_t i = 0; i < nDstCount; i++)
609 {
610 const INT16* pL = pLowBand;
611 const INT16* pH = pHighBand;
612 INT16* pX = pDstBand;
613 INT16 H0 = *pH++;
614 INT16 L0 = *pL++;
615 INT16 X0 = clampi16((int32_t)L0 - H0);
616 INT16 X2 = clampi16((int32_t)L0 - H0);
617
618 for (size_t j = 0; j < (nHighCount - 1); j++)
619 {
620 H1 = *pH;
621 pH++;
622 L0 = *pL;
623 pL++;
624 X2 = clampi16((int32_t)L0 - ((H0 + H1) / 2));
625 X1 = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
626 pX[0] = X0;
627 pX[1] = X1;
628 pX += 2;
629 X0 = X2;
630 H0 = H1;
631 }
632
633 if (nLowCount <= (nHighCount + 1))
634 {
635 if (nLowCount <= nHighCount)
636 {
637 pX[0] = X2;
638 pX[1] = clampi16((int32_t)X2 + (2 * H0));
639 }
640 else
641 {
642 L0 = *pL;
643 pL++;
644 X0 = clampi16((int32_t)L0 - H0);
645 pX[0] = X2;
646 pX[1] = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
647 pX[2] = X0;
648 }
649 }
650 else
651 {
652 L0 = *pL;
653 pL++;
654 X0 = clampi16((int32_t)L0 - (H0 / 2));
655 pX[0] = X2;
656 pX[1] = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
657 pX[2] = X0;
658 L0 = *pL;
659 pL++;
660 pX[3] = clampi16((int32_t)(X0 + L0) / 2);
661 }
662
663 pLowBand += nLowStep;
664 pHighBand += nHighStep;
665 pDstBand += nDstStep;
666 }
667}
668
669static inline void progressive_rfx_idwt_y(const INT16* WINPR_RESTRICT pLowBand, size_t nLowStep,
670 const INT16* WINPR_RESTRICT pHighBand, size_t nHighStep,
671 INT16* WINPR_RESTRICT pDstBand, size_t nDstStep,
672 size_t nLowCount, size_t nHighCount, size_t nDstCount)
673{
674 for (size_t i = 0; i < nDstCount; i++)
675 {
676 INT16 H1 = 0;
677 INT16 X1 = 0;
678 const INT16* pL = pLowBand;
679 const INT16* pH = pHighBand;
680 INT16* pX = pDstBand;
681 INT16 H0 = *pH;
682 pH += nHighStep;
683 INT16 L0 = *pL;
684 pL += nLowStep;
685 int16_t X0 = clampi16((int32_t)L0 - H0);
686 int16_t X2 = clampi16((int32_t)L0 - H0);
687
688 for (size_t j = 0; j < (nHighCount - 1); j++)
689 {
690 H1 = *pH;
691 pH += nHighStep;
692 L0 = *pL;
693 pL += nLowStep;
694 X2 = clampi16((int32_t)L0 - ((H0 + H1) / 2));
695 X1 = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
696 *pX = X0;
697 pX += nDstStep;
698 *pX = X1;
699 pX += nDstStep;
700 X0 = X2;
701 H0 = H1;
702 }
703
704 if (nLowCount <= (nHighCount + 1))
705 {
706 if (nLowCount <= nHighCount)
707 {
708 *pX = X2;
709 pX += nDstStep;
710 *pX = clampi16((int32_t)X2 + (2 * H0));
711 }
712 else
713 {
714 L0 = *pL;
715 X0 = clampi16((int32_t)L0 - H0);
716 *pX = X2;
717 pX += nDstStep;
718 *pX = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
719 pX += nDstStep;
720 *pX = X0;
721 }
722 }
723 else
724 {
725 L0 = *pL;
726 pL += nLowStep;
727 X0 = clampi16((int32_t)L0 - (H0 / 2));
728 *pX = X2;
729 pX += nDstStep;
730 *pX = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
731 pX += nDstStep;
732 *pX = X0;
733 pX += nDstStep;
734 L0 = *pL;
735 *pX = clampi16((int32_t)(X0 + L0) / 2);
736 }
737
738 pLowBand++;
739 pHighBand++;
740 pDstBand++;
741 }
742}
743
744static inline size_t progressive_rfx_get_band_l_count(size_t level)
745{
746 return (64 >> level) + 1;
747}
748
749static inline size_t progressive_rfx_get_band_h_count(size_t level)
750{
751 if (level == 1)
752 return (64 >> 1) - 1;
753 else
754 return (64 + (1u << (level - 1))) >> level;
755}
756
757static inline void progressive_rfx_dwt_2d_decode_block(INT16* WINPR_RESTRICT buffer,
758 INT16* WINPR_RESTRICT temp, size_t level)
759{
760 size_t nDstStepX = 0;
761 size_t nDstStepY = 0;
762 const INT16* WINPR_RESTRICT HL = nullptr;
763 const INT16* WINPR_RESTRICT LH = nullptr;
764 const INT16* WINPR_RESTRICT HH = nullptr;
765 INT16* WINPR_RESTRICT LL = nullptr;
766 INT16* WINPR_RESTRICT L = nullptr;
767 INT16* WINPR_RESTRICT H = nullptr;
768 INT16* WINPR_RESTRICT LLx = nullptr;
769
770 const size_t nBandL = progressive_rfx_get_band_l_count(level);
771 const size_t nBandH = progressive_rfx_get_band_h_count(level);
772 size_t offset = 0;
773
774 HL = &buffer[offset];
775 offset += (nBandH * nBandL);
776 LH = &buffer[offset];
777 offset += (nBandL * nBandH);
778 HH = &buffer[offset];
779 offset += (nBandH * nBandH);
780 LL = &buffer[offset];
781 nDstStepX = (nBandL + nBandH);
782 nDstStepY = (nBandL + nBandH);
783 offset = 0;
784 L = &temp[offset];
785 offset += (nBandL * nDstStepX);
786 H = &temp[offset];
787 LLx = &buffer[0];
788
789 /* horizontal (LL + HL -> L) */
790 progressive_rfx_idwt_x(LL, nBandL, HL, nBandH, L, nDstStepX, nBandL, nBandH, nBandL);
791
792 /* horizontal (LH + HH -> H) */
793 progressive_rfx_idwt_x(LH, nBandL, HH, nBandH, H, nDstStepX, nBandL, nBandH, nBandH);
794
795 /* vertical (L + H -> LL) */
796 progressive_rfx_idwt_y(L, nDstStepX, H, nDstStepX, LLx, nDstStepY, nBandL, nBandH,
797 nBandL + nBandH);
798}
799
800void rfx_dwt_2d_extrapolate_decode(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer)
801{
802 WINPR_ASSERT(buffer);
803 WINPR_ASSERT(dwt_buffer);
804 progressive_rfx_dwt_2d_decode_block(&buffer[3807], dwt_buffer, 3);
805 progressive_rfx_dwt_2d_decode_block(&buffer[3007], dwt_buffer, 2);
806 progressive_rfx_dwt_2d_decode_block(&buffer[0], dwt_buffer, 1);
807}
808
809static inline int progressive_rfx_dwt_2d_decode(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
810 INT16* WINPR_RESTRICT buffer,
811 INT16* WINPR_RESTRICT current, BOOL coeffDiff,
812 BOOL extrapolate, BOOL reverse)
813{
814 const primitives_t* prims = primitives_get();
815
816 if (!progressive || !buffer || !current)
817 return -1;
818
819 const uint32_t belements = 4096;
820 const uint32_t bsize = belements * sizeof(INT16);
821 if (reverse)
822 memcpy(buffer, current, bsize);
823 else if (!coeffDiff)
824 memcpy(current, buffer, bsize);
825 else
826 {
827 const pstatus_t rc = prims->add_16s_inplace(buffer, current, belements);
828 if (rc != PRIMITIVES_SUCCESS)
829 return -1;
830 }
831
832 INT16* temp = (INT16*)BufferPool_Take(progressive->bufferPool, -1); /* DWT buffer */
833
834 if (!temp)
835 return -2;
836
837 if (!extrapolate)
838 {
839 progressive->rfx_context->dwt_2d_decode(buffer, temp);
840 }
841 else
842 {
843 WINPR_ASSERT(progressive->rfx_context->dwt_2d_extrapolate_decode);
844 progressive->rfx_context->dwt_2d_extrapolate_decode(buffer, temp);
845 }
846 BufferPool_Return(progressive->bufferPool, temp);
847 return 1;
848}
849
850static inline BOOL progressive_rfx_decode_block(const primitives_t* prims,
851 INT16* WINPR_RESTRICT buffer, UINT32 length,
852 UINT32 shift)
853{
854 if (shift == 0)
855 return TRUE;
856
857 return prims->lShiftC_16s_inplace(buffer, shift, length) == PRIMITIVES_SUCCESS;
858}
859
860static inline int
861progressive_rfx_decode_component(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
862 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT shift,
863 const BYTE* WINPR_RESTRICT data, UINT32 length,
864 INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT current,
865 INT16* WINPR_RESTRICT sign, BOOL coeffDiff,
866 WINPR_ATTR_UNUSED BOOL subbandDiff, BOOL extrapolate)
867{
868 int status = 0;
869 const primitives_t* prims = primitives_get();
870
871 status = progressive->rfx_context->rlgr_decode(RLGR1, data, length, buffer, 4096);
872
873 if (status < 0)
874 return status;
875
876 CopyMemory(sign, buffer, 4096ULL * 2ULL);
877 if (!extrapolate)
878 {
879 rfx_differential_decode(buffer + 4032, 64);
880 if (!progressive_rfx_decode_block(prims, &buffer[0], 1024, shift->HL1)) /* HL1 */
881 return -1;
882 if (!progressive_rfx_decode_block(prims, &buffer[1024], 1024, shift->LH1)) /* LH1 */
883 return -1;
884 if (!progressive_rfx_decode_block(prims, &buffer[2048], 1024, shift->HH1)) /* HH1 */
885 return -1;
886 if (!progressive_rfx_decode_block(prims, &buffer[3072], 256, shift->HL2)) /* HL2 */
887 return -1;
888 if (!progressive_rfx_decode_block(prims, &buffer[3328], 256, shift->LH2)) /* LH2 */
889 return -1;
890 if (!progressive_rfx_decode_block(prims, &buffer[3584], 256, shift->HH2)) /* HH2 */
891 return -1;
892 if (!progressive_rfx_decode_block(prims, &buffer[3840], 64, shift->HL3)) /* HL3 */
893 return -1;
894 if (!progressive_rfx_decode_block(prims, &buffer[3904], 64, shift->LH3)) /* LH3 */
895 return -1;
896 if (!progressive_rfx_decode_block(prims, &buffer[3968], 64, shift->HH3)) /* HH3 */
897 return -1;
898 if (!progressive_rfx_decode_block(prims, &buffer[4032], 64, shift->LL3)) /* LL3 */
899 return -1;
900 }
901 else
902 {
903 if (!progressive_rfx_decode_block(prims, &buffer[0], 1023, shift->HL1)) /* HL1 */
904 return -1;
905 if (!progressive_rfx_decode_block(prims, &buffer[1023], 1023, shift->LH1)) /* LH1 */
906 return -1;
907 if (!progressive_rfx_decode_block(prims, &buffer[2046], 961, shift->HH1)) /* HH1 */
908 return -1;
909 if (!progressive_rfx_decode_block(prims, &buffer[3007], 272, shift->HL2)) /* HL2 */
910 return -1;
911 if (!progressive_rfx_decode_block(prims, &buffer[3279], 272, shift->LH2)) /* LH2 */
912 return -1;
913 if (!progressive_rfx_decode_block(prims, &buffer[3551], 256, shift->HH2)) /* HH2 */
914 return -1;
915 if (!progressive_rfx_decode_block(prims, &buffer[3807], 72, shift->HL3)) /* HL3 */
916 return -1;
917 if (!progressive_rfx_decode_block(prims, &buffer[3879], 72, shift->LH3)) /* LH3 */
918 return -1;
919 if (!progressive_rfx_decode_block(prims, &buffer[3951], 64, shift->HH3)) /* HH3 */
920 return -1;
921 rfx_differential_decode(&buffer[4015], 81); /* LL3 */
922 if (!progressive_rfx_decode_block(prims, &buffer[4015], 81, shift->LL3)) /* LL3 */
923 return -1;
924 }
925 return progressive_rfx_dwt_2d_decode(progressive, buffer, current, coeffDiff, extrapolate,
926 FALSE);
927}
928
929static inline int
930progressive_decompress_tile_first(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
931 RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile,
932 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
933 const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
934{
935 int rc = 0;
936 BOOL diff = 0;
937 BOOL sub = 0;
938 BOOL extrapolate = 0;
939 BYTE* pBuffer = nullptr;
940 INT16* pSign[3];
941 INT16* pSrcDst[3];
942 INT16* pCurrent[3];
943 RFX_COMPONENT_CODEC_QUANT shiftY = WINPR_C_ARRAY_INIT;
944 RFX_COMPONENT_CODEC_QUANT shiftCb = WINPR_C_ARRAY_INIT;
945 RFX_COMPONENT_CODEC_QUANT shiftCr = WINPR_C_ARRAY_INIT;
946 RFX_COMPONENT_CODEC_QUANT* quantY = nullptr;
947 RFX_COMPONENT_CODEC_QUANT* quantCb = nullptr;
948 RFX_COMPONENT_CODEC_QUANT* quantCr = nullptr;
949 RFX_COMPONENT_CODEC_QUANT* quantProgY = nullptr;
950 RFX_COMPONENT_CODEC_QUANT* quantProgCb = nullptr;
951 RFX_COMPONENT_CODEC_QUANT* quantProgCr = nullptr;
952 RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal = nullptr;
953 static const prim_size_t roi_64x64 = { 64, 64 };
954 const primitives_t* prims = primitives_get();
955
956 tile->pass = 1;
957 diff = tile->flags & RFX_TILE_DIFFERENCE;
958 sub = context->flags & RFX_SUBBAND_DIFFING;
959 extrapolate = region->flags & RFX_DWT_REDUCE_EXTRAPOLATE;
960
961#if defined(WITH_DEBUG_CODECS)
962 WLog_Print(progressive->log, WLOG_DEBUG,
963 "ProgressiveTile%s: quantIdx Y: %" PRIu8 " Cb: %" PRIu8 " Cr: %" PRIu8
964 " xIdx: %" PRIu16 " yIdx: %" PRIu16 " flags: 0x%02" PRIX8 " quality: %" PRIu8
965 " yLen: %" PRIu16 " cbLen: %" PRIu16 " crLen: %" PRIu16 " tailLen: %" PRIu16 "",
966 (tile->blockType == PROGRESSIVE_WBT_TILE_FIRST) ? "First" : "Simple",
967 tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx, tile->yIdx,
968 tile->flags, tile->quality, tile->yLen, tile->cbLen, tile->crLen, tile->tailLen);
969#endif
970
971 if (tile->quantIdxY >= region->numQuant)
972 {
973 WLog_ERR(TAG, "quantIdxY %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxY, region->numQuant);
974 return -1;
975 }
976
977 quantY = &(region->quantVals[tile->quantIdxY]);
978
979 if (tile->quantIdxCb >= region->numQuant)
980 {
981 WLog_ERR(TAG, "quantIdxCb %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCb,
982 region->numQuant);
983 return -1;
984 }
985
986 quantCb = &(region->quantVals[tile->quantIdxCb]);
987
988 if (tile->quantIdxCr >= region->numQuant)
989 {
990 WLog_ERR(TAG, "quantIdxCr %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCr,
991 region->numQuant);
992 return -1;
993 }
994
995 quantCr = &(region->quantVals[tile->quantIdxCr]);
996
997 if (tile->quality == 0xFF)
998 {
999 quantProgVal = &(progressive->quantProgValFull);
1000 }
1001 else
1002 {
1003 if (tile->quality >= region->numProgQuant)
1004 {
1005 WLog_ERR(TAG, "quality %" PRIu8 " > numProgQuant %" PRIu8, tile->quality,
1006 region->numProgQuant);
1007 return -1;
1008 }
1009
1010 quantProgVal = &(region->quantProgVals[tile->quality]);
1011 }
1012
1013 quantProgY = &(quantProgVal->yQuantValues);
1014 quantProgCb = &(quantProgVal->cbQuantValues);
1015 quantProgCr = &(quantProgVal->crQuantValues);
1016
1017 tile->yQuant = *quantY;
1018 tile->cbQuant = *quantCb;
1019 tile->crQuant = *quantCr;
1020 tile->yProgQuant = *quantProgY;
1021 tile->cbProgQuant = *quantProgCb;
1022 tile->crProgQuant = *quantProgCr;
1023
1024 progressive_rfx_quant_add(quantY, quantProgY, &(tile->yBitPos));
1025 progressive_rfx_quant_add(quantCb, quantProgCb, &(tile->cbBitPos));
1026 progressive_rfx_quant_add(quantCr, quantProgCr, &(tile->crBitPos));
1027 progressive_rfx_quant_add(quantY, quantProgY, &shiftY);
1028 if (!progressive_rfx_quant_lsub(&shiftY, 1)) /* -6 + 5 = -1 */
1029 goto fail;
1030 progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);
1031 if (!progressive_rfx_quant_lsub(&shiftCb, 1)) /* -6 + 5 = -1 */
1032 goto fail;
1033 progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);
1034 if (!progressive_rfx_quant_lsub(&shiftCr, 1)) /* -6 + 5 = -1 */
1035 goto fail;
1036
1037 pSign[0] = (INT16*)((&tile->sign[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1038 pSign[1] = (INT16*)((&tile->sign[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1039 pSign[2] = (INT16*)((&tile->sign[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1040
1041 pCurrent[0] = (INT16*)((&tile->current[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1042 pCurrent[1] = (INT16*)((&tile->current[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1043 pCurrent[2] = (INT16*)((&tile->current[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1044
1045 pBuffer = (BYTE*)BufferPool_Take(progressive->bufferPool, -1);
1046 pSrcDst[0] = (INT16*)((&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1047 pSrcDst[1] = (INT16*)((&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1048 pSrcDst[2] = (INT16*)((&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1049
1050 rc = progressive_rfx_decode_component(progressive, &shiftY, tile->yData, tile->yLen, pSrcDst[0],
1051 pCurrent[0], pSign[0], diff, sub, extrapolate); /* Y */
1052 if (rc < 0)
1053 goto fail;
1054 rc = progressive_rfx_decode_component(progressive, &shiftCb, tile->cbData, tile->cbLen,
1055 pSrcDst[1], pCurrent[1], pSign[1], diff, sub,
1056 extrapolate); /* Cb */
1057 if (rc < 0)
1058 goto fail;
1059 rc = progressive_rfx_decode_component(progressive, &shiftCr, tile->crData, tile->crLen,
1060 pSrcDst[2], pCurrent[2], pSign[2], diff, sub,
1061 extrapolate); /* Cr */
1062 if (rc < 0)
1063 goto fail;
1064
1065 {
1066 const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
1067 rc = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride,
1068 progressive->format, &roi_64x64);
1069 }
1070fail:
1071 BufferPool_Return(progressive->bufferPool, pBuffer);
1072 return rc;
1073}
1074
1075static inline INT16 progressive_rfx_srl_read(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state,
1076 UINT32 numBits)
1077{
1078 WINPR_ASSERT(state);
1079
1080 wBitStream* bs = state->srl;
1081 WINPR_ASSERT(bs);
1082
1083 if (state->nz)
1084 {
1085 state->nz--;
1086 return 0;
1087 }
1088
1089 const UINT32 k = state->kp / 8;
1090
1091 if (!state->mode)
1092 {
1093 /* zero encoding */
1094 const UINT32 bit = (bs->accumulator & 0x80000000) ? 1 : 0;
1095 BitStream_Shift(bs, 1);
1096
1097 if (!bit)
1098 {
1099 /* '0' bit, nz >= (1 << k), nz = (1 << k) */
1100 state->nz = (1 << k);
1101 state->kp += 4;
1102
1103 if (state->kp > 80)
1104 state->kp = 80;
1105
1106 state->nz--;
1107 return 0;
1108 }
1109 else
1110 {
1111 /* '1' bit, nz < (1 << k), nz = next k bits */
1112 state->nz = 0;
1113 state->mode = 1; /* unary encoding is next */
1114
1115 if (k)
1116 {
1117 bs->mask = ((1u << k) - 1);
1118 state->nz =
1119 WINPR_ASSERTING_INT_CAST(int16_t, ((bs->accumulator >> (32u - k)) & bs->mask));
1120 BitStream_Shift(bs, k);
1121 }
1122
1123 if (state->nz)
1124 {
1125 state->nz--;
1126 return 0;
1127 }
1128 }
1129 }
1130
1131 state->mode = 0; /* zero encoding is next */
1132 /* unary encoding */
1133 /* read sign bit */
1134 const UINT32 sign = (bs->accumulator & 0x80000000) ? 1 : 0;
1135 BitStream_Shift(bs, 1);
1136
1137 if (state->kp < 6)
1138 state->kp = 0;
1139 else
1140 state->kp -= 6;
1141
1142 if (numBits == 1)
1143 return sign ? -1 : 1;
1144
1145 UINT32 mag = 1;
1146 const UINT32 max = (1u << numBits) - 1;
1147
1148 while (mag < max)
1149 {
1150 const UINT32 bit = (bs->accumulator & 0x80000000) ? 1 : 0;
1151 BitStream_Shift(bs, 1);
1152
1153 if (bit)
1154 break;
1155
1156 mag++;
1157 }
1158
1159 if (mag > INT16_MAX)
1160 mag = INT16_MAX;
1161 return (INT16)(sign ? -1 * (int)mag : (INT16)mag);
1162}
1163
1164static inline int
1165progressive_rfx_upgrade_state_finish(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state)
1166{
1167 UINT32 pad = 0;
1168 wBitStream* srl = nullptr;
1169 wBitStream* raw = nullptr;
1170 if (!state)
1171 return -1;
1172
1173 srl = state->srl;
1174 raw = state->raw;
1175 /* Read trailing bits from RAW/SRL bit streams */
1176 pad = (raw->position % 8) ? (8 - (raw->position % 8)) : 0;
1177
1178 if (pad)
1179 BitStream_Shift(raw, pad);
1180
1181 pad = (srl->position % 8) ? (8 - (srl->position % 8)) : 0;
1182
1183 if (pad)
1184 BitStream_Shift(srl, pad);
1185
1186 if (BitStream_GetRemainingLength(srl) == 8)
1187 BitStream_Shift(srl, 8);
1188
1189 return 1;
1190}
1191
1192static inline int16_t rawShift(wBitStream* raw, UINT32 numBits)
1193{
1194 WINPR_ASSERT(raw);
1195 WINPR_ASSERT(numBits > 0);
1196
1197 raw->mask = ((1u << numBits) - 1);
1198 const int16_t input = (int16_t)((raw->accumulator >> (32 - numBits)) & raw->mask);
1199 BitStream_Shift(raw, numBits);
1200 return input;
1201}
1202
1203static inline int progressive_rfx_upgrade_block(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state,
1204 INT16* WINPR_RESTRICT buffer,
1205 INT16* WINPR_RESTRICT sign, UINT32 length,
1206 UINT32 shift, WINPR_ATTR_UNUSED UINT32 bitPos,
1207 UINT32 numBits)
1208{
1209 if (numBits < 1)
1210 return 1;
1211
1212 wBitStream* raw = state->raw;
1213 int32_t input = 0;
1214
1215 if (!state->nonLL)
1216 {
1217 for (UINT32 index = 0; index < length; index++)
1218 {
1219 input = rawShift(raw, numBits);
1220
1221 const int32_t shifted = input << shift;
1222 const int32_t val = buffer[index] + shifted;
1223 const int16_t ival = WINPR_ASSERTING_INT_CAST(int16_t, val);
1224 buffer[index] = ival;
1225 }
1226
1227 return 1;
1228 }
1229
1230 for (UINT32 index = 0; index < length; index++)
1231 {
1232 if (sign[index] > 0)
1233 {
1234 /* sign > 0, read from raw */
1235 input = rawShift(raw, numBits);
1236 }
1237 else if (sign[index] < 0)
1238 {
1239 /* sign < 0, read from raw */
1240 input = rawShift(raw, numBits);
1241 input *= -1;
1242 }
1243 else
1244 {
1245 /* sign == 0, read from srl */
1246 input = progressive_rfx_srl_read(state, numBits);
1247 sign[index] = WINPR_ASSERTING_INT_CAST(int16_t, input);
1248 }
1249
1250 const int32_t val = input << shift;
1251 const int32_t ival = buffer[index] + val;
1252 buffer[index] = WINPR_ASSERTING_INT_CAST(INT16, ival);
1253 }
1254
1255 return 1;
1256}
1257
1258static inline int progressive_rfx_upgrade_component(
1259 PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1260 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT shift,
1261 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT bitPos,
1262 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT numBits, INT16* WINPR_RESTRICT buffer,
1263 INT16* WINPR_RESTRICT current, INT16* WINPR_RESTRICT sign, const BYTE* WINPR_RESTRICT srlData,
1264 UINT32 srlLen, const BYTE* WINPR_RESTRICT rawData, UINT32 rawLen, BOOL coeffDiff,
1265 WINPR_ATTR_UNUSED BOOL subbandDiff, BOOL extrapolate)
1266{
1267 int rc = 0;
1268 wBitStream s_srl = WINPR_C_ARRAY_INIT;
1269 wBitStream s_raw = WINPR_C_ARRAY_INIT;
1270 RFX_PROGRESSIVE_UPGRADE_STATE state = WINPR_C_ARRAY_INIT;
1271
1272 state.kp = 8;
1273 state.mode = 0;
1274 state.srl = &s_srl;
1275 state.raw = &s_raw;
1276 BitStream_Attach(state.srl, srlData, srlLen);
1277 BitStream_Fetch(state.srl);
1278 BitStream_Attach(state.raw, rawData, rawLen);
1279 BitStream_Fetch(state.raw);
1280
1281 state.nonLL = TRUE;
1282 rc = progressive_rfx_upgrade_block(&state, &current[0], &sign[0], 1023, shift->HL1, bitPos->HL1,
1283 numBits->HL1); /* HL1 */
1284 if (rc < 0)
1285 return rc;
1286 rc = progressive_rfx_upgrade_block(&state, &current[1023], &sign[1023], 1023, shift->LH1,
1287 bitPos->LH1, numBits->LH1); /* LH1 */
1288 if (rc < 0)
1289 return rc;
1290 rc = progressive_rfx_upgrade_block(&state, &current[2046], &sign[2046], 961, shift->HH1,
1291 bitPos->HH1, numBits->HH1); /* HH1 */
1292 if (rc < 0)
1293 return rc;
1294 rc = progressive_rfx_upgrade_block(&state, &current[3007], &sign[3007], 272, shift->HL2,
1295 bitPos->HL2, numBits->HL2); /* HL2 */
1296 if (rc < 0)
1297 return rc;
1298 rc = progressive_rfx_upgrade_block(&state, &current[3279], &sign[3279], 272, shift->LH2,
1299 bitPos->LH2, numBits->LH2); /* LH2 */
1300 if (rc < 0)
1301 return rc;
1302 rc = progressive_rfx_upgrade_block(&state, &current[3551], &sign[3551], 256, shift->HH2,
1303 bitPos->HH2, numBits->HH2); /* HH2 */
1304 if (rc < 0)
1305 return rc;
1306 rc = progressive_rfx_upgrade_block(&state, &current[3807], &sign[3807], 72, shift->HL3,
1307 bitPos->HL3, numBits->HL3); /* HL3 */
1308 if (rc < 0)
1309 return rc;
1310 rc = progressive_rfx_upgrade_block(&state, &current[3879], &sign[3879], 72, shift->LH3,
1311 bitPos->LH3, numBits->LH3); /* LH3 */
1312 if (rc < 0)
1313 return rc;
1314 rc = progressive_rfx_upgrade_block(&state, &current[3951], &sign[3951], 64, shift->HH3,
1315 bitPos->HH3, numBits->HH3); /* HH3 */
1316 if (rc < 0)
1317 return rc;
1318
1319 state.nonLL = FALSE;
1320 rc = progressive_rfx_upgrade_block(&state, &current[4015], &sign[4015], 81, shift->LL3,
1321 bitPos->LL3, numBits->LL3); /* LL3 */
1322 if (rc < 0)
1323 return rc;
1324 rc = progressive_rfx_upgrade_state_finish(&state);
1325 if (rc < 0)
1326 return rc;
1327 return progressive_rfx_dwt_2d_decode(progressive, buffer, current, coeffDiff, extrapolate,
1328 TRUE);
1329}
1330
1331static inline int
1332progressive_decompress_tile_upgrade(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1333 RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile,
1334 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1335 const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1336{
1337 int status = 0;
1338 BOOL coeffDiff = 0;
1339 BOOL sub = 0;
1340 BOOL extrapolate = 0;
1341 BYTE* pBuffer = nullptr;
1342 INT16* pSign[3] = WINPR_C_ARRAY_INIT;
1343 INT16* pSrcDst[3] = WINPR_C_ARRAY_INIT;
1344 INT16* pCurrent[3] = WINPR_C_ARRAY_INIT;
1345 RFX_COMPONENT_CODEC_QUANT shiftY = WINPR_C_ARRAY_INIT;
1346 RFX_COMPONENT_CODEC_QUANT shiftCb = WINPR_C_ARRAY_INIT;
1347 RFX_COMPONENT_CODEC_QUANT shiftCr = WINPR_C_ARRAY_INIT;
1348 RFX_COMPONENT_CODEC_QUANT yBitPos = WINPR_C_ARRAY_INIT;
1349 RFX_COMPONENT_CODEC_QUANT cbBitPos = WINPR_C_ARRAY_INIT;
1350 RFX_COMPONENT_CODEC_QUANT crBitPos = WINPR_C_ARRAY_INIT;
1351 RFX_COMPONENT_CODEC_QUANT yNumBits = WINPR_C_ARRAY_INIT;
1352 RFX_COMPONENT_CODEC_QUANT cbNumBits = WINPR_C_ARRAY_INIT;
1353 RFX_COMPONENT_CODEC_QUANT crNumBits = WINPR_C_ARRAY_INIT;
1354 RFX_COMPONENT_CODEC_QUANT* quantY = nullptr;
1355 RFX_COMPONENT_CODEC_QUANT* quantCb = nullptr;
1356 RFX_COMPONENT_CODEC_QUANT* quantCr = nullptr;
1357 RFX_COMPONENT_CODEC_QUANT* quantProgY = nullptr;
1358 RFX_COMPONENT_CODEC_QUANT* quantProgCb = nullptr;
1359 RFX_COMPONENT_CODEC_QUANT* quantProgCr = nullptr;
1360 RFX_PROGRESSIVE_CODEC_QUANT* quantProg = nullptr;
1361 static const prim_size_t roi_64x64 = { 64, 64 };
1362 const primitives_t* prims = primitives_get();
1363
1364 coeffDiff = tile->flags & RFX_TILE_DIFFERENCE;
1365 sub = context->flags & RFX_SUBBAND_DIFFING;
1366 extrapolate = region->flags & RFX_DWT_REDUCE_EXTRAPOLATE;
1367
1368 tile->pass++;
1369
1370#if defined(WITH_DEBUG_CODECS)
1371 WLog_Print(progressive->log, WLOG_DEBUG,
1372 "ProgressiveTileUpgrade: pass: %" PRIu16 " quantIdx Y: %" PRIu8 " Cb: %" PRIu8
1373 " Cr: %" PRIu8 " xIdx: %" PRIu16 " yIdx: %" PRIu16 " quality: %" PRIu8
1374 " ySrlLen: %" PRIu16 " yRawLen: %" PRIu16 " cbSrlLen: %" PRIu16 " cbRawLen: %" PRIu16
1375 " crSrlLen: %" PRIu16 " crRawLen: %" PRIu16 "",
1376 tile->pass, tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx,
1377 tile->yIdx, tile->quality, tile->ySrlLen, tile->yRawLen, tile->cbSrlLen,
1378 tile->cbRawLen, tile->crSrlLen, tile->crRawLen);
1379#endif
1380
1381 if (tile->quantIdxY >= region->numQuant)
1382 {
1383 WLog_ERR(TAG, "quantIdxY %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxY, region->numQuant);
1384 return -1;
1385 }
1386
1387 quantY = &(region->quantVals[tile->quantIdxY]);
1388
1389 if (tile->quantIdxCb >= region->numQuant)
1390 {
1391 WLog_ERR(TAG, "quantIdxCb %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCb,
1392 region->numQuant);
1393 return -1;
1394 }
1395
1396 quantCb = &(region->quantVals[tile->quantIdxCb]);
1397
1398 if (tile->quantIdxCr >= region->numQuant)
1399 {
1400 WLog_ERR(TAG, "quantIdxCr %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCr,
1401 region->numQuant);
1402 return -1;
1403 }
1404
1405 quantCr = &(region->quantVals[tile->quantIdxCr]);
1406
1407 if (tile->quality == 0xFF)
1408 {
1409 quantProg = &(progressive->quantProgValFull);
1410 }
1411 else
1412 {
1413 if (tile->quality >= region->numProgQuant)
1414 {
1415 WLog_ERR(TAG, "quality %" PRIu8 " > numProgQuant %" PRIu8, tile->quality,
1416 region->numProgQuant);
1417 return -1;
1418 }
1419
1420 quantProg = &(region->quantProgVals[tile->quality]);
1421 }
1422
1423 quantProgY = &(quantProg->yQuantValues);
1424 quantProgCb = &(quantProg->cbQuantValues);
1425 quantProgCr = &(quantProg->crQuantValues);
1426
1427 if (!progressive_rfx_quant_cmp_equal(quantY, &(tile->yQuant)))
1428 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantY has changed!");
1429
1430 if (!progressive_rfx_quant_cmp_equal(quantCb, &(tile->cbQuant)))
1431 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCb has changed!");
1432
1433 if (!progressive_rfx_quant_cmp_equal(quantCr, &(tile->crQuant)))
1434 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCr has changed!");
1435
1436 if (!(context->flags & RFX_SUBBAND_DIFFING))
1437 WLog_WARN(TAG, "PROGRESSIVE_BLOCK_CONTEXT::flags & RFX_SUBBAND_DIFFING not set");
1438
1439 progressive_rfx_quant_add(quantY, quantProgY, &yBitPos);
1440 progressive_rfx_quant_add(quantCb, quantProgCb, &cbBitPos);
1441 progressive_rfx_quant_add(quantCr, quantProgCr, &crBitPos);
1442 if (!progressive_rfx_quant_sub(&(tile->yBitPos), &yBitPos, &yNumBits))
1443 goto fail;
1444 if (!progressive_rfx_quant_sub(&(tile->cbBitPos), &cbBitPos, &cbNumBits))
1445 goto fail;
1446 if (!progressive_rfx_quant_sub(&(tile->crBitPos), &crBitPos, &crNumBits))
1447 goto fail;
1448 progressive_rfx_quant_add(quantY, quantProgY, &shiftY);
1449 if (!progressive_rfx_quant_lsub(&shiftY, 1)) /* -6 + 5 = -1 */
1450 goto fail;
1451 progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);
1452 if (!progressive_rfx_quant_lsub(&shiftCb, 1)) /* -6 + 5 = -1 */
1453 goto fail;
1454 progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);
1455 if (!progressive_rfx_quant_lsub(&shiftCr, 1)) /* -6 + 5 = -1 */
1456 goto fail;
1457
1458 tile->yBitPos = yBitPos;
1459 tile->cbBitPos = cbBitPos;
1460 tile->crBitPos = crBitPos;
1461 tile->yQuant = *quantY;
1462 tile->cbQuant = *quantCb;
1463 tile->crQuant = *quantCr;
1464 tile->yProgQuant = *quantProgY;
1465 tile->cbProgQuant = *quantProgCb;
1466 tile->crProgQuant = *quantProgCr;
1467
1468 pSign[0] = (INT16*)((&tile->sign[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1469 pSign[1] = (INT16*)((&tile->sign[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1470 pSign[2] = (INT16*)((&tile->sign[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1471
1472 pCurrent[0] = (INT16*)((&tile->current[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1473 pCurrent[1] = (INT16*)((&tile->current[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1474 pCurrent[2] = (INT16*)((&tile->current[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1475
1476 pBuffer = (BYTE*)BufferPool_Take(progressive->bufferPool, -1);
1477 pSrcDst[0] = (INT16*)((&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1478 pSrcDst[1] = (INT16*)((&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1479 pSrcDst[2] = (INT16*)((&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1480
1481 status = progressive_rfx_upgrade_component(progressive, &shiftY, quantProgY, &yNumBits,
1482 pSrcDst[0], pCurrent[0], pSign[0], tile->ySrlData,
1483 tile->ySrlLen, tile->yRawData, tile->yRawLen,
1484 coeffDiff, sub, extrapolate); /* Y */
1485
1486 if (status < 0)
1487 goto fail;
1488
1489 status = progressive_rfx_upgrade_component(progressive, &shiftCb, quantProgCb, &cbNumBits,
1490 pSrcDst[1], pCurrent[1], pSign[1], tile->cbSrlData,
1491 tile->cbSrlLen, tile->cbRawData, tile->cbRawLen,
1492 coeffDiff, sub, extrapolate); /* Cb */
1493
1494 if (status < 0)
1495 goto fail;
1496
1497 status = progressive_rfx_upgrade_component(progressive, &shiftCr, quantProgCr, &crNumBits,
1498 pSrcDst[2], pCurrent[2], pSign[2], tile->crSrlData,
1499 tile->crSrlLen, tile->crRawData, tile->crRawLen,
1500 coeffDiff, sub, extrapolate); /* Cr */
1501
1502 if (status < 0)
1503 goto fail;
1504
1505 {
1506 const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
1507 status = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride,
1508 progressive->format, &roi_64x64);
1509 }
1510fail:
1511 BufferPool_Return(progressive->bufferPool, pBuffer);
1512 return status;
1513}
1514
1515static inline BOOL progressive_tile_read_upgrade(
1516 PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s, UINT16 blockType,
1517 UINT32 blockLen, PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
1518 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1519 WINPR_ATTR_UNUSED const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1520{
1521 RFX_PROGRESSIVE_TILE tile = WINPR_C_ARRAY_INIT;
1522 const size_t expect = 20;
1523
1524 if (!Stream_CheckAndLogRequiredLength(TAG, s, expect))
1525 return FALSE;
1526
1527 tile.blockType = blockType;
1528 tile.blockLen = blockLen;
1529 tile.flags = 0;
1530
1531 Stream_Read_UINT8(s, tile.quantIdxY);
1532 Stream_Read_UINT8(s, tile.quantIdxCb);
1533 Stream_Read_UINT8(s, tile.quantIdxCr);
1534 Stream_Read_UINT16(s, tile.xIdx);
1535 Stream_Read_UINT16(s, tile.yIdx);
1536 Stream_Read_UINT8(s, tile.quality);
1537 Stream_Read_UINT16(s, tile.ySrlLen);
1538 Stream_Read_UINT16(s, tile.yRawLen);
1539 Stream_Read_UINT16(s, tile.cbSrlLen);
1540 Stream_Read_UINT16(s, tile.cbRawLen);
1541 Stream_Read_UINT16(s, tile.crSrlLen);
1542 Stream_Read_UINT16(s, tile.crRawLen);
1543
1544 tile.ySrlData = Stream_Pointer(s);
1545 if (!Stream_SafeSeek(s, tile.ySrlLen))
1546 {
1547 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.ySrlLen);
1548 return FALSE;
1549 }
1550
1551 tile.yRawData = Stream_Pointer(s);
1552 if (!Stream_SafeSeek(s, tile.yRawLen))
1553 {
1554 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.yRawLen);
1555 return FALSE;
1556 }
1557
1558 tile.cbSrlData = Stream_Pointer(s);
1559 if (!Stream_SafeSeek(s, tile.cbSrlLen))
1560 {
1561 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1562 tile.cbSrlLen);
1563 return FALSE;
1564 }
1565
1566 tile.cbRawData = Stream_Pointer(s);
1567 if (!Stream_SafeSeek(s, tile.cbRawLen))
1568 {
1569 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1570 tile.cbRawLen);
1571 return FALSE;
1572 }
1573
1574 tile.crSrlData = Stream_Pointer(s);
1575 if (!Stream_SafeSeek(s, tile.crSrlLen))
1576 {
1577 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1578 tile.crSrlLen);
1579 return FALSE;
1580 }
1581
1582 tile.crRawData = Stream_Pointer(s);
1583 if (!Stream_SafeSeek(s, tile.crRawLen))
1584 {
1585 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1586 tile.crRawLen);
1587 return FALSE;
1588 }
1589
1590 return progressive_surface_tile_replace(surface, region, &tile, TRUE);
1591}
1592
1593static inline BOOL
1594progressive_tile_read(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, BOOL simple,
1595 wStream* WINPR_RESTRICT s, UINT16 blockType, UINT32 blockLen,
1596 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
1597 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1598 WINPR_ATTR_UNUSED const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1599{
1600 RFX_PROGRESSIVE_TILE tile = WINPR_C_ARRAY_INIT;
1601 size_t expect = simple ? 16 : 17;
1602
1603 if (!Stream_CheckAndLogRequiredLength(TAG, s, expect))
1604 return FALSE;
1605
1606 tile.blockType = blockType;
1607 tile.blockLen = blockLen;
1608
1609 Stream_Read_UINT8(s, tile.quantIdxY);
1610 Stream_Read_UINT8(s, tile.quantIdxCb);
1611 Stream_Read_UINT8(s, tile.quantIdxCr);
1612 Stream_Read_UINT16(s, tile.xIdx);
1613 Stream_Read_UINT16(s, tile.yIdx);
1614 Stream_Read_UINT8(s, tile.flags);
1615
1616 if (!simple)
1617 Stream_Read_UINT8(s, tile.quality);
1618 else
1619 tile.quality = 0xFF;
1620 Stream_Read_UINT16(s, tile.yLen);
1621 Stream_Read_UINT16(s, tile.cbLen);
1622 Stream_Read_UINT16(s, tile.crLen);
1623 Stream_Read_UINT16(s, tile.tailLen);
1624
1625 tile.yData = Stream_Pointer(s);
1626 if (!Stream_SafeSeek(s, tile.yLen))
1627 {
1628 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.yLen);
1629 return FALSE;
1630 }
1631
1632 tile.cbData = Stream_Pointer(s);
1633 if (!Stream_SafeSeek(s, tile.cbLen))
1634 {
1635 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.cbLen);
1636 return FALSE;
1637 }
1638
1639 tile.crData = Stream_Pointer(s);
1640 if (!Stream_SafeSeek(s, tile.crLen))
1641 {
1642 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.crLen);
1643 return FALSE;
1644 }
1645
1646 tile.tailData = Stream_Pointer(s);
1647 if (!Stream_SafeSeek(s, tile.tailLen))
1648 {
1649 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.tailLen);
1650 return FALSE;
1651 }
1652
1653 return progressive_surface_tile_replace(surface, region, &tile, FALSE);
1654}
1655
1656static void CALLBACK progressive_process_tiles_tile_work_callback(PTP_CALLBACK_INSTANCE instance,
1657 void* context, PTP_WORK work)
1658{
1659 PROGRESSIVE_TILE_PROCESS_WORK_PARAM* param = (PROGRESSIVE_TILE_PROCESS_WORK_PARAM*)context;
1660
1661 WINPR_UNUSED(instance);
1662 WINPR_UNUSED(work);
1663
1664 switch (param->tile->blockType)
1665 {
1666 case PROGRESSIVE_WBT_TILE_SIMPLE:
1667 case PROGRESSIVE_WBT_TILE_FIRST:
1668 progressive_decompress_tile_first(param->progressive, param->tile, param->region,
1669 param->context);
1670 break;
1671
1672 case PROGRESSIVE_WBT_TILE_UPGRADE:
1673 progressive_decompress_tile_upgrade(param->progressive, param->tile, param->region,
1674 param->context);
1675 break;
1676 default:
1677 WLog_Print(param->progressive->log, WLOG_ERROR, "Invalid block type %04" PRIx16 " (%s)",
1678 param->tile->blockType,
1679 rfx_get_progressive_block_type_string(param->tile->blockType));
1680 break;
1681 }
1682}
1683
1684static inline SSIZE_T
1685progressive_process_tiles(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1686 wStream* WINPR_RESTRICT s,
1687 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1688 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
1689 const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1690{
1691 int status = 0;
1692 size_t end = 0;
1693 const size_t start = Stream_GetPosition(s);
1694 UINT16 blockType = 0;
1695 UINT32 blockLen = 0;
1696 UINT32 count = 0;
1697 UINT16 close_cnt = 0;
1698
1699 WINPR_ASSERT(progressive);
1700 WINPR_ASSERT(region);
1701
1702 if (!Stream_CheckAndLogRequiredLength(TAG, s, region->tileDataSize))
1703 return -1;
1704
1705 while ((Stream_GetRemainingLength(s) >= 6) &&
1706 (region->tileDataSize > (Stream_GetPosition(s) - start)))
1707 {
1708 const size_t pos = Stream_GetPosition(s);
1709
1710 Stream_Read_UINT16(s, blockType);
1711 Stream_Read_UINT32(s, blockLen);
1712
1713#if defined(WITH_DEBUG_CODECS)
1714 WLog_Print(progressive->log, WLOG_DEBUG, "%s",
1715 rfx_get_progressive_block_type_string(blockType));
1716#endif
1717
1718 if (blockLen < 6)
1719 {
1720 WLog_Print(progressive->log, WLOG_ERROR, "Expected >= %" PRIu32 " remaining %" PRIu32,
1721 6u, blockLen);
1722 return -1003;
1723 }
1724 if (!Stream_CheckAndLogRequiredLength(TAG, s, blockLen - 6))
1725 return -1003;
1726
1727 switch (blockType)
1728 {
1729 case PROGRESSIVE_WBT_TILE_SIMPLE:
1730 if (!progressive_tile_read(progressive, TRUE, s, blockType, blockLen, surface,
1731 region, context))
1732 return -1022;
1733 break;
1734
1735 case PROGRESSIVE_WBT_TILE_FIRST:
1736 if (!progressive_tile_read(progressive, FALSE, s, blockType, blockLen, surface,
1737 region, context))
1738 return -1027;
1739 break;
1740
1741 case PROGRESSIVE_WBT_TILE_UPGRADE:
1742 if (!progressive_tile_read_upgrade(progressive, s, blockType, blockLen, surface,
1743 region, context))
1744 return -1032;
1745 break;
1746 default:
1747 WLog_ERR(TAG, "Invalid block type %04" PRIx16 " (%s)", blockType,
1748 rfx_get_progressive_block_type_string(blockType));
1749 return -1039;
1750 }
1751
1752 size_t rem = Stream_GetPosition(s);
1753 if ((rem - pos) != blockLen)
1754 {
1755 WLog_Print(progressive->log, WLOG_ERROR,
1756 "Actual block read %" PRIuz " but expected %" PRIu32, rem - pos, blockLen);
1757 return -1040;
1758 }
1759 count++;
1760 }
1761
1762 end = Stream_GetPosition(s);
1763 if ((end - start) != region->tileDataSize)
1764 {
1765 WLog_Print(progressive->log, WLOG_ERROR,
1766 "Actual total blocks read %" PRIuz " but expected %" PRIu32, end - start,
1767 region->tileDataSize);
1768 return -1041;
1769 }
1770
1771 if (count != region->numTiles)
1772 {
1773 WLog_Print(progressive->log, WLOG_WARN,
1774 "numTiles inconsistency: actual: %" PRIu32 ", expected: %" PRIu16 "\n", count,
1775 region->numTiles);
1776 return -1044;
1777 }
1778
1779 for (UINT32 idx = 0; idx < region->numTiles; idx++)
1780 {
1781 RFX_PROGRESSIVE_TILE* tile = region->tiles[idx];
1782 PROGRESSIVE_TILE_PROCESS_WORK_PARAM* param = &progressive->params[idx];
1783 param->progressive = progressive;
1784 param->region = region;
1785 param->context = context;
1786 param->tile = tile;
1787
1788 if (progressive->rfx_context->priv->UseThreads)
1789 {
1790 progressive->work_objects[idx] = CreateThreadpoolWork(
1791 progressive_process_tiles_tile_work_callback, (void*)param, nullptr);
1792 if (!progressive->work_objects[idx])
1793 {
1794 WLog_Print(progressive->log, WLOG_ERROR,
1795 "Failed to create ThreadpoolWork for tile %" PRIu32, idx);
1796 status = -1;
1797 break;
1798 }
1799
1800 SubmitThreadpoolWork(progressive->work_objects[idx]);
1801
1802 close_cnt = WINPR_ASSERTING_INT_CAST(UINT16, idx + 1);
1803 }
1804 else
1805 {
1806 progressive_process_tiles_tile_work_callback(nullptr, param, nullptr);
1807 }
1808
1809 if (status < 0)
1810 {
1811 WLog_Print(progressive->log, WLOG_ERROR, "Failed to decompress %s at %" PRIu16,
1812 rfx_get_progressive_block_type_string(tile->blockType), idx);
1813 goto fail;
1814 }
1815 }
1816
1817 if (progressive->rfx_context->priv->UseThreads)
1818 {
1819 for (UINT32 idx = 0; idx < close_cnt; idx++)
1820 {
1821 WaitForThreadpoolWorkCallbacks(progressive->work_objects[idx], FALSE);
1822 CloseThreadpoolWork(progressive->work_objects[idx]);
1823 }
1824 }
1825
1826fail:
1827
1828 if (status < 0)
1829 return -1;
1830
1831 return (SSIZE_T)(end - start);
1832}
1833
1834static inline SSIZE_T progressive_wb_sync(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1835 wStream* WINPR_RESTRICT s, UINT16 blockType,
1836 UINT32 blockLen)
1837{
1838 const UINT32 magic = 0xCACCACCA;
1839 const UINT16 version = 0x0100;
1840 PROGRESSIVE_BLOCK_SYNC sync = WINPR_C_ARRAY_INIT;
1841
1842 sync.blockType = blockType;
1843 sync.blockLen = blockLen;
1844
1845 if (sync.blockLen != 12)
1846 {
1847 WLog_Print(progressive->log, WLOG_ERROR,
1848 "PROGRESSIVE_BLOCK_SYNC::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
1849 sync.blockLen, 12u);
1850 return -1005;
1851 }
1852
1853 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
1854 return -1004;
1855
1856#if defined(WITH_DEBUG_CODECS)
1857 WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveSync");
1858#endif
1859
1860 Stream_Read_UINT32(s, sync.magic);
1861 Stream_Read_UINT16(s, sync.version);
1862
1863 if (sync.magic != magic)
1864 {
1865 WLog_Print(progressive->log, WLOG_ERROR,
1866 "PROGRESSIVE_BLOCK_SYNC::magic = 0x%08" PRIx32 " != 0x%08" PRIx32, sync.magic,
1867 magic);
1868 return -1005;
1869 }
1870
1871 if (sync.version != 0x0100)
1872 {
1873 WLog_Print(progressive->log, WLOG_ERROR,
1874 "PROGRESSIVE_BLOCK_SYNC::version = 0x%04" PRIx16 " != 0x%04" PRIu16,
1875 sync.version, version);
1876 return -1006;
1877 }
1878
1879 if ((progressive->state & FLAG_WBT_SYNC) != 0)
1880 WLog_WARN(TAG, "Duplicate PROGRESSIVE_BLOCK_SYNC, ignoring");
1881
1882 progressive->state |= FLAG_WBT_SYNC;
1883 return 0;
1884}
1885
1886static inline SSIZE_T progressive_wb_frame_begin(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1887 wStream* WINPR_RESTRICT s, UINT16 blockType,
1888 UINT32 blockLen)
1889{
1890 PROGRESSIVE_BLOCK_FRAME_BEGIN frameBegin = WINPR_C_ARRAY_INIT;
1891
1892 frameBegin.blockType = blockType;
1893 frameBegin.blockLen = blockLen;
1894
1895 if (frameBegin.blockLen != 12)
1896 {
1897 WLog_Print(progressive->log, WLOG_ERROR,
1898 " RFX_PROGRESSIVE_FRAME_BEGIN::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
1899 frameBegin.blockLen, 12u);
1900 return -1005;
1901 }
1902
1903 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
1904 return -1007;
1905
1906 Stream_Read_UINT32(s, frameBegin.frameIndex);
1907 Stream_Read_UINT16(s, frameBegin.regionCount);
1908
1909#if defined(WITH_DEBUG_CODECS)
1910 WLog_Print(progressive->log, WLOG_DEBUG,
1911 "ProgressiveFrameBegin: frameIndex: %" PRIu32 " regionCount: %" PRIu16 "",
1912 frameBegin.frameIndex, frameBegin.regionCount);
1913#endif
1914
1921 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) != 0)
1922 {
1923 WLog_ERR(TAG, "Duplicate RFX_PROGRESSIVE_FRAME_BEGIN in stream, this is not allowed!");
1924 return -1008;
1925 }
1926
1927 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
1928 {
1929 WLog_ERR(TAG, "RFX_PROGRESSIVE_FRAME_BEGIN after RFX_PROGRESSIVE_FRAME_END in stream, this "
1930 "is not allowed!");
1931 return -1008;
1932 }
1933
1934 progressive->state |= FLAG_WBT_FRAME_BEGIN;
1935 return 0;
1936}
1937
1938static inline SSIZE_T progressive_wb_frame_end(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1939 wStream* WINPR_RESTRICT s, UINT16 blockType,
1940 UINT32 blockLen)
1941{
1942 PROGRESSIVE_BLOCK_FRAME_END frameEnd = WINPR_C_ARRAY_INIT;
1943
1944 frameEnd.blockType = blockType;
1945 frameEnd.blockLen = blockLen;
1946
1947 if (frameEnd.blockLen != 6)
1948 {
1949 WLog_Print(progressive->log, WLOG_ERROR,
1950 " RFX_PROGRESSIVE_FRAME_END::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
1951 frameEnd.blockLen, 6u);
1952 return -1005;
1953 }
1954
1955 if (Stream_GetRemainingLength(s) != 0)
1956 {
1957 WLog_Print(progressive->log, WLOG_ERROR,
1958 "ProgressiveFrameEnd short %" PRIuz ", expected %u",
1959 Stream_GetRemainingLength(s), 0U);
1960 return -1008;
1961 }
1962
1963#if defined(WITH_DEBUG_CODECS)
1964 WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveFrameEnd");
1965#endif
1966
1967 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) == 0)
1968 WLog_WARN(TAG, "RFX_PROGRESSIVE_FRAME_END before RFX_PROGRESSIVE_FRAME_BEGIN, ignoring");
1969 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
1970 WLog_WARN(TAG, "Duplicate RFX_PROGRESSIVE_FRAME_END, ignoring");
1971
1972 progressive->state |= FLAG_WBT_FRAME_END;
1973 return 0;
1974}
1975
1976static inline SSIZE_T progressive_wb_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1977 wStream* WINPR_RESTRICT s, UINT16 blockType,
1978 UINT32 blockLen)
1979{
1980 PROGRESSIVE_BLOCK_CONTEXT* context = &progressive->context;
1981 context->blockType = blockType;
1982 context->blockLen = blockLen;
1983
1984 if (context->blockLen != 10)
1985 {
1986 WLog_Print(progressive->log, WLOG_ERROR,
1987 "RFX_PROGRESSIVE_CONTEXT::blockLen = 0x%08" PRIx32 " != 0x%08x",
1988 context->blockLen, 10u);
1989 return -1005;
1990 }
1991
1992 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
1993 return -1009;
1994
1995 Stream_Read_UINT8(s, context->ctxId);
1996 Stream_Read_UINT16(s, context->tileSize);
1997 Stream_Read_UINT8(s, context->flags);
1998
1999 if (context->ctxId != 0x00)
2000 WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT::ctxId != 0x00: %" PRIu8, context->ctxId);
2001
2002 if (context->tileSize != 64)
2003 {
2004 WLog_ERR(TAG, "RFX_PROGRESSIVE_CONTEXT::tileSize != 0x40: %" PRIu16, context->tileSize);
2005 return -1010;
2006 }
2007
2008 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) != 0)
2009 WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT received after RFX_PROGRESSIVE_FRAME_BEGIN");
2010 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
2011 WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT received after RFX_PROGRESSIVE_FRAME_END");
2012 if ((progressive->state & FLAG_WBT_CONTEXT) != 0)
2013 WLog_WARN(TAG, "Duplicate RFX_PROGRESSIVE_CONTEXT received, ignoring.");
2014
2015#if defined(WITH_DEBUG_CODECS)
2016 WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveContext: flags: 0x%02" PRIX8 "",
2017 context->flags);
2018#endif
2019
2020 progressive->state |= FLAG_WBT_CONTEXT;
2021 return 0;
2022}
2023
2024static inline SSIZE_T
2025progressive_wb_read_region_header(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2026 wStream* WINPR_RESTRICT s, UINT16 blockType, UINT32 blockLen,
2027 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
2028{
2029 region->usedTiles = 0;
2030
2031 if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
2032 return -1011;
2033
2034 region->blockType = blockType;
2035 region->blockLen = blockLen;
2036 Stream_Read_UINT8(s, region->tileSize);
2037 Stream_Read_UINT16(s, region->numRects);
2038 Stream_Read_UINT8(s, region->numQuant);
2039 Stream_Read_UINT8(s, region->numProgQuant);
2040 Stream_Read_UINT8(s, region->flags);
2041 Stream_Read_UINT16(s, region->numTiles);
2042 Stream_Read_UINT32(s, region->tileDataSize);
2043
2044 if (region->tileSize != 64)
2045 {
2046 WLog_Print(progressive->log, WLOG_ERROR,
2047 "ProgressiveRegion tile size %" PRIu8 ", expected %u", region->tileSize, 64U);
2048 return -1012;
2049 }
2050
2051 if (region->numRects < 1)
2052 {
2053 WLog_Print(progressive->log, WLOG_ERROR, "ProgressiveRegion missing rect count %" PRIu16,
2054 region->numRects);
2055 return -1013;
2056 }
2057
2058 if (region->numQuant > 7)
2059 {
2060 WLog_Print(progressive->log, WLOG_ERROR,
2061 "ProgressiveRegion quant count too high %" PRIu8 ", expected < %u",
2062 region->numQuant, 7U);
2063 return -1014;
2064 }
2065
2066 const SSIZE_T rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, Stream_GetRemainingLength(s));
2067 const SSIZE_T expect = region->numRects * 8ll + region->numQuant * 5ll +
2068 region->numProgQuant * 16ll + region->tileDataSize;
2069 SSIZE_T len = rc;
2070 if (expect != rc)
2071 {
2072 if (len / 8LL < region->numRects)
2073 {
2074 WLog_Print(progressive->log, WLOG_ERROR,
2075 "ProgressiveRegion data short for region->rects");
2076 return -1015;
2077 }
2078 len -= region->numRects * 8LL;
2079
2080 if (len / 5LL < region->numQuant)
2081 {
2082 WLog_Print(progressive->log, WLOG_ERROR,
2083 "ProgressiveRegion data short for region->cQuant");
2084 return -1018;
2085 }
2086 len -= region->numQuant * 5LL;
2087
2088 if (len / 16LL < region->numProgQuant)
2089 {
2090 WLog_Print(progressive->log, WLOG_ERROR,
2091 "ProgressiveRegion data short for region->cProgQuant");
2092 return -1021;
2093 }
2094 len -= region->numProgQuant * 16LL;
2095
2096 if (len < region->tileDataSize * 1ll)
2097 {
2098 WLog_Print(progressive->log, WLOG_ERROR,
2099 "ProgressiveRegion data short for region->tiles");
2100 return -1024;
2101 }
2102 len -= region->tileDataSize;
2103
2104 if (len > 0)
2105 WLog_Print(progressive->log, WLOG_WARN,
2106 "Unused bytes detected, %" PRIdz " bytes not processed", len);
2107 }
2108
2109 return rc;
2110}
2111
2112static inline SSIZE_T progressive_wb_skip_region(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2113 wStream* WINPR_RESTRICT s, UINT16 blockType,
2114 UINT32 blockLen)
2115{
2116 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region = &progressive->region;
2117
2118 const SSIZE_T rc =
2119 progressive_wb_read_region_header(progressive, s, blockType, blockLen, region);
2120 if (rc < 0)
2121 return rc;
2122
2123 if (!Stream_SafeSeek(s, WINPR_ASSERTING_INT_CAST(size_t, rc)))
2124 return -1111;
2125
2126 return rc;
2127}
2128
2129static inline SSIZE_T progressive_wb_region(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2130 wStream* WINPR_RESTRICT s, UINT16 blockType,
2131 UINT32 blockLen,
2132 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
2133 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
2134{
2135 SSIZE_T rc = -1;
2136 UINT16 boxLeft = 0;
2137 UINT16 boxTop = 0;
2138 UINT16 boxRight = 0;
2139 UINT16 boxBottom = 0;
2140 UINT16 idxLeft = 0;
2141 UINT16 idxTop = 0;
2142 UINT16 idxRight = 0;
2143 UINT16 idxBottom = 0;
2144 const PROGRESSIVE_BLOCK_CONTEXT* context = &progressive->context;
2145
2146 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) == 0)
2147 {
2148 WLog_WARN(TAG, "RFX_PROGRESSIVE_REGION before RFX_PROGRESSIVE_FRAME_BEGIN, ignoring");
2149 return progressive_wb_skip_region(progressive, s, blockType, blockLen);
2150 }
2151 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
2152 {
2153 WLog_WARN(TAG, "RFX_PROGRESSIVE_REGION after RFX_PROGRESSIVE_FRAME_END, ignoring");
2154 return progressive_wb_skip_region(progressive, s, blockType, blockLen);
2155 }
2156
2157 progressive->state |= FLAG_WBT_REGION;
2158
2159 rc = progressive_wb_read_region_header(progressive, s, blockType, blockLen, region);
2160 if (rc < 0)
2161 return rc;
2162
2163 for (UINT16 index = 0; index < region->numRects; index++)
2164 {
2165 RFX_RECT* rect = &(region->rects[index]);
2166 Stream_Read_UINT16(s, rect->x);
2167 Stream_Read_UINT16(s, rect->y);
2168 Stream_Read_UINT16(s, rect->width);
2169 Stream_Read_UINT16(s, rect->height);
2170 }
2171
2172 for (BYTE index = 0; index < region->numQuant; index++)
2173 {
2174 RFX_COMPONENT_CODEC_QUANT* quantVal = &(region->quantVals[index]);
2175 progressive_component_codec_quant_read(s, quantVal);
2176
2177 if (!progressive_rfx_quant_lcmp_greater_equal(quantVal, 6))
2178 {
2179 WLog_Print(progressive->log, WLOG_ERROR,
2180 "ProgressiveRegion region->cQuant[%" PRIu32 "] < 6", index);
2181 return -1;
2182 }
2183
2184 if (!progressive_rfx_quant_lcmp_less_equal(quantVal, 15))
2185 {
2186 WLog_Print(progressive->log, WLOG_ERROR,
2187 "ProgressiveRegion region->cQuant[%" PRIu32 "] > 15", index);
2188 return -1;
2189 }
2190 }
2191
2192 for (BYTE index = 0; index < region->numProgQuant; index++)
2193 {
2194 RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal = &(region->quantProgVals[index]);
2195
2196 Stream_Read_UINT8(s, quantProgVal->quality);
2197
2198 progressive_component_codec_quant_read(s, &(quantProgVal->yQuantValues));
2199 progressive_component_codec_quant_read(s, &(quantProgVal->cbQuantValues));
2200 progressive_component_codec_quant_read(s, &(quantProgVal->crQuantValues));
2201 }
2202
2203#if defined(WITH_DEBUG_CODECS)
2204 WLog_Print(progressive->log, WLOG_DEBUG,
2205 "ProgressiveRegion: numRects: %" PRIu16 " numTiles: %" PRIu16
2206 " tileDataSize: %" PRIu32 " flags: 0x%02" PRIX8 " numQuant: %" PRIu8
2207 " numProgQuant: %" PRIu8 "",
2208 region->numRects, region->numTiles, region->tileDataSize, region->flags,
2209 region->numQuant, region->numProgQuant);
2210#endif
2211
2212 boxLeft = WINPR_ASSERTING_INT_CAST(UINT16, surface->gridWidth);
2213 boxTop = WINPR_ASSERTING_INT_CAST(UINT16, surface->gridHeight);
2214 boxRight = 0;
2215 boxBottom = 0;
2216
2217 for (UINT16 index = 0; index < region->numRects; index++)
2218 {
2219 RFX_RECT* rect = &(region->rects[index]);
2220 idxLeft = rect->x / 64;
2221 idxTop = rect->y / 64;
2222 idxRight = (rect->x + rect->width + 63) / 64;
2223 idxBottom = (rect->y + rect->height + 63) / 64;
2224
2225 if (idxLeft < boxLeft)
2226 boxLeft = idxLeft;
2227
2228 if (idxTop < boxTop)
2229 boxTop = idxTop;
2230
2231 if (idxRight > boxRight)
2232 boxRight = idxRight;
2233
2234 if (idxBottom > boxBottom)
2235 boxBottom = idxBottom;
2236
2237#if defined(WITH_DEBUG_CODECS)
2238 WLog_Print(progressive->log, WLOG_DEBUG,
2239 "rect[%" PRIu16 "]: x: %" PRIu16 " y: %" PRIu16 " w: %" PRIu16 " h: %" PRIu16 "",
2240 index, rect->x, rect->y, rect->width, rect->height);
2241#endif
2242 }
2243
2244 const SSIZE_T res = progressive_process_tiles(progressive, s, region, surface, context);
2245 if (res < 0)
2246 return -1;
2247 return rc;
2248}
2249
2250static inline SSIZE_T progressive_parse_block(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2251 wStream* WINPR_RESTRICT s,
2252 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
2253 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
2254{
2255 UINT16 blockType = 0;
2256 UINT32 blockLen = 0;
2257 SSIZE_T rc = -1;
2258 wStream sub = WINPR_C_ARRAY_INIT;
2259
2260 WINPR_ASSERT(progressive);
2261
2262 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
2263 return -1;
2264
2265 Stream_Read_UINT16(s, blockType);
2266 Stream_Read_UINT32(s, blockLen);
2267
2268 if (blockLen < 6)
2269 {
2270 WLog_WARN(TAG, "Invalid blockLen %" PRIu32 ", expected >= 6", blockLen);
2271 return -1;
2272 }
2273 if (!Stream_CheckAndLogRequiredLength(TAG, s, blockLen - 6))
2274 return -1;
2275 Stream_StaticConstInit(&sub, Stream_Pointer(s), blockLen - 6);
2276 Stream_Seek(s, blockLen - 6);
2277
2278 switch (blockType)
2279 {
2280 case PROGRESSIVE_WBT_SYNC:
2281 rc = progressive_wb_sync(progressive, &sub, blockType, blockLen);
2282 break;
2283
2284 case PROGRESSIVE_WBT_FRAME_BEGIN:
2285 rc = progressive_wb_frame_begin(progressive, &sub, blockType, blockLen);
2286 break;
2287
2288 case PROGRESSIVE_WBT_FRAME_END:
2289 rc = progressive_wb_frame_end(progressive, &sub, blockType, blockLen);
2290 break;
2291
2292 case PROGRESSIVE_WBT_CONTEXT:
2293 rc = progressive_wb_context(progressive, &sub, blockType, blockLen);
2294 break;
2295
2296 case PROGRESSIVE_WBT_REGION:
2297 rc = progressive_wb_region(progressive, &sub, blockType, blockLen, surface, region);
2298 break;
2299
2300 default:
2301 WLog_Print(progressive->log, WLOG_ERROR, "Invalid block type %04" PRIx16, blockType);
2302 return -1;
2303 }
2304
2305 if (rc < 0)
2306 return -1;
2307
2308 if (Stream_GetRemainingLength(&sub) > 0)
2309 {
2310 WLog_Print(progressive->log, WLOG_ERROR,
2311 "block len %" PRIu32 " does not match read data %" PRIuz, blockLen,
2312 blockLen - Stream_GetRemainingLength(&sub));
2313 return -1;
2314 }
2315
2316 return rc;
2317}
2318
2319static inline BOOL update_tiles(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2320 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
2321 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep,
2322 UINT32 nXDst, UINT32 nYDst,
2323 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
2324 REGION16* WINPR_RESTRICT invalidRegion)
2325{
2326 BOOL rc = TRUE;
2327 REGION16 clippingRects = WINPR_C_ARRAY_INIT;
2328 region16_init(&clippingRects);
2329
2330 for (UINT32 i = 0; i < region->numRects; i++)
2331 {
2332 RECTANGLE_16 clippingRect = WINPR_C_ARRAY_INIT;
2333 const RFX_RECT* rect = &(region->rects[i]);
2334
2335 clippingRect.left = (UINT16)nXDst + rect->x;
2336 clippingRect.top = (UINT16)nYDst + rect->y;
2337 clippingRect.right = clippingRect.left + rect->width;
2338 clippingRect.bottom = clippingRect.top + rect->height;
2339 if (!region16_union_rect(&clippingRects, &clippingRects, &clippingRect))
2340 {
2341 region16_uninit(&clippingRects);
2342 return FALSE;
2343 }
2344 }
2345
2346 for (UINT32 i = 0; i < surface->numUpdatedTiles; i++)
2347 {
2348 UINT32 nbUpdateRects = 0;
2349 const RECTANGLE_16* updateRects = nullptr;
2350 RECTANGLE_16 updateRect = WINPR_C_ARRAY_INIT;
2351
2352 WINPR_ASSERT(surface->updatedTileIndices);
2353 const UINT32 index = surface->updatedTileIndices[i];
2354
2355 WINPR_ASSERT(index < surface->tilesSize);
2356 RFX_PROGRESSIVE_TILE* tile = surface->tiles[index];
2357 WINPR_ASSERT(tile);
2358
2359 const UINT32 dl = nXDst + tile->x;
2360 updateRect.left = WINPR_ASSERTING_INT_CAST(UINT16, dl);
2361
2362 const UINT32 dt = nYDst + tile->y;
2363 updateRect.top = WINPR_ASSERTING_INT_CAST(UINT16, dt);
2364 updateRect.right = updateRect.left + 64;
2365 updateRect.bottom = updateRect.top + 64;
2366
2367 REGION16 updateRegion = WINPR_C_ARRAY_INIT;
2368 region16_init(&updateRegion);
2369 if (!region16_intersect_rect(&updateRegion, &clippingRects, &updateRect))
2370 {
2371 region16_uninit(&updateRegion);
2372 goto fail;
2373 }
2374 updateRects = region16_rects(&updateRegion, &nbUpdateRects);
2375
2376 for (UINT32 j = 0; j < nbUpdateRects; j++)
2377 {
2378 rc = FALSE;
2379 const RECTANGLE_16* rect = &updateRects[j];
2380 if (rect->left < updateRect.left)
2381 break;
2382 const UINT32 nXSrc = rect->left - updateRect.left;
2383 const UINT32 nYSrc = rect->top - updateRect.top;
2384 const UINT32 width = rect->right - rect->left;
2385 const UINT32 height = rect->bottom - rect->top;
2386
2387 if (rect->left + width > surface->width)
2388 break;
2389 if (rect->top + height > surface->height)
2390 break;
2391 rc = freerdp_image_copy_no_overlap(
2392 pDstData, DstFormat, nDstStep, rect->left, rect->top, width, height, tile->data,
2393 progressive->format, tile->stride, nXSrc, nYSrc, nullptr, FREERDP_KEEP_DST_ALPHA);
2394 if (!rc)
2395 break;
2396
2397 if (invalidRegion)
2398 {
2399 if (!region16_union_rect(invalidRegion, invalidRegion, rect))
2400 {
2401 region16_uninit(&updateRegion);
2402 goto fail;
2403 }
2404 }
2405 }
2406
2407 region16_uninit(&updateRegion);
2408 if (!rc)
2409 goto fail;
2410 tile->dirty = FALSE;
2411 }
2412
2413fail:
2414 region16_uninit(&clippingRects);
2415 return rc;
2416}
2417
2418INT32 progressive_decompress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2419 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
2420 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep,
2421 UINT32 nXDst, UINT32 nYDst, REGION16* WINPR_RESTRICT invalidRegion,
2422 UINT16 surfaceId, UINT32 frameId)
2423{
2424 INT32 rc = 1;
2425
2426 WINPR_ASSERT(progressive);
2427 PROGRESSIVE_SURFACE_CONTEXT* surface = progressive_get_surface_data(progressive, surfaceId);
2428
2429 if (!surface)
2430 {
2431 WLog_Print(progressive->log, WLOG_ERROR, "ProgressiveRegion no surface for %" PRIu16,
2432 surfaceId);
2433 return -1001;
2434 }
2435
2436 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region = &progressive->region;
2437 WINPR_ASSERT(region);
2438
2439 if (surface->frameId != frameId)
2440 {
2441 surface->frameId = frameId;
2442 surface->numUpdatedTiles = 0;
2443 }
2444
2445 wStream ss = WINPR_C_ARRAY_INIT;
2446 wStream* s = Stream_StaticConstInit(&ss, pSrcData, SrcSize);
2447 WINPR_ASSERT(s);
2448
2449 switch (DstFormat)
2450 {
2451 case PIXEL_FORMAT_RGBA32:
2452 case PIXEL_FORMAT_RGBX32:
2453 case PIXEL_FORMAT_BGRA32:
2454 case PIXEL_FORMAT_BGRX32:
2455 progressive->format = DstFormat;
2456 break;
2457 default:
2458 progressive->format = PIXEL_FORMAT_XRGB32;
2459 break;
2460 }
2461
2462 const size_t start = Stream_GetPosition(s);
2463 progressive->state = 0; /* Set state to not initialized */
2464 while (Stream_GetRemainingLength(s) > 0)
2465 {
2466 if (progressive_parse_block(progressive, s, surface, region) < 0)
2467 goto fail;
2468 }
2469
2470 {
2471 const size_t end = Stream_GetPosition(s);
2472 if ((end - start) != SrcSize)
2473 {
2474 WLog_Print(progressive->log, WLOG_ERROR,
2475 "total block len %" PRIuz " does not match read data %" PRIu32, end - start,
2476 SrcSize);
2477 rc = -1041;
2478 goto fail;
2479 }
2480 }
2481
2482 if (!update_tiles(progressive, surface, pDstData, DstFormat, nDstStep, nXDst, nYDst, region,
2483 invalidRegion))
2484 return -2002;
2485fail:
2486 return rc;
2487}
2488
2489BOOL progressive_rfx_write_message_progressive_simple(
2490 PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s,
2491 const RFX_MESSAGE* WINPR_RESTRICT msg)
2492{
2493 RFX_CONTEXT* context = nullptr;
2494
2495 WINPR_ASSERT(progressive);
2496 WINPR_ASSERT(s);
2497 WINPR_ASSERT(msg);
2498 context = progressive->rfx_context;
2499 return rfx_write_message_progressive_simple(context, s, msg);
2500}
2501
2502int progressive_compress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2503 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 SrcFormat,
2504 UINT32 Width, UINT32 Height, UINT32 ScanLine,
2505 const REGION16* WINPR_RESTRICT invalidRegion,
2506 BYTE** WINPR_RESTRICT ppDstData, UINT32* WINPR_RESTRICT pDstSize)
2507{
2508 BOOL rc = FALSE;
2509 int res = -6;
2510 wStream* s = nullptr;
2511 UINT32 numRects = 0;
2512 RFX_RECT* rects = nullptr;
2513 RFX_MESSAGE* message = nullptr;
2514
2515 if (!progressive || !pSrcData || !ppDstData || !pDstSize)
2516 {
2517 return -1;
2518 }
2519
2520 if (ScanLine == 0)
2521 {
2522 switch (SrcFormat)
2523 {
2524 case PIXEL_FORMAT_ABGR32:
2525 case PIXEL_FORMAT_ARGB32:
2526 case PIXEL_FORMAT_XBGR32:
2527 case PIXEL_FORMAT_XRGB32:
2528 case PIXEL_FORMAT_BGRA32:
2529 case PIXEL_FORMAT_BGRX32:
2530 case PIXEL_FORMAT_RGBA32:
2531 case PIXEL_FORMAT_RGBX32:
2532 ScanLine = Width * 4;
2533 break;
2534 default:
2535 return -2;
2536 }
2537 }
2538
2539 if (SrcSize < Height * ScanLine)
2540 return -4;
2541
2542 if (!invalidRegion)
2543 {
2544 numRects = (Width + 63) / 64;
2545 numRects *= (Height + 63) / 64;
2546 }
2547 else
2548 {
2549 const int nr = region16_n_rects(invalidRegion);
2550 numRects = WINPR_ASSERTING_INT_CAST(uint32_t, nr);
2551 }
2552
2553 if (numRects == 0)
2554 return 0;
2555
2556 if (!Stream_EnsureRemainingCapacity(progressive->rects, numRects * sizeof(RFX_RECT)))
2557 return -5;
2558 rects = Stream_BufferAs(progressive->rects, RFX_RECT);
2559 if (invalidRegion)
2560 {
2561 const RECTANGLE_16* region_rects = region16_rects(invalidRegion, nullptr);
2562 for (UINT32 idx = 0; idx < numRects; idx++)
2563 {
2564 const RECTANGLE_16* r = &region_rects[idx];
2565 RFX_RECT* rect = &rects[idx];
2566
2567 rect->x = r->left;
2568 rect->y = r->top;
2569 rect->width = r->right - r->left;
2570 rect->height = r->bottom - r->top;
2571 }
2572 }
2573 else
2574 {
2575 UINT16 x = 0;
2576 UINT16 y = 0;
2577
2578 for (UINT32 i = 0; i < numRects; i++)
2579 {
2580 RFX_RECT* r = &rects[i];
2581 r->x = x;
2582 r->y = y;
2583
2584 WINPR_ASSERT(Width >= x);
2585 WINPR_ASSERT(Height >= y);
2586 r->width = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Width - x));
2587 r->height = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Height - y));
2588
2589 if (x + 64UL >= Width)
2590 {
2591 y += 64;
2592 x = 0;
2593 }
2594 else
2595 x += 64;
2596
2597 WINPR_ASSERT(r->x % 64 == 0);
2598 WINPR_ASSERT(r->y % 64 == 0);
2599 WINPR_ASSERT(r->width <= 64);
2600 WINPR_ASSERT(r->height <= 64);
2601 }
2602 }
2603 s = progressive->buffer;
2604 Stream_ResetPosition(s);
2605
2606 progressive->rfx_context->mode = RLGR1;
2607
2608 progressive->rfx_context->width = WINPR_ASSERTING_INT_CAST(UINT16, Width);
2609 progressive->rfx_context->height = WINPR_ASSERTING_INT_CAST(UINT16, Height);
2610 rfx_context_set_pixel_format(progressive->rfx_context, SrcFormat);
2611 message = rfx_encode_message(progressive->rfx_context, rects, numRects, pSrcData, Width, Height,
2612 ScanLine);
2613 if (!message)
2614 {
2615 WLog_ERR(TAG, "failed to encode rfx message");
2616 goto fail;
2617 }
2618
2619 rc = progressive_rfx_write_message_progressive_simple(progressive, s, message);
2620 rfx_message_free(progressive->rfx_context, message);
2621 if (!rc)
2622 goto fail;
2623
2624 {
2625 const size_t pos = Stream_GetPosition(s);
2626 WINPR_ASSERT(pos <= UINT32_MAX);
2627 *pDstSize = (UINT32)pos;
2628 }
2629 *ppDstData = Stream_Buffer(s);
2630 res = 1;
2631fail:
2632 return res;
2633}
2634
2635BOOL progressive_context_reset(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive)
2636{
2637 return (progressive != nullptr);
2638}
2639
2640PROGRESSIVE_CONTEXT* progressive_context_new(BOOL Compressor)
2641{
2642 return progressive_context_new_ex(Compressor, 0);
2643}
2644
2645PROGRESSIVE_CONTEXT* progressive_context_new_ex(BOOL Compressor, UINT32 ThreadingFlags)
2646{
2647 PROGRESSIVE_CONTEXT* progressive =
2648 (PROGRESSIVE_CONTEXT*)winpr_aligned_calloc(1, sizeof(PROGRESSIVE_CONTEXT), 32);
2649
2650 if (!progressive)
2651 return nullptr;
2652
2653 progressive->Compressor = Compressor;
2654 progressive->quantProgValFull.quality = 100;
2655 progressive->log = WLog_Get(TAG);
2656 if (!progressive->log)
2657 goto fail;
2658 progressive->rfx_context = rfx_context_new_ex(Compressor, ThreadingFlags);
2659 if (!progressive->rfx_context)
2660 goto fail;
2661 progressive->buffer = Stream_New(nullptr, 1024);
2662 if (!progressive->buffer)
2663 goto fail;
2664 progressive->rects = Stream_New(nullptr, 1024);
2665 if (!progressive->rects)
2666 goto fail;
2667 progressive->bufferPool = BufferPool_New(TRUE, (8192LL + 32LL) * 3LL, 16);
2668 if (!progressive->bufferPool)
2669 goto fail;
2670 progressive->SurfaceContexts = HashTable_New(TRUE);
2671 if (!progressive->SurfaceContexts)
2672 goto fail;
2673
2674 {
2675 wObject* obj = HashTable_ValueObject(progressive->SurfaceContexts);
2676 WINPR_ASSERT(obj);
2677 obj->fnObjectFree = progressive_surface_context_free;
2678 }
2679 return progressive;
2680fail:
2681 WINPR_PRAGMA_DIAG_PUSH
2682 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2683 progressive_context_free(progressive);
2684 WINPR_PRAGMA_DIAG_POP
2685 return nullptr;
2686}
2687
2688void progressive_context_free(PROGRESSIVE_CONTEXT* progressive)
2689{
2690 if (!progressive)
2691 return;
2692
2693 Stream_Free(progressive->buffer, TRUE);
2694 Stream_Free(progressive->rects, TRUE);
2695 rfx_context_free(progressive->rfx_context);
2696
2697 BufferPool_Free(progressive->bufferPool);
2698 HashTable_Free(progressive->SurfaceContexts);
2699
2700 winpr_aligned_free(progressive);
2701}
PROGRESSIVE_BLOCK_CONTEXT
Definition libfreerdp/codec/progressive.h:74
PROGRESSIVE_BLOCK_FRAME_BEGIN
Definition libfreerdp/codec/progressive.h:174
PROGRESSIVE_BLOCK_FRAME_END
Definition libfreerdp/codec/progressive.h:184
PROGRESSIVE_BLOCK_SYNC
Definition libfreerdp/codec/progressive.h:65
PROGRESSIVE_SURFACE_CONTEXT
Definition libfreerdp/codec/progressive.h:190
PROGRESSIVE_TILE_PROCESS_WORK_PARAM
Definition libfreerdp/codec/progressive.h:147
RECTANGLE_16
Definition types.h:109
RFX_COMPONENT_CODEC_QUANT
Definition libfreerdp/codec/progressive.h:37
RFX_PROGRESSIVE_CODEC_QUANT
Definition libfreerdp/codec/progressive.h:51
RFX_PROGRESSIVE_TILE
Definition libfreerdp/codec/progressive.h:84
RFX_RECT
Definition rfx.h:44
prim_size_t
Definition primitives.h:74
primitives_t
Definition primitives.h:255
primitives_t::lShiftC_16s_inplace
WINPR_ATTR_NODISCARD fn_lShiftC_16s_inplace_t lShiftC_16s_inplace
Definition primitives.h:303
primitives_t::add_16s_inplace
WINPR_ATTR_NODISCARD fn_add_16s_inplace_t add_16s_inplace
Do vecotor addition, store result in both input buffers pSrcDst1 = pSrcDst2 = pSrcDst1 + pSrcDst2.
Definition primitives.h:302
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59