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->HH1 < 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 UINT32 aRawLen = 0;
1269 UINT32 aSrlLen = 0;
1270 wBitStream s_srl = WINPR_C_ARRAY_INIT;
1271 wBitStream s_raw = WINPR_C_ARRAY_INIT;
1272 RFX_PROGRESSIVE_UPGRADE_STATE state = WINPR_C_ARRAY_INIT;
1273
1274 state.kp = 8;
1275 state.mode = 0;
1276 state.srl = &s_srl;
1277 state.raw = &s_raw;
1278 BitStream_Attach(state.srl, srlData, srlLen);
1279 BitStream_Fetch(state.srl);
1280 BitStream_Attach(state.raw, rawData, rawLen);
1281 BitStream_Fetch(state.raw);
1282
1283 state.nonLL = TRUE;
1284 rc = progressive_rfx_upgrade_block(&state, &current[0], &sign[0], 1023, shift->HL1, bitPos->HL1,
1285 numBits->HL1); /* HL1 */
1286 if (rc < 0)
1287 return rc;
1288 rc = progressive_rfx_upgrade_block(&state, &current[1023], &sign[1023], 1023, shift->LH1,
1289 bitPos->LH1, numBits->LH1); /* LH1 */
1290 if (rc < 0)
1291 return rc;
1292 rc = progressive_rfx_upgrade_block(&state, &current[2046], &sign[2046], 961, shift->HH1,
1293 bitPos->HH1, numBits->HH1); /* HH1 */
1294 if (rc < 0)
1295 return rc;
1296 rc = progressive_rfx_upgrade_block(&state, &current[3007], &sign[3007], 272, shift->HL2,
1297 bitPos->HL2, numBits->HL2); /* HL2 */
1298 if (rc < 0)
1299 return rc;
1300 rc = progressive_rfx_upgrade_block(&state, &current[3279], &sign[3279], 272, shift->LH2,
1301 bitPos->LH2, numBits->LH2); /* LH2 */
1302 if (rc < 0)
1303 return rc;
1304 rc = progressive_rfx_upgrade_block(&state, &current[3551], &sign[3551], 256, shift->HH2,
1305 bitPos->HH2, numBits->HH2); /* HH2 */
1306 if (rc < 0)
1307 return rc;
1308 rc = progressive_rfx_upgrade_block(&state, &current[3807], &sign[3807], 72, shift->HL3,
1309 bitPos->HL3, numBits->HL3); /* HL3 */
1310 if (rc < 0)
1311 return rc;
1312 rc = progressive_rfx_upgrade_block(&state, &current[3879], &sign[3879], 72, shift->LH3,
1313 bitPos->LH3, numBits->LH3); /* LH3 */
1314 if (rc < 0)
1315 return rc;
1316 rc = progressive_rfx_upgrade_block(&state, &current[3951], &sign[3951], 64, shift->HH3,
1317 bitPos->HH3, numBits->HH3); /* HH3 */
1318 if (rc < 0)
1319 return rc;
1320
1321 state.nonLL = FALSE;
1322 rc = progressive_rfx_upgrade_block(&state, &current[4015], &sign[4015], 81, shift->LL3,
1323 bitPos->LL3, numBits->LL3); /* LL3 */
1324 if (rc < 0)
1325 return rc;
1326 rc = progressive_rfx_upgrade_state_finish(&state);
1327 if (rc < 0)
1328 return rc;
1329 aRawLen = (state.raw->position + 7) / 8;
1330 aSrlLen = (state.srl->position + 7) / 8;
1331
1332 if ((aRawLen != rawLen) || (aSrlLen != srlLen))
1333 {
1334 int pRawLen = 0;
1335 int pSrlLen = 0;
1336
1337 if (rawLen)
1338 pRawLen = (int)((((float)aRawLen) / ((float)rawLen)) * 100.0f);
1339
1340 if (srlLen)
1341 pSrlLen = (int)((((float)aSrlLen) / ((float)srlLen)) * 100.0f);
1342
1343 WLog_Print(progressive->log, WLOG_WARN,
1344 "RAW: %" PRIu32 "/%" PRIu32 " %d%% (%" PRIu32 "/%" PRIu32 ":%" PRIu32
1345 ")\tSRL: %" PRIu32 "/%" PRIu32 " %d%% (%" PRIu32 "/%" PRIu32 ":%" PRIu32 ")",
1346 aRawLen, rawLen, pRawLen, state.raw->position, rawLen * 8,
1347 (rawLen * 8) - state.raw->position, aSrlLen, srlLen, pSrlLen,
1348 state.srl->position, srlLen * 8, (srlLen * 8) - state.srl->position);
1349 return -1;
1350 }
1351
1352 return progressive_rfx_dwt_2d_decode(progressive, buffer, current, coeffDiff, extrapolate,
1353 TRUE);
1354}
1355
1356static inline int
1357progressive_decompress_tile_upgrade(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1358 RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile,
1359 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1360 const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1361{
1362 int status = 0;
1363 BOOL coeffDiff = 0;
1364 BOOL sub = 0;
1365 BOOL extrapolate = 0;
1366 BYTE* pBuffer = nullptr;
1367 INT16* pSign[3] = WINPR_C_ARRAY_INIT;
1368 INT16* pSrcDst[3] = WINPR_C_ARRAY_INIT;
1369 INT16* pCurrent[3] = WINPR_C_ARRAY_INIT;
1370 RFX_COMPONENT_CODEC_QUANT shiftY = WINPR_C_ARRAY_INIT;
1371 RFX_COMPONENT_CODEC_QUANT shiftCb = WINPR_C_ARRAY_INIT;
1372 RFX_COMPONENT_CODEC_QUANT shiftCr = WINPR_C_ARRAY_INIT;
1373 RFX_COMPONENT_CODEC_QUANT yBitPos = WINPR_C_ARRAY_INIT;
1374 RFX_COMPONENT_CODEC_QUANT cbBitPos = WINPR_C_ARRAY_INIT;
1375 RFX_COMPONENT_CODEC_QUANT crBitPos = WINPR_C_ARRAY_INIT;
1376 RFX_COMPONENT_CODEC_QUANT yNumBits = WINPR_C_ARRAY_INIT;
1377 RFX_COMPONENT_CODEC_QUANT cbNumBits = WINPR_C_ARRAY_INIT;
1378 RFX_COMPONENT_CODEC_QUANT crNumBits = WINPR_C_ARRAY_INIT;
1379 RFX_COMPONENT_CODEC_QUANT* quantY = nullptr;
1380 RFX_COMPONENT_CODEC_QUANT* quantCb = nullptr;
1381 RFX_COMPONENT_CODEC_QUANT* quantCr = nullptr;
1382 RFX_COMPONENT_CODEC_QUANT* quantProgY = nullptr;
1383 RFX_COMPONENT_CODEC_QUANT* quantProgCb = nullptr;
1384 RFX_COMPONENT_CODEC_QUANT* quantProgCr = nullptr;
1385 RFX_PROGRESSIVE_CODEC_QUANT* quantProg = nullptr;
1386 static const prim_size_t roi_64x64 = { 64, 64 };
1387 const primitives_t* prims = primitives_get();
1388
1389 coeffDiff = tile->flags & RFX_TILE_DIFFERENCE;
1390 sub = context->flags & RFX_SUBBAND_DIFFING;
1391 extrapolate = region->flags & RFX_DWT_REDUCE_EXTRAPOLATE;
1392
1393 tile->pass++;
1394
1395#if defined(WITH_DEBUG_CODECS)
1396 WLog_Print(progressive->log, WLOG_DEBUG,
1397 "ProgressiveTileUpgrade: pass: %" PRIu16 " quantIdx Y: %" PRIu8 " Cb: %" PRIu8
1398 " Cr: %" PRIu8 " xIdx: %" PRIu16 " yIdx: %" PRIu16 " quality: %" PRIu8
1399 " ySrlLen: %" PRIu16 " yRawLen: %" PRIu16 " cbSrlLen: %" PRIu16 " cbRawLen: %" PRIu16
1400 " crSrlLen: %" PRIu16 " crRawLen: %" PRIu16 "",
1401 tile->pass, tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx,
1402 tile->yIdx, tile->quality, tile->ySrlLen, tile->yRawLen, tile->cbSrlLen,
1403 tile->cbRawLen, tile->crSrlLen, tile->crRawLen);
1404#endif
1405
1406 if (tile->quantIdxY >= region->numQuant)
1407 {
1408 WLog_ERR(TAG, "quantIdxY %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxY, region->numQuant);
1409 return -1;
1410 }
1411
1412 quantY = &(region->quantVals[tile->quantIdxY]);
1413
1414 if (tile->quantIdxCb >= region->numQuant)
1415 {
1416 WLog_ERR(TAG, "quantIdxCb %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCb,
1417 region->numQuant);
1418 return -1;
1419 }
1420
1421 quantCb = &(region->quantVals[tile->quantIdxCb]);
1422
1423 if (tile->quantIdxCr >= region->numQuant)
1424 {
1425 WLog_ERR(TAG, "quantIdxCr %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCr,
1426 region->numQuant);
1427 return -1;
1428 }
1429
1430 quantCr = &(region->quantVals[tile->quantIdxCr]);
1431
1432 if (tile->quality == 0xFF)
1433 {
1434 quantProg = &(progressive->quantProgValFull);
1435 }
1436 else
1437 {
1438 if (tile->quality >= region->numProgQuant)
1439 {
1440 WLog_ERR(TAG, "quality %" PRIu8 " > numProgQuant %" PRIu8, tile->quality,
1441 region->numProgQuant);
1442 return -1;
1443 }
1444
1445 quantProg = &(region->quantProgVals[tile->quality]);
1446 }
1447
1448 quantProgY = &(quantProg->yQuantValues);
1449 quantProgCb = &(quantProg->cbQuantValues);
1450 quantProgCr = &(quantProg->crQuantValues);
1451
1452 if (!progressive_rfx_quant_cmp_equal(quantY, &(tile->yQuant)))
1453 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantY has changed!");
1454
1455 if (!progressive_rfx_quant_cmp_equal(quantCb, &(tile->cbQuant)))
1456 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCb has changed!");
1457
1458 if (!progressive_rfx_quant_cmp_equal(quantCr, &(tile->crQuant)))
1459 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCr has changed!");
1460
1461 if (!(context->flags & RFX_SUBBAND_DIFFING))
1462 WLog_WARN(TAG, "PROGRESSIVE_BLOCK_CONTEXT::flags & RFX_SUBBAND_DIFFING not set");
1463
1464 progressive_rfx_quant_add(quantY, quantProgY, &yBitPos);
1465 progressive_rfx_quant_add(quantCb, quantProgCb, &cbBitPos);
1466 progressive_rfx_quant_add(quantCr, quantProgCr, &crBitPos);
1467 if (!progressive_rfx_quant_sub(&(tile->yBitPos), &yBitPos, &yNumBits))
1468 goto fail;
1469 if (!progressive_rfx_quant_sub(&(tile->cbBitPos), &cbBitPos, &cbNumBits))
1470 goto fail;
1471 if (!progressive_rfx_quant_sub(&(tile->crBitPos), &crBitPos, &crNumBits))
1472 goto fail;
1473 progressive_rfx_quant_add(quantY, quantProgY, &shiftY);
1474 if (!progressive_rfx_quant_lsub(&shiftY, 1)) /* -6 + 5 = -1 */
1475 goto fail;
1476 progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);
1477 if (!progressive_rfx_quant_lsub(&shiftCb, 1)) /* -6 + 5 = -1 */
1478 goto fail;
1479 progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);
1480 if (!progressive_rfx_quant_lsub(&shiftCr, 1)) /* -6 + 5 = -1 */
1481 goto fail;
1482
1483 tile->yBitPos = yBitPos;
1484 tile->cbBitPos = cbBitPos;
1485 tile->crBitPos = crBitPos;
1486 tile->yQuant = *quantY;
1487 tile->cbQuant = *quantCb;
1488 tile->crQuant = *quantCr;
1489 tile->yProgQuant = *quantProgY;
1490 tile->cbProgQuant = *quantProgCb;
1491 tile->crProgQuant = *quantProgCr;
1492
1493 pSign[0] = (INT16*)((&tile->sign[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1494 pSign[1] = (INT16*)((&tile->sign[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1495 pSign[2] = (INT16*)((&tile->sign[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1496
1497 pCurrent[0] = (INT16*)((&tile->current[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1498 pCurrent[1] = (INT16*)((&tile->current[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1499 pCurrent[2] = (INT16*)((&tile->current[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1500
1501 pBuffer = (BYTE*)BufferPool_Take(progressive->bufferPool, -1);
1502 pSrcDst[0] = (INT16*)((&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1503 pSrcDst[1] = (INT16*)((&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1504 pSrcDst[2] = (INT16*)((&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1505
1506 status = progressive_rfx_upgrade_component(progressive, &shiftY, quantProgY, &yNumBits,
1507 pSrcDst[0], pCurrent[0], pSign[0], tile->ySrlData,
1508 tile->ySrlLen, tile->yRawData, tile->yRawLen,
1509 coeffDiff, sub, extrapolate); /* Y */
1510
1511 if (status < 0)
1512 goto fail;
1513
1514 status = progressive_rfx_upgrade_component(progressive, &shiftCb, quantProgCb, &cbNumBits,
1515 pSrcDst[1], pCurrent[1], pSign[1], tile->cbSrlData,
1516 tile->cbSrlLen, tile->cbRawData, tile->cbRawLen,
1517 coeffDiff, sub, extrapolate); /* Cb */
1518
1519 if (status < 0)
1520 goto fail;
1521
1522 status = progressive_rfx_upgrade_component(progressive, &shiftCr, quantProgCr, &crNumBits,
1523 pSrcDst[2], pCurrent[2], pSign[2], tile->crSrlData,
1524 tile->crSrlLen, tile->crRawData, tile->crRawLen,
1525 coeffDiff, sub, extrapolate); /* Cr */
1526
1527 if (status < 0)
1528 goto fail;
1529
1530 {
1531 const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
1532 status = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride,
1533 progressive->format, &roi_64x64);
1534 }
1535fail:
1536 BufferPool_Return(progressive->bufferPool, pBuffer);
1537 return status;
1538}
1539
1540static inline BOOL progressive_tile_read_upgrade(
1541 PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s, UINT16 blockType,
1542 UINT32 blockLen, PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
1543 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1544 WINPR_ATTR_UNUSED const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1545{
1546 RFX_PROGRESSIVE_TILE tile = WINPR_C_ARRAY_INIT;
1547 const size_t expect = 20;
1548
1549 if (!Stream_CheckAndLogRequiredLength(TAG, s, expect))
1550 return FALSE;
1551
1552 tile.blockType = blockType;
1553 tile.blockLen = blockLen;
1554 tile.flags = 0;
1555
1556 Stream_Read_UINT8(s, tile.quantIdxY);
1557 Stream_Read_UINT8(s, tile.quantIdxCb);
1558 Stream_Read_UINT8(s, tile.quantIdxCr);
1559 Stream_Read_UINT16(s, tile.xIdx);
1560 Stream_Read_UINT16(s, tile.yIdx);
1561 Stream_Read_UINT8(s, tile.quality);
1562 Stream_Read_UINT16(s, tile.ySrlLen);
1563 Stream_Read_UINT16(s, tile.yRawLen);
1564 Stream_Read_UINT16(s, tile.cbSrlLen);
1565 Stream_Read_UINT16(s, tile.cbRawLen);
1566 Stream_Read_UINT16(s, tile.crSrlLen);
1567 Stream_Read_UINT16(s, tile.crRawLen);
1568
1569 tile.ySrlData = Stream_Pointer(s);
1570 if (!Stream_SafeSeek(s, tile.ySrlLen))
1571 {
1572 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.ySrlLen);
1573 return FALSE;
1574 }
1575
1576 tile.yRawData = Stream_Pointer(s);
1577 if (!Stream_SafeSeek(s, tile.yRawLen))
1578 {
1579 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.yRawLen);
1580 return FALSE;
1581 }
1582
1583 tile.cbSrlData = Stream_Pointer(s);
1584 if (!Stream_SafeSeek(s, tile.cbSrlLen))
1585 {
1586 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1587 tile.cbSrlLen);
1588 return FALSE;
1589 }
1590
1591 tile.cbRawData = Stream_Pointer(s);
1592 if (!Stream_SafeSeek(s, tile.cbRawLen))
1593 {
1594 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1595 tile.cbRawLen);
1596 return FALSE;
1597 }
1598
1599 tile.crSrlData = Stream_Pointer(s);
1600 if (!Stream_SafeSeek(s, tile.crSrlLen))
1601 {
1602 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1603 tile.crSrlLen);
1604 return FALSE;
1605 }
1606
1607 tile.crRawData = Stream_Pointer(s);
1608 if (!Stream_SafeSeek(s, tile.crRawLen))
1609 {
1610 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes",
1611 tile.crRawLen);
1612 return FALSE;
1613 }
1614
1615 return progressive_surface_tile_replace(surface, region, &tile, TRUE);
1616}
1617
1618static inline BOOL
1619progressive_tile_read(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, BOOL simple,
1620 wStream* WINPR_RESTRICT s, UINT16 blockType, UINT32 blockLen,
1621 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
1622 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1623 WINPR_ATTR_UNUSED const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1624{
1625 RFX_PROGRESSIVE_TILE tile = WINPR_C_ARRAY_INIT;
1626 size_t expect = simple ? 16 : 17;
1627
1628 if (!Stream_CheckAndLogRequiredLength(TAG, s, expect))
1629 return FALSE;
1630
1631 tile.blockType = blockType;
1632 tile.blockLen = blockLen;
1633
1634 Stream_Read_UINT8(s, tile.quantIdxY);
1635 Stream_Read_UINT8(s, tile.quantIdxCb);
1636 Stream_Read_UINT8(s, tile.quantIdxCr);
1637 Stream_Read_UINT16(s, tile.xIdx);
1638 Stream_Read_UINT16(s, tile.yIdx);
1639 Stream_Read_UINT8(s, tile.flags);
1640
1641 if (!simple)
1642 Stream_Read_UINT8(s, tile.quality);
1643 else
1644 tile.quality = 0xFF;
1645 Stream_Read_UINT16(s, tile.yLen);
1646 Stream_Read_UINT16(s, tile.cbLen);
1647 Stream_Read_UINT16(s, tile.crLen);
1648 Stream_Read_UINT16(s, tile.tailLen);
1649
1650 tile.yData = Stream_Pointer(s);
1651 if (!Stream_SafeSeek(s, tile.yLen))
1652 {
1653 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.yLen);
1654 return FALSE;
1655 }
1656
1657 tile.cbData = Stream_Pointer(s);
1658 if (!Stream_SafeSeek(s, tile.cbLen))
1659 {
1660 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.cbLen);
1661 return FALSE;
1662 }
1663
1664 tile.crData = Stream_Pointer(s);
1665 if (!Stream_SafeSeek(s, tile.crLen))
1666 {
1667 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.crLen);
1668 return FALSE;
1669 }
1670
1671 tile.tailData = Stream_Pointer(s);
1672 if (!Stream_SafeSeek(s, tile.tailLen))
1673 {
1674 WLog_Print(progressive->log, WLOG_ERROR, " Failed to seek %" PRIu32 " bytes", tile.tailLen);
1675 return FALSE;
1676 }
1677
1678 return progressive_surface_tile_replace(surface, region, &tile, FALSE);
1679}
1680
1681static void CALLBACK progressive_process_tiles_tile_work_callback(PTP_CALLBACK_INSTANCE instance,
1682 void* context, PTP_WORK work)
1683{
1684 PROGRESSIVE_TILE_PROCESS_WORK_PARAM* param = (PROGRESSIVE_TILE_PROCESS_WORK_PARAM*)context;
1685
1686 WINPR_UNUSED(instance);
1687 WINPR_UNUSED(work);
1688
1689 switch (param->tile->blockType)
1690 {
1691 case PROGRESSIVE_WBT_TILE_SIMPLE:
1692 case PROGRESSIVE_WBT_TILE_FIRST:
1693 progressive_decompress_tile_first(param->progressive, param->tile, param->region,
1694 param->context);
1695 break;
1696
1697 case PROGRESSIVE_WBT_TILE_UPGRADE:
1698 progressive_decompress_tile_upgrade(param->progressive, param->tile, param->region,
1699 param->context);
1700 break;
1701 default:
1702 WLog_Print(param->progressive->log, WLOG_ERROR, "Invalid block type %04" PRIx16 " (%s)",
1703 param->tile->blockType,
1704 rfx_get_progressive_block_type_string(param->tile->blockType));
1705 break;
1706 }
1707}
1708
1709static inline SSIZE_T
1710progressive_process_tiles(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1711 wStream* WINPR_RESTRICT s,
1712 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1713 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
1714 const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1715{
1716 int status = 0;
1717 size_t end = 0;
1718 const size_t start = Stream_GetPosition(s);
1719 UINT16 blockType = 0;
1720 UINT32 blockLen = 0;
1721 UINT32 count = 0;
1722 UINT16 close_cnt = 0;
1723
1724 WINPR_ASSERT(progressive);
1725 WINPR_ASSERT(region);
1726
1727 if (!Stream_CheckAndLogRequiredLength(TAG, s, region->tileDataSize))
1728 return -1;
1729
1730 while ((Stream_GetRemainingLength(s) >= 6) &&
1731 (region->tileDataSize > (Stream_GetPosition(s) - start)))
1732 {
1733 const size_t pos = Stream_GetPosition(s);
1734
1735 Stream_Read_UINT16(s, blockType);
1736 Stream_Read_UINT32(s, blockLen);
1737
1738#if defined(WITH_DEBUG_CODECS)
1739 WLog_Print(progressive->log, WLOG_DEBUG, "%s",
1740 rfx_get_progressive_block_type_string(blockType));
1741#endif
1742
1743 if (blockLen < 6)
1744 {
1745 WLog_Print(progressive->log, WLOG_ERROR, "Expected >= %" PRIu32 " remaining %" PRIu32,
1746 6u, blockLen);
1747 return -1003;
1748 }
1749 if (!Stream_CheckAndLogRequiredLength(TAG, s, blockLen - 6))
1750 return -1003;
1751
1752 switch (blockType)
1753 {
1754 case PROGRESSIVE_WBT_TILE_SIMPLE:
1755 if (!progressive_tile_read(progressive, TRUE, s, blockType, blockLen, surface,
1756 region, context))
1757 return -1022;
1758 break;
1759
1760 case PROGRESSIVE_WBT_TILE_FIRST:
1761 if (!progressive_tile_read(progressive, FALSE, s, blockType, blockLen, surface,
1762 region, context))
1763 return -1027;
1764 break;
1765
1766 case PROGRESSIVE_WBT_TILE_UPGRADE:
1767 if (!progressive_tile_read_upgrade(progressive, s, blockType, blockLen, surface,
1768 region, context))
1769 return -1032;
1770 break;
1771 default:
1772 WLog_ERR(TAG, "Invalid block type %04" PRIx16 " (%s)", blockType,
1773 rfx_get_progressive_block_type_string(blockType));
1774 return -1039;
1775 }
1776
1777 size_t rem = Stream_GetPosition(s);
1778 if ((rem - pos) != blockLen)
1779 {
1780 WLog_Print(progressive->log, WLOG_ERROR,
1781 "Actual block read %" PRIuz " but expected %" PRIu32, rem - pos, blockLen);
1782 return -1040;
1783 }
1784 count++;
1785 }
1786
1787 end = Stream_GetPosition(s);
1788 if ((end - start) != region->tileDataSize)
1789 {
1790 WLog_Print(progressive->log, WLOG_ERROR,
1791 "Actual total blocks read %" PRIuz " but expected %" PRIu32, end - start,
1792 region->tileDataSize);
1793 return -1041;
1794 }
1795
1796 if (count != region->numTiles)
1797 {
1798 WLog_Print(progressive->log, WLOG_WARN,
1799 "numTiles inconsistency: actual: %" PRIu32 ", expected: %" PRIu16 "\n", count,
1800 region->numTiles);
1801 return -1044;
1802 }
1803
1804 for (UINT32 idx = 0; idx < region->numTiles; idx++)
1805 {
1806 RFX_PROGRESSIVE_TILE* tile = region->tiles[idx];
1807 PROGRESSIVE_TILE_PROCESS_WORK_PARAM* param = &progressive->params[idx];
1808 param->progressive = progressive;
1809 param->region = region;
1810 param->context = context;
1811 param->tile = tile;
1812
1813 if (progressive->rfx_context->priv->UseThreads)
1814 {
1815 progressive->work_objects[idx] = CreateThreadpoolWork(
1816 progressive_process_tiles_tile_work_callback, (void*)param, nullptr);
1817 if (!progressive->work_objects[idx])
1818 {
1819 WLog_Print(progressive->log, WLOG_ERROR,
1820 "Failed to create ThreadpoolWork for tile %" PRIu32, idx);
1821 status = -1;
1822 break;
1823 }
1824
1825 SubmitThreadpoolWork(progressive->work_objects[idx]);
1826
1827 close_cnt = WINPR_ASSERTING_INT_CAST(UINT16, idx + 1);
1828 }
1829 else
1830 {
1831 progressive_process_tiles_tile_work_callback(nullptr, param, nullptr);
1832 }
1833
1834 if (status < 0)
1835 {
1836 WLog_Print(progressive->log, WLOG_ERROR, "Failed to decompress %s at %" PRIu16,
1837 rfx_get_progressive_block_type_string(tile->blockType), idx);
1838 goto fail;
1839 }
1840 }
1841
1842 if (progressive->rfx_context->priv->UseThreads)
1843 {
1844 for (UINT32 idx = 0; idx < close_cnt; idx++)
1845 {
1846 WaitForThreadpoolWorkCallbacks(progressive->work_objects[idx], FALSE);
1847 CloseThreadpoolWork(progressive->work_objects[idx]);
1848 }
1849 }
1850
1851fail:
1852
1853 if (status < 0)
1854 return -1;
1855
1856 return (SSIZE_T)(end - start);
1857}
1858
1859static inline SSIZE_T progressive_wb_sync(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1860 wStream* WINPR_RESTRICT s, UINT16 blockType,
1861 UINT32 blockLen)
1862{
1863 const UINT32 magic = 0xCACCACCA;
1864 const UINT16 version = 0x0100;
1865 PROGRESSIVE_BLOCK_SYNC sync = WINPR_C_ARRAY_INIT;
1866
1867 sync.blockType = blockType;
1868 sync.blockLen = blockLen;
1869
1870 if (sync.blockLen != 12)
1871 {
1872 WLog_Print(progressive->log, WLOG_ERROR,
1873 "PROGRESSIVE_BLOCK_SYNC::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
1874 sync.blockLen, 12u);
1875 return -1005;
1876 }
1877
1878 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
1879 return -1004;
1880
1881#if defined(WITH_DEBUG_CODECS)
1882 WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveSync");
1883#endif
1884
1885 Stream_Read_UINT32(s, sync.magic);
1886 Stream_Read_UINT16(s, sync.version);
1887
1888 if (sync.magic != magic)
1889 {
1890 WLog_Print(progressive->log, WLOG_ERROR,
1891 "PROGRESSIVE_BLOCK_SYNC::magic = 0x%08" PRIx32 " != 0x%08" PRIx32, sync.magic,
1892 magic);
1893 return -1005;
1894 }
1895
1896 if (sync.version != 0x0100)
1897 {
1898 WLog_Print(progressive->log, WLOG_ERROR,
1899 "PROGRESSIVE_BLOCK_SYNC::version = 0x%04" PRIx16 " != 0x%04" PRIu16,
1900 sync.version, version);
1901 return -1006;
1902 }
1903
1904 if ((progressive->state & FLAG_WBT_SYNC) != 0)
1905 WLog_WARN(TAG, "Duplicate PROGRESSIVE_BLOCK_SYNC, ignoring");
1906
1907 progressive->state |= FLAG_WBT_SYNC;
1908 return 0;
1909}
1910
1911static inline SSIZE_T progressive_wb_frame_begin(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1912 wStream* WINPR_RESTRICT s, UINT16 blockType,
1913 UINT32 blockLen)
1914{
1915 PROGRESSIVE_BLOCK_FRAME_BEGIN frameBegin = WINPR_C_ARRAY_INIT;
1916
1917 frameBegin.blockType = blockType;
1918 frameBegin.blockLen = blockLen;
1919
1920 if (frameBegin.blockLen != 12)
1921 {
1922 WLog_Print(progressive->log, WLOG_ERROR,
1923 " RFX_PROGRESSIVE_FRAME_BEGIN::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
1924 frameBegin.blockLen, 12u);
1925 return -1005;
1926 }
1927
1928 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
1929 return -1007;
1930
1931 Stream_Read_UINT32(s, frameBegin.frameIndex);
1932 Stream_Read_UINT16(s, frameBegin.regionCount);
1933
1934#if defined(WITH_DEBUG_CODECS)
1935 WLog_Print(progressive->log, WLOG_DEBUG,
1936 "ProgressiveFrameBegin: frameIndex: %" PRIu32 " regionCount: %" PRIu16 "",
1937 frameBegin.frameIndex, frameBegin.regionCount);
1938#endif
1939
1946 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) != 0)
1947 {
1948 WLog_ERR(TAG, "Duplicate RFX_PROGRESSIVE_FRAME_BEGIN in stream, this is not allowed!");
1949 return -1008;
1950 }
1951
1952 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
1953 {
1954 WLog_ERR(TAG, "RFX_PROGRESSIVE_FRAME_BEGIN after RFX_PROGRESSIVE_FRAME_END in stream, this "
1955 "is not allowed!");
1956 return -1008;
1957 }
1958
1959 progressive->state |= FLAG_WBT_FRAME_BEGIN;
1960 return 0;
1961}
1962
1963static inline SSIZE_T progressive_wb_frame_end(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1964 wStream* WINPR_RESTRICT s, UINT16 blockType,
1965 UINT32 blockLen)
1966{
1967 PROGRESSIVE_BLOCK_FRAME_END frameEnd = WINPR_C_ARRAY_INIT;
1968
1969 frameEnd.blockType = blockType;
1970 frameEnd.blockLen = blockLen;
1971
1972 if (frameEnd.blockLen != 6)
1973 {
1974 WLog_Print(progressive->log, WLOG_ERROR,
1975 " RFX_PROGRESSIVE_FRAME_END::blockLen = 0x%08" PRIx32 " != 0x%08" PRIx32,
1976 frameEnd.blockLen, 6u);
1977 return -1005;
1978 }
1979
1980 if (Stream_GetRemainingLength(s) != 0)
1981 {
1982 WLog_Print(progressive->log, WLOG_ERROR,
1983 "ProgressiveFrameEnd short %" PRIuz ", expected %u",
1984 Stream_GetRemainingLength(s), 0U);
1985 return -1008;
1986 }
1987
1988#if defined(WITH_DEBUG_CODECS)
1989 WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveFrameEnd");
1990#endif
1991
1992 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) == 0)
1993 WLog_WARN(TAG, "RFX_PROGRESSIVE_FRAME_END before RFX_PROGRESSIVE_FRAME_BEGIN, ignoring");
1994 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
1995 WLog_WARN(TAG, "Duplicate RFX_PROGRESSIVE_FRAME_END, ignoring");
1996
1997 progressive->state |= FLAG_WBT_FRAME_END;
1998 return 0;
1999}
2000
2001static inline SSIZE_T progressive_wb_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2002 wStream* WINPR_RESTRICT s, UINT16 blockType,
2003 UINT32 blockLen)
2004{
2005 PROGRESSIVE_BLOCK_CONTEXT* context = &progressive->context;
2006 context->blockType = blockType;
2007 context->blockLen = blockLen;
2008
2009 if (context->blockLen != 10)
2010 {
2011 WLog_Print(progressive->log, WLOG_ERROR,
2012 "RFX_PROGRESSIVE_CONTEXT::blockLen = 0x%08" PRIx32 " != 0x%08x",
2013 context->blockLen, 10u);
2014 return -1005;
2015 }
2016
2017 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
2018 return -1009;
2019
2020 Stream_Read_UINT8(s, context->ctxId);
2021 Stream_Read_UINT16(s, context->tileSize);
2022 Stream_Read_UINT8(s, context->flags);
2023
2024 if (context->ctxId != 0x00)
2025 WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT::ctxId != 0x00: %" PRIu8, context->ctxId);
2026
2027 if (context->tileSize != 64)
2028 {
2029 WLog_ERR(TAG, "RFX_PROGRESSIVE_CONTEXT::tileSize != 0x40: %" PRIu16, context->tileSize);
2030 return -1010;
2031 }
2032
2033 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) != 0)
2034 WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT received after RFX_PROGRESSIVE_FRAME_BEGIN");
2035 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
2036 WLog_WARN(TAG, "RFX_PROGRESSIVE_CONTEXT received after RFX_PROGRESSIVE_FRAME_END");
2037 if ((progressive->state & FLAG_WBT_CONTEXT) != 0)
2038 WLog_WARN(TAG, "Duplicate RFX_PROGRESSIVE_CONTEXT received, ignoring.");
2039
2040#if defined(WITH_DEBUG_CODECS)
2041 WLog_Print(progressive->log, WLOG_DEBUG, "ProgressiveContext: flags: 0x%02" PRIX8 "",
2042 context->flags);
2043#endif
2044
2045 progressive->state |= FLAG_WBT_CONTEXT;
2046 return 0;
2047}
2048
2049static inline SSIZE_T
2050progressive_wb_read_region_header(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2051 wStream* WINPR_RESTRICT s, UINT16 blockType, UINT32 blockLen,
2052 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
2053{
2054 region->usedTiles = 0;
2055
2056 if (!Stream_CheckAndLogRequiredLength(TAG, s, 12))
2057 return -1011;
2058
2059 region->blockType = blockType;
2060 region->blockLen = blockLen;
2061 Stream_Read_UINT8(s, region->tileSize);
2062 Stream_Read_UINT16(s, region->numRects);
2063 Stream_Read_UINT8(s, region->numQuant);
2064 Stream_Read_UINT8(s, region->numProgQuant);
2065 Stream_Read_UINT8(s, region->flags);
2066 Stream_Read_UINT16(s, region->numTiles);
2067 Stream_Read_UINT32(s, region->tileDataSize);
2068
2069 if (region->tileSize != 64)
2070 {
2071 WLog_Print(progressive->log, WLOG_ERROR,
2072 "ProgressiveRegion tile size %" PRIu8 ", expected %u", region->tileSize, 64U);
2073 return -1012;
2074 }
2075
2076 if (region->numRects < 1)
2077 {
2078 WLog_Print(progressive->log, WLOG_ERROR, "ProgressiveRegion missing rect count %" PRIu16,
2079 region->numRects);
2080 return -1013;
2081 }
2082
2083 if (region->numQuant > 7)
2084 {
2085 WLog_Print(progressive->log, WLOG_ERROR,
2086 "ProgressiveRegion quant count too high %" PRIu8 ", expected < %u",
2087 region->numQuant, 7U);
2088 return -1014;
2089 }
2090
2091 const SSIZE_T rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, Stream_GetRemainingLength(s));
2092 const SSIZE_T expect = region->numRects * 8ll + region->numQuant * 5ll +
2093 region->numProgQuant * 16ll + region->tileDataSize;
2094 SSIZE_T len = rc;
2095 if (expect != rc)
2096 {
2097 if (len / 8LL < region->numRects)
2098 {
2099 WLog_Print(progressive->log, WLOG_ERROR,
2100 "ProgressiveRegion data short for region->rects");
2101 return -1015;
2102 }
2103 len -= region->numRects * 8LL;
2104
2105 if (len / 5LL < region->numQuant)
2106 {
2107 WLog_Print(progressive->log, WLOG_ERROR,
2108 "ProgressiveRegion data short for region->cQuant");
2109 return -1018;
2110 }
2111 len -= region->numQuant * 5LL;
2112
2113 if (len / 16LL < region->numProgQuant)
2114 {
2115 WLog_Print(progressive->log, WLOG_ERROR,
2116 "ProgressiveRegion data short for region->cProgQuant");
2117 return -1021;
2118 }
2119 len -= region->numProgQuant * 16LL;
2120
2121 if (len < region->tileDataSize * 1ll)
2122 {
2123 WLog_Print(progressive->log, WLOG_ERROR,
2124 "ProgressiveRegion data short for region->tiles");
2125 return -1024;
2126 }
2127 len -= region->tileDataSize;
2128
2129 if (len > 0)
2130 WLog_Print(progressive->log, WLOG_WARN,
2131 "Unused bytes detected, %" PRIdz " bytes not processed", len);
2132 }
2133
2134 return rc;
2135}
2136
2137static inline SSIZE_T progressive_wb_skip_region(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2138 wStream* WINPR_RESTRICT s, UINT16 blockType,
2139 UINT32 blockLen)
2140{
2141 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region = &progressive->region;
2142
2143 const SSIZE_T rc =
2144 progressive_wb_read_region_header(progressive, s, blockType, blockLen, region);
2145 if (rc < 0)
2146 return rc;
2147
2148 if (!Stream_SafeSeek(s, WINPR_ASSERTING_INT_CAST(size_t, rc)))
2149 return -1111;
2150
2151 return rc;
2152}
2153
2154static inline SSIZE_T progressive_wb_region(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2155 wStream* WINPR_RESTRICT s, UINT16 blockType,
2156 UINT32 blockLen,
2157 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
2158 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
2159{
2160 SSIZE_T rc = -1;
2161 UINT16 boxLeft = 0;
2162 UINT16 boxTop = 0;
2163 UINT16 boxRight = 0;
2164 UINT16 boxBottom = 0;
2165 UINT16 idxLeft = 0;
2166 UINT16 idxTop = 0;
2167 UINT16 idxRight = 0;
2168 UINT16 idxBottom = 0;
2169 const PROGRESSIVE_BLOCK_CONTEXT* context = &progressive->context;
2170
2171 if ((progressive->state & FLAG_WBT_FRAME_BEGIN) == 0)
2172 {
2173 WLog_WARN(TAG, "RFX_PROGRESSIVE_REGION before RFX_PROGRESSIVE_FRAME_BEGIN, ignoring");
2174 return progressive_wb_skip_region(progressive, s, blockType, blockLen);
2175 }
2176 if ((progressive->state & FLAG_WBT_FRAME_END) != 0)
2177 {
2178 WLog_WARN(TAG, "RFX_PROGRESSIVE_REGION after RFX_PROGRESSIVE_FRAME_END, ignoring");
2179 return progressive_wb_skip_region(progressive, s, blockType, blockLen);
2180 }
2181
2182 progressive->state |= FLAG_WBT_REGION;
2183
2184 rc = progressive_wb_read_region_header(progressive, s, blockType, blockLen, region);
2185 if (rc < 0)
2186 return rc;
2187
2188 for (UINT16 index = 0; index < region->numRects; index++)
2189 {
2190 RFX_RECT* rect = &(region->rects[index]);
2191 Stream_Read_UINT16(s, rect->x);
2192 Stream_Read_UINT16(s, rect->y);
2193 Stream_Read_UINT16(s, rect->width);
2194 Stream_Read_UINT16(s, rect->height);
2195 }
2196
2197 for (BYTE index = 0; index < region->numQuant; index++)
2198 {
2199 RFX_COMPONENT_CODEC_QUANT* quantVal = &(region->quantVals[index]);
2200 progressive_component_codec_quant_read(s, quantVal);
2201
2202 if (!progressive_rfx_quant_lcmp_greater_equal(quantVal, 6))
2203 {
2204 WLog_Print(progressive->log, WLOG_ERROR,
2205 "ProgressiveRegion region->cQuant[%" PRIu32 "] < 6", index);
2206 return -1;
2207 }
2208
2209 if (!progressive_rfx_quant_lcmp_less_equal(quantVal, 15))
2210 {
2211 WLog_Print(progressive->log, WLOG_ERROR,
2212 "ProgressiveRegion region->cQuant[%" PRIu32 "] > 15", index);
2213 return -1;
2214 }
2215 }
2216
2217 for (BYTE index = 0; index < region->numProgQuant; index++)
2218 {
2219 RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal = &(region->quantProgVals[index]);
2220
2221 Stream_Read_UINT8(s, quantProgVal->quality);
2222
2223 progressive_component_codec_quant_read(s, &(quantProgVal->yQuantValues));
2224 progressive_component_codec_quant_read(s, &(quantProgVal->cbQuantValues));
2225 progressive_component_codec_quant_read(s, &(quantProgVal->crQuantValues));
2226 }
2227
2228#if defined(WITH_DEBUG_CODECS)
2229 WLog_Print(progressive->log, WLOG_DEBUG,
2230 "ProgressiveRegion: numRects: %" PRIu16 " numTiles: %" PRIu16
2231 " tileDataSize: %" PRIu32 " flags: 0x%02" PRIX8 " numQuant: %" PRIu8
2232 " numProgQuant: %" PRIu8 "",
2233 region->numRects, region->numTiles, region->tileDataSize, region->flags,
2234 region->numQuant, region->numProgQuant);
2235#endif
2236
2237 boxLeft = WINPR_ASSERTING_INT_CAST(UINT16, surface->gridWidth);
2238 boxTop = WINPR_ASSERTING_INT_CAST(UINT16, surface->gridHeight);
2239 boxRight = 0;
2240 boxBottom = 0;
2241
2242 for (UINT16 index = 0; index < region->numRects; index++)
2243 {
2244 RFX_RECT* rect = &(region->rects[index]);
2245 idxLeft = rect->x / 64;
2246 idxTop = rect->y / 64;
2247 idxRight = (rect->x + rect->width + 63) / 64;
2248 idxBottom = (rect->y + rect->height + 63) / 64;
2249
2250 if (idxLeft < boxLeft)
2251 boxLeft = idxLeft;
2252
2253 if (idxTop < boxTop)
2254 boxTop = idxTop;
2255
2256 if (idxRight > boxRight)
2257 boxRight = idxRight;
2258
2259 if (idxBottom > boxBottom)
2260 boxBottom = idxBottom;
2261
2262#if defined(WITH_DEBUG_CODECS)
2263 WLog_Print(progressive->log, WLOG_DEBUG,
2264 "rect[%" PRIu16 "]: x: %" PRIu16 " y: %" PRIu16 " w: %" PRIu16 " h: %" PRIu16 "",
2265 index, rect->x, rect->y, rect->width, rect->height);
2266#endif
2267 }
2268
2269 const SSIZE_T res = progressive_process_tiles(progressive, s, region, surface, context);
2270 if (res < 0)
2271 return -1;
2272 return rc;
2273}
2274
2275static inline SSIZE_T progressive_parse_block(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2276 wStream* WINPR_RESTRICT s,
2277 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
2278 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region)
2279{
2280 UINT16 blockType = 0;
2281 UINT32 blockLen = 0;
2282 SSIZE_T rc = -1;
2283 wStream sub = WINPR_C_ARRAY_INIT;
2284
2285 WINPR_ASSERT(progressive);
2286
2287 if (!Stream_CheckAndLogRequiredLength(TAG, s, 6))
2288 return -1;
2289
2290 Stream_Read_UINT16(s, blockType);
2291 Stream_Read_UINT32(s, blockLen);
2292
2293 if (blockLen < 6)
2294 {
2295 WLog_WARN(TAG, "Invalid blockLen %" PRIu32 ", expected >= 6", blockLen);
2296 return -1;
2297 }
2298 if (!Stream_CheckAndLogRequiredLength(TAG, s, blockLen - 6))
2299 return -1;
2300 Stream_StaticConstInit(&sub, Stream_Pointer(s), blockLen - 6);
2301 Stream_Seek(s, blockLen - 6);
2302
2303 switch (blockType)
2304 {
2305 case PROGRESSIVE_WBT_SYNC:
2306 rc = progressive_wb_sync(progressive, &sub, blockType, blockLen);
2307 break;
2308
2309 case PROGRESSIVE_WBT_FRAME_BEGIN:
2310 rc = progressive_wb_frame_begin(progressive, &sub, blockType, blockLen);
2311 break;
2312
2313 case PROGRESSIVE_WBT_FRAME_END:
2314 rc = progressive_wb_frame_end(progressive, &sub, blockType, blockLen);
2315 break;
2316
2317 case PROGRESSIVE_WBT_CONTEXT:
2318 rc = progressive_wb_context(progressive, &sub, blockType, blockLen);
2319 break;
2320
2321 case PROGRESSIVE_WBT_REGION:
2322 rc = progressive_wb_region(progressive, &sub, blockType, blockLen, surface, region);
2323 break;
2324
2325 default:
2326 WLog_Print(progressive->log, WLOG_ERROR, "Invalid block type %04" PRIx16, blockType);
2327 return -1;
2328 }
2329
2330 if (rc < 0)
2331 return -1;
2332
2333 if (Stream_GetRemainingLength(&sub) > 0)
2334 {
2335 WLog_Print(progressive->log, WLOG_ERROR,
2336 "block len %" PRIu32 " does not match read data %" PRIuz, blockLen,
2337 blockLen - Stream_GetRemainingLength(&sub));
2338 return -1;
2339 }
2340
2341 return rc;
2342}
2343
2344static inline BOOL update_tiles(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2345 PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
2346 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep,
2347 UINT32 nXDst, UINT32 nYDst,
2348 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
2349 REGION16* WINPR_RESTRICT invalidRegion)
2350{
2351 BOOL rc = TRUE;
2352 REGION16 clippingRects = WINPR_C_ARRAY_INIT;
2353 region16_init(&clippingRects);
2354
2355 for (UINT32 i = 0; i < region->numRects; i++)
2356 {
2357 RECTANGLE_16 clippingRect = WINPR_C_ARRAY_INIT;
2358 const RFX_RECT* rect = &(region->rects[i]);
2359
2360 clippingRect.left = (UINT16)nXDst + rect->x;
2361 clippingRect.top = (UINT16)nYDst + rect->y;
2362 clippingRect.right = clippingRect.left + rect->width;
2363 clippingRect.bottom = clippingRect.top + rect->height;
2364 if (!region16_union_rect(&clippingRects, &clippingRects, &clippingRect))
2365 {
2366 region16_uninit(&clippingRects);
2367 return FALSE;
2368 }
2369 }
2370
2371 for (UINT32 i = 0; i < surface->numUpdatedTiles; i++)
2372 {
2373 UINT32 nbUpdateRects = 0;
2374 const RECTANGLE_16* updateRects = nullptr;
2375 RECTANGLE_16 updateRect = WINPR_C_ARRAY_INIT;
2376
2377 WINPR_ASSERT(surface->updatedTileIndices);
2378 const UINT32 index = surface->updatedTileIndices[i];
2379
2380 WINPR_ASSERT(index < surface->tilesSize);
2381 RFX_PROGRESSIVE_TILE* tile = surface->tiles[index];
2382 WINPR_ASSERT(tile);
2383
2384 const UINT32 dl = nXDst + tile->x;
2385 updateRect.left = WINPR_ASSERTING_INT_CAST(UINT16, dl);
2386
2387 const UINT32 dt = nYDst + tile->y;
2388 updateRect.top = WINPR_ASSERTING_INT_CAST(UINT16, dt);
2389 updateRect.right = updateRect.left + 64;
2390 updateRect.bottom = updateRect.top + 64;
2391
2392 REGION16 updateRegion = WINPR_C_ARRAY_INIT;
2393 region16_init(&updateRegion);
2394 if (!region16_intersect_rect(&updateRegion, &clippingRects, &updateRect))
2395 {
2396 region16_uninit(&updateRegion);
2397 goto fail;
2398 }
2399 updateRects = region16_rects(&updateRegion, &nbUpdateRects);
2400
2401 for (UINT32 j = 0; j < nbUpdateRects; j++)
2402 {
2403 rc = FALSE;
2404 const RECTANGLE_16* rect = &updateRects[j];
2405 if (rect->left < updateRect.left)
2406 break;
2407 const UINT32 nXSrc = rect->left - updateRect.left;
2408 const UINT32 nYSrc = rect->top - updateRect.top;
2409 const UINT32 width = rect->right - rect->left;
2410 const UINT32 height = rect->bottom - rect->top;
2411
2412 if (rect->left + width > surface->width)
2413 break;
2414 if (rect->top + height > surface->height)
2415 break;
2416 rc = freerdp_image_copy_no_overlap(
2417 pDstData, DstFormat, nDstStep, rect->left, rect->top, width, height, tile->data,
2418 progressive->format, tile->stride, nXSrc, nYSrc, nullptr, FREERDP_KEEP_DST_ALPHA);
2419 if (!rc)
2420 break;
2421
2422 if (invalidRegion)
2423 {
2424 if (!region16_union_rect(invalidRegion, invalidRegion, rect))
2425 {
2426 region16_uninit(&updateRegion);
2427 goto fail;
2428 }
2429 }
2430 }
2431
2432 region16_uninit(&updateRegion);
2433 if (!rc)
2434 goto fail;
2435 tile->dirty = FALSE;
2436 }
2437
2438fail:
2439 region16_uninit(&clippingRects);
2440 return rc;
2441}
2442
2443INT32 progressive_decompress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2444 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
2445 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep,
2446 UINT32 nXDst, UINT32 nYDst, REGION16* WINPR_RESTRICT invalidRegion,
2447 UINT16 surfaceId, UINT32 frameId)
2448{
2449 INT32 rc = 1;
2450
2451 WINPR_ASSERT(progressive);
2452 PROGRESSIVE_SURFACE_CONTEXT* surface = progressive_get_surface_data(progressive, surfaceId);
2453
2454 if (!surface)
2455 {
2456 WLog_Print(progressive->log, WLOG_ERROR, "ProgressiveRegion no surface for %" PRIu16,
2457 surfaceId);
2458 return -1001;
2459 }
2460
2461 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region = &progressive->region;
2462 WINPR_ASSERT(region);
2463
2464 if (surface->frameId != frameId)
2465 {
2466 surface->frameId = frameId;
2467 surface->numUpdatedTiles = 0;
2468 }
2469
2470 wStream ss = WINPR_C_ARRAY_INIT;
2471 wStream* s = Stream_StaticConstInit(&ss, pSrcData, SrcSize);
2472 WINPR_ASSERT(s);
2473
2474 switch (DstFormat)
2475 {
2476 case PIXEL_FORMAT_RGBA32:
2477 case PIXEL_FORMAT_RGBX32:
2478 case PIXEL_FORMAT_BGRA32:
2479 case PIXEL_FORMAT_BGRX32:
2480 progressive->format = DstFormat;
2481 break;
2482 default:
2483 progressive->format = PIXEL_FORMAT_XRGB32;
2484 break;
2485 }
2486
2487 const size_t start = Stream_GetPosition(s);
2488 progressive->state = 0; /* Set state to not initialized */
2489 while (Stream_GetRemainingLength(s) > 0)
2490 {
2491 if (progressive_parse_block(progressive, s, surface, region) < 0)
2492 goto fail;
2493 }
2494
2495 {
2496 const size_t end = Stream_GetPosition(s);
2497 if ((end - start) != SrcSize)
2498 {
2499 WLog_Print(progressive->log, WLOG_ERROR,
2500 "total block len %" PRIuz " does not match read data %" PRIu32, end - start,
2501 SrcSize);
2502 rc = -1041;
2503 goto fail;
2504 }
2505 }
2506
2507 if (!update_tiles(progressive, surface, pDstData, DstFormat, nDstStep, nXDst, nYDst, region,
2508 invalidRegion))
2509 return -2002;
2510fail:
2511 return rc;
2512}
2513
2514BOOL progressive_rfx_write_message_progressive_simple(
2515 PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s,
2516 const RFX_MESSAGE* WINPR_RESTRICT msg)
2517{
2518 RFX_CONTEXT* context = nullptr;
2519
2520 WINPR_ASSERT(progressive);
2521 WINPR_ASSERT(s);
2522 WINPR_ASSERT(msg);
2523 context = progressive->rfx_context;
2524 return rfx_write_message_progressive_simple(context, s, msg);
2525}
2526
2527int progressive_compress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2528 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 SrcFormat,
2529 UINT32 Width, UINT32 Height, UINT32 ScanLine,
2530 const REGION16* WINPR_RESTRICT invalidRegion,
2531 BYTE** WINPR_RESTRICT ppDstData, UINT32* WINPR_RESTRICT pDstSize)
2532{
2533 BOOL rc = FALSE;
2534 int res = -6;
2535 wStream* s = nullptr;
2536 UINT32 numRects = 0;
2537 RFX_RECT* rects = nullptr;
2538 RFX_MESSAGE* message = nullptr;
2539
2540 if (!progressive || !pSrcData || !ppDstData || !pDstSize)
2541 {
2542 return -1;
2543 }
2544
2545 if (ScanLine == 0)
2546 {
2547 switch (SrcFormat)
2548 {
2549 case PIXEL_FORMAT_ABGR32:
2550 case PIXEL_FORMAT_ARGB32:
2551 case PIXEL_FORMAT_XBGR32:
2552 case PIXEL_FORMAT_XRGB32:
2553 case PIXEL_FORMAT_BGRA32:
2554 case PIXEL_FORMAT_BGRX32:
2555 case PIXEL_FORMAT_RGBA32:
2556 case PIXEL_FORMAT_RGBX32:
2557 ScanLine = Width * 4;
2558 break;
2559 default:
2560 return -2;
2561 }
2562 }
2563
2564 if (SrcSize < Height * ScanLine)
2565 return -4;
2566
2567 if (!invalidRegion)
2568 {
2569 numRects = (Width + 63) / 64;
2570 numRects *= (Height + 63) / 64;
2571 }
2572 else
2573 {
2574 const int nr = region16_n_rects(invalidRegion);
2575 numRects = WINPR_ASSERTING_INT_CAST(uint32_t, nr);
2576 }
2577
2578 if (numRects == 0)
2579 return 0;
2580
2581 if (!Stream_EnsureRemainingCapacity(progressive->rects, numRects * sizeof(RFX_RECT)))
2582 return -5;
2583 rects = Stream_BufferAs(progressive->rects, RFX_RECT);
2584 if (invalidRegion)
2585 {
2586 const RECTANGLE_16* region_rects = region16_rects(invalidRegion, nullptr);
2587 for (UINT32 idx = 0; idx < numRects; idx++)
2588 {
2589 const RECTANGLE_16* r = &region_rects[idx];
2590 RFX_RECT* rect = &rects[idx];
2591
2592 rect->x = r->left;
2593 rect->y = r->top;
2594 rect->width = r->right - r->left;
2595 rect->height = r->bottom - r->top;
2596 }
2597 }
2598 else
2599 {
2600 UINT16 x = 0;
2601 UINT16 y = 0;
2602
2603 for (UINT32 i = 0; i < numRects; i++)
2604 {
2605 RFX_RECT* r = &rects[i];
2606 r->x = x;
2607 r->y = y;
2608
2609 WINPR_ASSERT(Width >= x);
2610 WINPR_ASSERT(Height >= y);
2611 r->width = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Width - x));
2612 r->height = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Height - y));
2613
2614 if (x + 64UL >= Width)
2615 {
2616 y += 64;
2617 x = 0;
2618 }
2619 else
2620 x += 64;
2621
2622 WINPR_ASSERT(r->x % 64 == 0);
2623 WINPR_ASSERT(r->y % 64 == 0);
2624 WINPR_ASSERT(r->width <= 64);
2625 WINPR_ASSERT(r->height <= 64);
2626 }
2627 }
2628 s = progressive->buffer;
2629 Stream_ResetPosition(s);
2630
2631 progressive->rfx_context->mode = RLGR1;
2632
2633 progressive->rfx_context->width = WINPR_ASSERTING_INT_CAST(UINT16, Width);
2634 progressive->rfx_context->height = WINPR_ASSERTING_INT_CAST(UINT16, Height);
2635 rfx_context_set_pixel_format(progressive->rfx_context, SrcFormat);
2636 message = rfx_encode_message(progressive->rfx_context, rects, numRects, pSrcData, Width, Height,
2637 ScanLine);
2638 if (!message)
2639 {
2640 WLog_ERR(TAG, "failed to encode rfx message");
2641 goto fail;
2642 }
2643
2644 rc = progressive_rfx_write_message_progressive_simple(progressive, s, message);
2645 rfx_message_free(progressive->rfx_context, message);
2646 if (!rc)
2647 goto fail;
2648
2649 {
2650 const size_t pos = Stream_GetPosition(s);
2651 WINPR_ASSERT(pos <= UINT32_MAX);
2652 *pDstSize = (UINT32)pos;
2653 }
2654 *ppDstData = Stream_Buffer(s);
2655 res = 1;
2656fail:
2657 return res;
2658}
2659
2660BOOL progressive_context_reset(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive)
2661{
2662 return (progressive != nullptr);
2663}
2664
2665PROGRESSIVE_CONTEXT* progressive_context_new(BOOL Compressor)
2666{
2667 return progressive_context_new_ex(Compressor, 0);
2668}
2669
2670PROGRESSIVE_CONTEXT* progressive_context_new_ex(BOOL Compressor, UINT32 ThreadingFlags)
2671{
2672 PROGRESSIVE_CONTEXT* progressive =
2673 (PROGRESSIVE_CONTEXT*)winpr_aligned_calloc(1, sizeof(PROGRESSIVE_CONTEXT), 32);
2674
2675 if (!progressive)
2676 return nullptr;
2677
2678 progressive->Compressor = Compressor;
2679 progressive->quantProgValFull.quality = 100;
2680 progressive->log = WLog_Get(TAG);
2681 if (!progressive->log)
2682 goto fail;
2683 progressive->rfx_context = rfx_context_new_ex(Compressor, ThreadingFlags);
2684 if (!progressive->rfx_context)
2685 goto fail;
2686 progressive->buffer = Stream_New(nullptr, 1024);
2687 if (!progressive->buffer)
2688 goto fail;
2689 progressive->rects = Stream_New(nullptr, 1024);
2690 if (!progressive->rects)
2691 goto fail;
2692 progressive->bufferPool = BufferPool_New(TRUE, (8192LL + 32LL) * 3LL, 16);
2693 if (!progressive->bufferPool)
2694 goto fail;
2695 progressive->SurfaceContexts = HashTable_New(TRUE);
2696 if (!progressive->SurfaceContexts)
2697 goto fail;
2698
2699 {
2700 wObject* obj = HashTable_ValueObject(progressive->SurfaceContexts);
2701 WINPR_ASSERT(obj);
2702 obj->fnObjectFree = progressive_surface_context_free;
2703 }
2704 return progressive;
2705fail:
2706 WINPR_PRAGMA_DIAG_PUSH
2707 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2708 progressive_context_free(progressive);
2709 WINPR_PRAGMA_DIAG_POP
2710 return nullptr;
2711}
2712
2713void progressive_context_free(PROGRESSIVE_CONTEXT* progressive)
2714{
2715 if (!progressive)
2716 return;
2717
2718 Stream_Free(progressive->buffer, TRUE);
2719 Stream_Free(progressive->rects, TRUE);
2720 rfx_context_free(progressive->rfx_context);
2721
2722 BufferPool_Free(progressive->bufferPool);
2723 HashTable_Free(progressive->SurfaceContexts);
2724
2725 winpr_aligned_free(progressive);
2726}
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