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_calloc(tile->stride, tile->height, 16);
369 if (!tile->data)
370 goto fail;
371 memset(tile->data, 0xFF, dataLen);
372 }
373
374 {
375 const size_t signLen = (8192ULL + 32ULL);
376 tile->sign = (BYTE*)winpr_aligned_calloc(3, signLen, 16);
377 }
378
379 if (!tile->sign)
380 goto fail;
381
382 {
383 const size_t currentLen = (8192ULL + 32ULL);
384 tile->current = (BYTE*)winpr_aligned_calloc(3, 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 UINT32 gridSize = surface->gridSize;
405 if (surface->tiles)
406 {
407 oldIndex = gridSize;
408 while (gridSize < min)
409 {
410 if (gridSize > UINT32_MAX - 1024)
411 return FALSE;
412 gridSize += 1024;
413 }
414 }
415
416 void* tmp =
417 winpr_aligned_recalloc((void*)surface->tiles, gridSize, sizeof(RFX_PROGRESSIVE_TILE*), 32);
418 if (!tmp)
419 return FALSE;
420 surface->tilesSize = gridSize;
421 surface->tiles = (RFX_PROGRESSIVE_TILE**)tmp;
422
423 for (size_t x = oldIndex; x < surface->tilesSize; x++)
424 {
425 surface->tiles[x] = progressive_tile_new();
426 if (!surface->tiles[x])
427 return FALSE;
428 }
429
430 tmp = winpr_aligned_recalloc(surface->updatedTileIndices, gridSize, sizeof(UINT32), 32);
431 if (!tmp)
432 return FALSE;
433
434 surface->gridSize = gridSize;
435 surface->updatedTileIndices = tmp;
436
437 return TRUE;
438}
439
440static PROGRESSIVE_SURFACE_CONTEXT* progressive_surface_context_new(UINT16 surfaceId, UINT32 width,
441 UINT32 height)
442{
443 PROGRESSIVE_SURFACE_CONTEXT* surface = (PROGRESSIVE_SURFACE_CONTEXT*)winpr_aligned_calloc(
444 1, sizeof(PROGRESSIVE_SURFACE_CONTEXT), 32);
445
446 if (!surface)
447 return nullptr;
448
449 surface->id = surfaceId;
450 surface->width = width;
451 surface->height = height;
452 surface->gridWidth = (width + (64 - width % 64)) / 64;
453 surface->gridHeight = (height + (64 - height % 64)) / 64;
454 surface->gridSize = surface->gridWidth * surface->gridHeight;
455
456 if (!progressive_allocate_tile_cache(surface, surface->gridSize))
457 {
458 progressive_surface_context_free(surface);
459 return nullptr;
460 }
461
462 return surface;
463}
464
465static inline BOOL
466progressive_surface_tile_replace(PROGRESSIVE_SURFACE_CONTEXT* WINPR_RESTRICT surface,
467 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
468 const RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile, BOOL upgrade)
469{
470 RFX_PROGRESSIVE_TILE* t = nullptr;
471
472 size_t zIdx = 0;
473 if (!surface || !tile)
474 return FALSE;
475
476 zIdx = (tile->yIdx * surface->gridWidth) + tile->xIdx;
477
478 if (zIdx >= surface->tilesSize)
479 {
480 WLog_ERR(TAG, "Invalid zIndex %" PRIuz, zIdx);
481 return FALSE;
482 }
483
484 t = surface->tiles[zIdx];
485
486 t->blockType = tile->blockType;
487 t->blockLen = tile->blockLen;
488 t->quantIdxY = tile->quantIdxY;
489 t->quantIdxCb = tile->quantIdxCb;
490 t->quantIdxCr = tile->quantIdxCr;
491 t->xIdx = tile->xIdx;
492 t->yIdx = tile->yIdx;
493 t->flags = tile->flags;
494 t->quality = tile->quality;
495 t->x = tile->xIdx * t->width;
496 t->y = tile->yIdx * t->height;
497
498 if (upgrade)
499 {
500 t->ySrlLen = tile->ySrlLen;
501 t->yRawLen = tile->yRawLen;
502 t->cbSrlLen = tile->cbSrlLen;
503 t->cbRawLen = tile->cbRawLen;
504 t->crSrlLen = tile->crSrlLen;
505 t->crRawLen = tile->crRawLen;
506 t->ySrlData = tile->ySrlData;
507 t->yRawData = tile->yRawData;
508 t->cbSrlData = tile->cbSrlData;
509 t->cbRawData = tile->cbRawData;
510 t->crSrlData = tile->crSrlData;
511 t->crRawData = tile->crRawData;
512 }
513 else
514 {
515 t->yLen = tile->yLen;
516 t->cbLen = tile->cbLen;
517 t->crLen = tile->crLen;
518 t->tailLen = tile->tailLen;
519 t->yData = tile->yData;
520 t->cbData = tile->cbData;
521 t->crData = tile->crData;
522 t->tailData = tile->tailData;
523 }
524
525 if (region->usedTiles >= region->numTiles)
526 {
527 WLog_ERR(TAG, "Invalid tile count, only expected %" PRIu16 ", got %" PRIu16,
528 region->numTiles, region->usedTiles);
529 return FALSE;
530 }
531
532 region->tiles[region->usedTiles++] = t;
533 if (!t->dirty)
534 {
535 if (surface->numUpdatedTiles >= surface->gridSize)
536 {
537 if (!progressive_allocate_tile_cache(surface, surface->numUpdatedTiles + 1))
538 return FALSE;
539 }
540
541 surface->updatedTileIndices[surface->numUpdatedTiles++] = (UINT32)zIdx;
542 }
543
544 t->dirty = TRUE;
545 return TRUE;
546}
547
548INT32 progressive_create_surface_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
549 UINT16 surfaceId, UINT32 width, UINT32 height)
550{
551 PROGRESSIVE_SURFACE_CONTEXT* surface = progressive_get_surface_data(progressive, surfaceId);
552
553 if (!surface)
554 {
555 surface = progressive_surface_context_new(surfaceId, width, height);
556
557 if (!surface)
558 return -1;
559
560 if (!progressive_set_surface_data(progressive, surfaceId, (void*)surface))
561 {
562 progressive_surface_context_free(surface);
563 return -1;
564 }
565 }
566
567 return 1;
568}
569
570int progressive_delete_surface_context(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
571 UINT16 surfaceId)
572{
573 progressive_set_surface_data(progressive, surfaceId, nullptr);
574
575 return 1;
576}
577
578/*
579 * Band Offset Dimensions Size
580 *
581 * HL1 0 31x33 1023
582 * LH1 1023 33x31 1023
583 * HH1 2046 31x31 961
584 *
585 * HL2 3007 16x17 272
586 * LH2 3279 17x16 272
587 * HH2 3551 16x16 256
588 *
589 * HL3 3807 8x9 72
590 * LH3 3879 9x8 72
591 * HH3 3951 8x8 64
592 *
593 * LL3 4015 9x9 81
594 */
595
596static int16_t clampi16(int val)
597{
598 if (val < INT16_MIN)
599 return INT16_MIN;
600 if (val > INT16_MAX)
601 return INT16_MAX;
602 return (int16_t)val;
603}
604
605static inline void progressive_rfx_idwt_x(const INT16* WINPR_RESTRICT pLowBand, size_t nLowStep,
606 const INT16* WINPR_RESTRICT pHighBand, size_t nHighStep,
607 INT16* WINPR_RESTRICT pDstBand, size_t nDstStep,
608 size_t nLowCount, size_t nHighCount, size_t nDstCount)
609{
610 INT16 H1 = 0;
611 INT16 X1 = 0;
612
613 for (size_t i = 0; i < nDstCount; i++)
614 {
615 const INT16* pL = pLowBand;
616 const INT16* pH = pHighBand;
617 INT16* pX = pDstBand;
618 INT16 H0 = *pH++;
619 INT16 L0 = *pL++;
620 INT16 X0 = clampi16((int32_t)L0 - H0);
621 INT16 X2 = clampi16((int32_t)L0 - H0);
622
623 for (size_t j = 0; j < (nHighCount - 1); j++)
624 {
625 H1 = *pH;
626 pH++;
627 L0 = *pL;
628 pL++;
629 X2 = clampi16((int32_t)L0 - ((H0 + H1) / 2));
630 X1 = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
631 pX[0] = X0;
632 pX[1] = X1;
633 pX += 2;
634 X0 = X2;
635 H0 = H1;
636 }
637
638 if (nLowCount <= (nHighCount + 1))
639 {
640 if (nLowCount <= nHighCount)
641 {
642 pX[0] = X2;
643 pX[1] = clampi16((int32_t)X2 + (2 * H0));
644 }
645 else
646 {
647 L0 = *pL;
648 pL++;
649 X0 = clampi16((int32_t)L0 - H0);
650 pX[0] = X2;
651 pX[1] = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
652 pX[2] = X0;
653 }
654 }
655 else
656 {
657 L0 = *pL;
658 pL++;
659 X0 = clampi16((int32_t)L0 - (H0 / 2));
660 pX[0] = X2;
661 pX[1] = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
662 pX[2] = X0;
663 L0 = *pL;
664 pL++;
665 pX[3] = clampi16((int32_t)(X0 + L0) / 2);
666 }
667
668 pLowBand += nLowStep;
669 pHighBand += nHighStep;
670 pDstBand += nDstStep;
671 }
672}
673
674static inline void progressive_rfx_idwt_y(const INT16* WINPR_RESTRICT pLowBand, size_t nLowStep,
675 const INT16* WINPR_RESTRICT pHighBand, size_t nHighStep,
676 INT16* WINPR_RESTRICT pDstBand, size_t nDstStep,
677 size_t nLowCount, size_t nHighCount, size_t nDstCount)
678{
679 for (size_t i = 0; i < nDstCount; i++)
680 {
681 INT16 H1 = 0;
682 INT16 X1 = 0;
683 const INT16* pL = pLowBand;
684 const INT16* pH = pHighBand;
685 INT16* pX = pDstBand;
686 INT16 H0 = *pH;
687 pH += nHighStep;
688 INT16 L0 = *pL;
689 pL += nLowStep;
690 int16_t X0 = clampi16((int32_t)L0 - H0);
691 int16_t X2 = clampi16((int32_t)L0 - H0);
692
693 for (size_t j = 0; j < (nHighCount - 1); j++)
694 {
695 H1 = *pH;
696 pH += nHighStep;
697 L0 = *pL;
698 pL += nLowStep;
699 X2 = clampi16((int32_t)L0 - ((H0 + H1) / 2));
700 X1 = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
701 *pX = X0;
702 pX += nDstStep;
703 *pX = X1;
704 pX += nDstStep;
705 X0 = X2;
706 H0 = H1;
707 }
708
709 if (nLowCount <= (nHighCount + 1))
710 {
711 if (nLowCount <= nHighCount)
712 {
713 *pX = X2;
714 pX += nDstStep;
715 *pX = clampi16((int32_t)X2 + (2 * H0));
716 }
717 else
718 {
719 L0 = *pL;
720 X0 = clampi16((int32_t)L0 - H0);
721 *pX = X2;
722 pX += nDstStep;
723 *pX = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
724 pX += nDstStep;
725 *pX = X0;
726 }
727 }
728 else
729 {
730 L0 = *pL;
731 pL += nLowStep;
732 X0 = clampi16((int32_t)L0 - (H0 / 2));
733 *pX = X2;
734 pX += nDstStep;
735 *pX = clampi16((int32_t)((X0 + X2) / 2) + (2 * H0));
736 pX += nDstStep;
737 *pX = X0;
738 pX += nDstStep;
739 L0 = *pL;
740 *pX = clampi16((int32_t)(X0 + L0) / 2);
741 }
742
743 pLowBand++;
744 pHighBand++;
745 pDstBand++;
746 }
747}
748
749static inline size_t progressive_rfx_get_band_l_count(size_t level)
750{
751 return (64 >> level) + 1;
752}
753
754static inline size_t progressive_rfx_get_band_h_count(size_t level)
755{
756 if (level == 1)
757 return (64 >> 1) - 1;
758 else
759 return (64 + (1u << (level - 1))) >> level;
760}
761
762static inline void progressive_rfx_dwt_2d_decode_block(INT16* WINPR_RESTRICT buffer,
763 INT16* WINPR_RESTRICT temp, size_t level)
764{
765 size_t nDstStepX = 0;
766 size_t nDstStepY = 0;
767 const INT16* WINPR_RESTRICT HL = nullptr;
768 const INT16* WINPR_RESTRICT LH = nullptr;
769 const INT16* WINPR_RESTRICT HH = nullptr;
770 INT16* WINPR_RESTRICT LL = nullptr;
771 INT16* WINPR_RESTRICT L = nullptr;
772 INT16* WINPR_RESTRICT H = nullptr;
773 INT16* WINPR_RESTRICT LLx = nullptr;
774
775 const size_t nBandL = progressive_rfx_get_band_l_count(level);
776 const size_t nBandH = progressive_rfx_get_band_h_count(level);
777 size_t offset = 0;
778
779 HL = &buffer[offset];
780 offset += (nBandH * nBandL);
781 LH = &buffer[offset];
782 offset += (nBandL * nBandH);
783 HH = &buffer[offset];
784 offset += (nBandH * nBandH);
785 LL = &buffer[offset];
786 nDstStepX = (nBandL + nBandH);
787 nDstStepY = (nBandL + nBandH);
788 offset = 0;
789 L = &temp[offset];
790 offset += (nBandL * nDstStepX);
791 H = &temp[offset];
792 LLx = &buffer[0];
793
794 /* horizontal (LL + HL -> L) */
795 progressive_rfx_idwt_x(LL, nBandL, HL, nBandH, L, nDstStepX, nBandL, nBandH, nBandL);
796
797 /* horizontal (LH + HH -> H) */
798 progressive_rfx_idwt_x(LH, nBandL, HH, nBandH, H, nDstStepX, nBandL, nBandH, nBandH);
799
800 /* vertical (L + H -> LL) */
801 progressive_rfx_idwt_y(L, nDstStepX, H, nDstStepX, LLx, nDstStepY, nBandL, nBandH,
802 nBandL + nBandH);
803}
804
805void rfx_dwt_2d_extrapolate_decode(INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT dwt_buffer)
806{
807 WINPR_ASSERT(buffer);
808 WINPR_ASSERT(dwt_buffer);
809 progressive_rfx_dwt_2d_decode_block(&buffer[3807], dwt_buffer, 3);
810 progressive_rfx_dwt_2d_decode_block(&buffer[3007], dwt_buffer, 2);
811 progressive_rfx_dwt_2d_decode_block(&buffer[0], dwt_buffer, 1);
812}
813
814static inline int progressive_rfx_dwt_2d_decode(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
815 INT16* WINPR_RESTRICT buffer,
816 INT16* WINPR_RESTRICT current, BOOL coeffDiff,
817 BOOL extrapolate, BOOL reverse)
818{
819 const primitives_t* prims = primitives_get();
820
821 if (!progressive || !buffer || !current)
822 return -1;
823
824 const uint32_t belements = 4096;
825 const uint32_t bsize = belements * sizeof(INT16);
826 if (reverse)
827 memcpy(buffer, current, bsize);
828 else if (!coeffDiff)
829 memcpy(current, buffer, bsize);
830 else
831 {
832 const pstatus_t rc = prims->add_16s_inplace(buffer, current, belements);
833 if (rc != PRIMITIVES_SUCCESS)
834 return -1;
835 }
836
837 INT16* temp = (INT16*)BufferPool_Take(progressive->bufferPool, -1); /* DWT buffer */
838
839 if (!temp)
840 return -2;
841
842 if (!extrapolate)
843 {
844 progressive->rfx_context->dwt_2d_decode(buffer, temp);
845 }
846 else
847 {
848 WINPR_ASSERT(progressive->rfx_context->dwt_2d_extrapolate_decode);
849 progressive->rfx_context->dwt_2d_extrapolate_decode(buffer, temp);
850 }
851 BufferPool_Return(progressive->bufferPool, temp);
852 return 1;
853}
854
855static inline BOOL progressive_rfx_decode_block(const primitives_t* prims,
856 INT16* WINPR_RESTRICT buffer, UINT32 length,
857 UINT32 shift)
858{
859 if (shift == 0)
860 return TRUE;
861
862 return prims->lShiftC_16s_inplace(buffer, shift, length) == PRIMITIVES_SUCCESS;
863}
864
865static inline int
866progressive_rfx_decode_component(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
867 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT shift,
868 const BYTE* WINPR_RESTRICT data, UINT32 length,
869 INT16* WINPR_RESTRICT buffer, INT16* WINPR_RESTRICT current,
870 INT16* WINPR_RESTRICT sign, BOOL coeffDiff,
871 WINPR_ATTR_UNUSED BOOL subbandDiff, BOOL extrapolate)
872{
873 int status = 0;
874 const primitives_t* prims = primitives_get();
875
876 status = progressive->rfx_context->rlgr_decode(RLGR1, data, length, buffer, 4096);
877
878 if (status < 0)
879 return status;
880
881 CopyMemory(sign, buffer, 4096ULL * 2ULL);
882 if (!extrapolate)
883 {
884 if (!rfx_differential_decode(buffer + 4032, 64))
885 return -1;
886 if (!progressive_rfx_decode_block(prims, &buffer[0], 1024, shift->HL1)) /* HL1 */
887 return -1;
888 if (!progressive_rfx_decode_block(prims, &buffer[1024], 1024, shift->LH1)) /* LH1 */
889 return -1;
890 if (!progressive_rfx_decode_block(prims, &buffer[2048], 1024, shift->HH1)) /* HH1 */
891 return -1;
892 if (!progressive_rfx_decode_block(prims, &buffer[3072], 256, shift->HL2)) /* HL2 */
893 return -1;
894 if (!progressive_rfx_decode_block(prims, &buffer[3328], 256, shift->LH2)) /* LH2 */
895 return -1;
896 if (!progressive_rfx_decode_block(prims, &buffer[3584], 256, shift->HH2)) /* HH2 */
897 return -1;
898 if (!progressive_rfx_decode_block(prims, &buffer[3840], 64, shift->HL3)) /* HL3 */
899 return -1;
900 if (!progressive_rfx_decode_block(prims, &buffer[3904], 64, shift->LH3)) /* LH3 */
901 return -1;
902 if (!progressive_rfx_decode_block(prims, &buffer[3968], 64, shift->HH3)) /* HH3 */
903 return -1;
904 if (!progressive_rfx_decode_block(prims, &buffer[4032], 64, shift->LL3)) /* LL3 */
905 return -1;
906 }
907 else
908 {
909 if (!progressive_rfx_decode_block(prims, &buffer[0], 1023, shift->HL1)) /* HL1 */
910 return -1;
911 if (!progressive_rfx_decode_block(prims, &buffer[1023], 1023, shift->LH1)) /* LH1 */
912 return -1;
913 if (!progressive_rfx_decode_block(prims, &buffer[2046], 961, shift->HH1)) /* HH1 */
914 return -1;
915 if (!progressive_rfx_decode_block(prims, &buffer[3007], 272, shift->HL2)) /* HL2 */
916 return -1;
917 if (!progressive_rfx_decode_block(prims, &buffer[3279], 272, shift->LH2)) /* LH2 */
918 return -1;
919 if (!progressive_rfx_decode_block(prims, &buffer[3551], 256, shift->HH2)) /* HH2 */
920 return -1;
921 if (!progressive_rfx_decode_block(prims, &buffer[3807], 72, shift->HL3)) /* HL3 */
922 return -1;
923 if (!progressive_rfx_decode_block(prims, &buffer[3879], 72, shift->LH3)) /* LH3 */
924 return -1;
925 if (!progressive_rfx_decode_block(prims, &buffer[3951], 64, shift->HH3)) /* HH3 */
926 return -1;
927 if (!rfx_differential_decode(&buffer[4015], 81)) /* LL3 */
928 return -1;
929 if (!progressive_rfx_decode_block(prims, &buffer[4015], 81, shift->LL3)) /* LL3 */
930 return -1;
931 }
932 return progressive_rfx_dwt_2d_decode(progressive, buffer, current, coeffDiff, extrapolate,
933 FALSE);
934}
935
936static inline int
937progressive_decompress_tile_first(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
938 RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile,
939 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
940 const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
941{
942 int rc = 0;
943 BOOL diff = 0;
944 BOOL sub = 0;
945 BOOL extrapolate = 0;
946 BYTE* pBuffer = nullptr;
947 INT16* pSign[3];
948 INT16* pSrcDst[3];
949 INT16* pCurrent[3];
950 RFX_COMPONENT_CODEC_QUANT shiftY = WINPR_C_ARRAY_INIT;
951 RFX_COMPONENT_CODEC_QUANT shiftCb = WINPR_C_ARRAY_INIT;
952 RFX_COMPONENT_CODEC_QUANT shiftCr = WINPR_C_ARRAY_INIT;
953 RFX_COMPONENT_CODEC_QUANT* quantY = nullptr;
954 RFX_COMPONENT_CODEC_QUANT* quantCb = nullptr;
955 RFX_COMPONENT_CODEC_QUANT* quantCr = nullptr;
956 RFX_COMPONENT_CODEC_QUANT* quantProgY = nullptr;
957 RFX_COMPONENT_CODEC_QUANT* quantProgCb = nullptr;
958 RFX_COMPONENT_CODEC_QUANT* quantProgCr = nullptr;
959 RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal = nullptr;
960 static const prim_size_t roi_64x64 = { 64, 64 };
961 const primitives_t* prims = primitives_get();
962
963 tile->pass = 1;
964 diff = tile->flags & RFX_TILE_DIFFERENCE;
965 sub = context->flags & RFX_SUBBAND_DIFFING;
966 extrapolate = region->flags & RFX_DWT_REDUCE_EXTRAPOLATE;
967
968#if defined(WITH_DEBUG_CODECS)
969 WLog_Print(progressive->log, WLOG_DEBUG,
970 "ProgressiveTile%s: quantIdx Y: %" PRIu8 " Cb: %" PRIu8 " Cr: %" PRIu8
971 " xIdx: %" PRIu16 " yIdx: %" PRIu16 " flags: 0x%02" PRIX8 " quality: %" PRIu8
972 " yLen: %" PRIu16 " cbLen: %" PRIu16 " crLen: %" PRIu16 " tailLen: %" PRIu16 "",
973 (tile->blockType == PROGRESSIVE_WBT_TILE_FIRST) ? "First" : "Simple",
974 tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx, tile->yIdx,
975 tile->flags, tile->quality, tile->yLen, tile->cbLen, tile->crLen, tile->tailLen);
976#endif
977
978 if (tile->quantIdxY >= region->numQuant)
979 {
980 WLog_ERR(TAG, "quantIdxY %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxY, region->numQuant);
981 return -1;
982 }
983
984 quantY = &(region->quantVals[tile->quantIdxY]);
985
986 if (tile->quantIdxCb >= region->numQuant)
987 {
988 WLog_ERR(TAG, "quantIdxCb %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCb,
989 region->numQuant);
990 return -1;
991 }
992
993 quantCb = &(region->quantVals[tile->quantIdxCb]);
994
995 if (tile->quantIdxCr >= region->numQuant)
996 {
997 WLog_ERR(TAG, "quantIdxCr %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCr,
998 region->numQuant);
999 return -1;
1000 }
1001
1002 quantCr = &(region->quantVals[tile->quantIdxCr]);
1003
1004 if (tile->quality == 0xFF)
1005 {
1006 quantProgVal = &(progressive->quantProgValFull);
1007 }
1008 else
1009 {
1010 if (tile->quality >= region->numProgQuant)
1011 {
1012 WLog_ERR(TAG, "quality %" PRIu8 " > numProgQuant %" PRIu8, tile->quality,
1013 region->numProgQuant);
1014 return -1;
1015 }
1016
1017 quantProgVal = &(region->quantProgVals[tile->quality]);
1018 }
1019
1020 quantProgY = &(quantProgVal->yQuantValues);
1021 quantProgCb = &(quantProgVal->cbQuantValues);
1022 quantProgCr = &(quantProgVal->crQuantValues);
1023
1024 tile->yQuant = *quantY;
1025 tile->cbQuant = *quantCb;
1026 tile->crQuant = *quantCr;
1027 tile->yProgQuant = *quantProgY;
1028 tile->cbProgQuant = *quantProgCb;
1029 tile->crProgQuant = *quantProgCr;
1030
1031 progressive_rfx_quant_add(quantY, quantProgY, &(tile->yBitPos));
1032 progressive_rfx_quant_add(quantCb, quantProgCb, &(tile->cbBitPos));
1033 progressive_rfx_quant_add(quantCr, quantProgCr, &(tile->crBitPos));
1034 progressive_rfx_quant_add(quantY, quantProgY, &shiftY);
1035 if (!progressive_rfx_quant_lsub(&shiftY, 1)) /* -6 + 5 = -1 */
1036 goto fail;
1037 progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);
1038 if (!progressive_rfx_quant_lsub(&shiftCb, 1)) /* -6 + 5 = -1 */
1039 goto fail;
1040 progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);
1041 if (!progressive_rfx_quant_lsub(&shiftCr, 1)) /* -6 + 5 = -1 */
1042 goto fail;
1043
1044 pSign[0] =
1045 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->sign[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1046 pSign[1] =
1047 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->sign[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1048 pSign[2] =
1049 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->sign[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1050
1051 pCurrent[0] =
1052 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->current[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1053 pCurrent[1] =
1054 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->current[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1055 pCurrent[2] =
1056 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->current[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1057
1058 pBuffer = (BYTE*)BufferPool_Take(progressive->bufferPool, -1);
1059 pSrcDst[0] =
1060 WINPR_PACKED_ALIGN_CAST(INT16*, (&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1061 pSrcDst[1] =
1062 WINPR_PACKED_ALIGN_CAST(INT16*, (&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1063 pSrcDst[2] =
1064 WINPR_PACKED_ALIGN_CAST(INT16*, (&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1065
1066 rc = progressive_rfx_decode_component(progressive, &shiftY, tile->yData, tile->yLen, pSrcDst[0],
1067 pCurrent[0], pSign[0], diff, sub, extrapolate); /* Y */
1068 if (rc < 0)
1069 goto fail;
1070 rc = progressive_rfx_decode_component(progressive, &shiftCb, tile->cbData, tile->cbLen,
1071 pSrcDst[1], pCurrent[1], pSign[1], diff, sub,
1072 extrapolate); /* Cb */
1073 if (rc < 0)
1074 goto fail;
1075 rc = progressive_rfx_decode_component(progressive, &shiftCr, tile->crData, tile->crLen,
1076 pSrcDst[2], pCurrent[2], pSign[2], diff, sub,
1077 extrapolate); /* Cr */
1078 if (rc < 0)
1079 goto fail;
1080
1081 {
1082 const INT16** ptr = WINPR_REINTERPRET_CAST(pSrcDst, INT16**, const INT16**);
1083 rc = prims->yCbCrToRGB_16s8u_P3AC4R(ptr, 64 * 2, tile->data, tile->stride,
1084 progressive->format, &roi_64x64);
1085 }
1086fail:
1087 BufferPool_Return(progressive->bufferPool, pBuffer);
1088 return rc;
1089}
1090
1091static inline INT16 progressive_rfx_srl_read(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state,
1092 UINT32 numBits)
1093{
1094 WINPR_ASSERT(state);
1095
1096 wBitStream* bs = state->srl;
1097 WINPR_ASSERT(bs);
1098
1099 if (state->nz)
1100 {
1101 state->nz--;
1102 return 0;
1103 }
1104
1105 const UINT32 k = state->kp / 8;
1106
1107 if (!state->mode)
1108 {
1109 /* zero encoding */
1110 const UINT32 bit = (bs->accumulator & 0x80000000) ? 1 : 0;
1111 BitStream_Shift(bs, 1);
1112
1113 if (!bit)
1114 {
1115 /* '0' bit, nz >= (1 << k), nz = (1 << k) */
1116 state->nz = (1 << k);
1117 state->kp += 4;
1118
1119 if (state->kp > 80)
1120 state->kp = 80;
1121
1122 state->nz--;
1123 return 0;
1124 }
1125 else
1126 {
1127 /* '1' bit, nz < (1 << k), nz = next k bits */
1128 state->nz = 0;
1129 state->mode = 1; /* unary encoding is next */
1130
1131 if (k)
1132 {
1133 bs->mask = ((1u << k) - 1);
1134 state->nz =
1135 WINPR_ASSERTING_INT_CAST(int16_t, ((bs->accumulator >> (32u - k)) & bs->mask));
1136 BitStream_Shift(bs, k);
1137 }
1138
1139 if (state->nz)
1140 {
1141 state->nz--;
1142 return 0;
1143 }
1144 }
1145 }
1146
1147 state->mode = 0; /* zero encoding is next */
1148 /* unary encoding */
1149 /* read sign bit */
1150 const UINT32 sign = (bs->accumulator & 0x80000000) ? 1 : 0;
1151 BitStream_Shift(bs, 1);
1152
1153 if (state->kp < 6)
1154 state->kp = 0;
1155 else
1156 state->kp -= 6;
1157
1158 if (numBits == 1)
1159 return sign ? -1 : 1;
1160
1161 UINT32 mag = 1;
1162 const UINT32 max = (1u << numBits) - 1;
1163
1164 while (mag < max)
1165 {
1166 const UINT32 bit = (bs->accumulator & 0x80000000) ? 1 : 0;
1167 BitStream_Shift(bs, 1);
1168
1169 if (bit)
1170 break;
1171
1172 mag++;
1173 }
1174
1175 if (mag > INT16_MAX)
1176 mag = INT16_MAX;
1177 return (INT16)(sign ? -1 * (int)mag : (INT16)mag);
1178}
1179
1180static inline int
1181progressive_rfx_upgrade_state_finish(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state)
1182{
1183 UINT32 pad = 0;
1184 wBitStream* srl = nullptr;
1185 wBitStream* raw = nullptr;
1186 if (!state)
1187 return -1;
1188
1189 srl = state->srl;
1190 raw = state->raw;
1191 /* Read trailing bits from RAW/SRL bit streams */
1192 pad = (raw->position % 8) ? (8 - (raw->position % 8)) : 0;
1193
1194 if (pad)
1195 BitStream_Shift(raw, pad);
1196
1197 pad = (srl->position % 8) ? (8 - (srl->position % 8)) : 0;
1198
1199 if (pad)
1200 BitStream_Shift(srl, pad);
1201
1202 if (BitStream_GetRemainingLength(srl) == 8)
1203 BitStream_Shift(srl, 8);
1204
1205 return 1;
1206}
1207
1208static inline int16_t rawShift(wBitStream* raw, UINT32 numBits)
1209{
1210 WINPR_ASSERT(raw);
1211 WINPR_ASSERT(numBits > 0);
1212
1213 raw->mask = ((1u << numBits) - 1);
1214 const int16_t input = (int16_t)((raw->accumulator >> (32 - numBits)) & raw->mask);
1215 BitStream_Shift(raw, numBits);
1216 return input;
1217}
1218
1219static inline int progressive_rfx_upgrade_block(RFX_PROGRESSIVE_UPGRADE_STATE* WINPR_RESTRICT state,
1220 INT16* WINPR_RESTRICT buffer,
1221 INT16* WINPR_RESTRICT sign, UINT32 length,
1222 UINT32 shift, WINPR_ATTR_UNUSED UINT32 bitPos,
1223 UINT32 numBits)
1224{
1225 if (numBits < 1)
1226 return 1;
1227
1228 wBitStream* raw = state->raw;
1229 int32_t input = 0;
1230
1231 if (!state->nonLL)
1232 {
1233 for (UINT32 index = 0; index < length; index++)
1234 {
1235 input = rawShift(raw, numBits);
1236
1237 const int32_t shifted = input << shift;
1238 const int32_t val = buffer[index] + shifted;
1239 const int16_t ival = WINPR_ASSERTING_INT_CAST(int16_t, val);
1240 buffer[index] = ival;
1241 }
1242
1243 return 1;
1244 }
1245
1246 for (UINT32 index = 0; index < length; index++)
1247 {
1248 if (sign[index] > 0)
1249 {
1250 /* sign > 0, read from raw */
1251 input = rawShift(raw, numBits);
1252 }
1253 else if (sign[index] < 0)
1254 {
1255 /* sign < 0, read from raw */
1256 input = rawShift(raw, numBits);
1257 input *= -1;
1258 }
1259 else
1260 {
1261 /* sign == 0, read from srl */
1262 input = progressive_rfx_srl_read(state, numBits);
1263 sign[index] = WINPR_ASSERTING_INT_CAST(int16_t, input);
1264 }
1265
1266 const int32_t val = input << shift;
1267 const int32_t ival = buffer[index] + val;
1268 buffer[index] = WINPR_ASSERTING_INT_CAST(INT16, ival);
1269 }
1270
1271 return 1;
1272}
1273
1274static inline int progressive_rfx_upgrade_component(
1275 PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1276 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT shift,
1277 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT bitPos,
1278 const RFX_COMPONENT_CODEC_QUANT* WINPR_RESTRICT numBits, INT16* WINPR_RESTRICT buffer,
1279 INT16* WINPR_RESTRICT current, INT16* WINPR_RESTRICT sign, const BYTE* WINPR_RESTRICT srlData,
1280 UINT32 srlLen, const BYTE* WINPR_RESTRICT rawData, UINT32 rawLen, BOOL coeffDiff,
1281 WINPR_ATTR_UNUSED BOOL subbandDiff, BOOL extrapolate)
1282{
1283 int rc = 0;
1284 wBitStream s_srl = WINPR_C_ARRAY_INIT;
1285 wBitStream s_raw = WINPR_C_ARRAY_INIT;
1286 RFX_PROGRESSIVE_UPGRADE_STATE state = WINPR_C_ARRAY_INIT;
1287
1288 state.kp = 8;
1289 state.mode = 0;
1290 state.srl = &s_srl;
1291 state.raw = &s_raw;
1292 BitStream_Attach(state.srl, srlData, srlLen);
1293 BitStream_Fetch(state.srl);
1294 BitStream_Attach(state.raw, rawData, rawLen);
1295 BitStream_Fetch(state.raw);
1296
1297 state.nonLL = TRUE;
1298 rc = progressive_rfx_upgrade_block(&state, &current[0], &sign[0], 1023, shift->HL1, bitPos->HL1,
1299 numBits->HL1); /* HL1 */
1300 if (rc < 0)
1301 return rc;
1302 rc = progressive_rfx_upgrade_block(&state, &current[1023], &sign[1023], 1023, shift->LH1,
1303 bitPos->LH1, numBits->LH1); /* LH1 */
1304 if (rc < 0)
1305 return rc;
1306 rc = progressive_rfx_upgrade_block(&state, &current[2046], &sign[2046], 961, shift->HH1,
1307 bitPos->HH1, numBits->HH1); /* HH1 */
1308 if (rc < 0)
1309 return rc;
1310 rc = progressive_rfx_upgrade_block(&state, &current[3007], &sign[3007], 272, shift->HL2,
1311 bitPos->HL2, numBits->HL2); /* HL2 */
1312 if (rc < 0)
1313 return rc;
1314 rc = progressive_rfx_upgrade_block(&state, &current[3279], &sign[3279], 272, shift->LH2,
1315 bitPos->LH2, numBits->LH2); /* LH2 */
1316 if (rc < 0)
1317 return rc;
1318 rc = progressive_rfx_upgrade_block(&state, &current[3551], &sign[3551], 256, shift->HH2,
1319 bitPos->HH2, numBits->HH2); /* HH2 */
1320 if (rc < 0)
1321 return rc;
1322 rc = progressive_rfx_upgrade_block(&state, &current[3807], &sign[3807], 72, shift->HL3,
1323 bitPos->HL3, numBits->HL3); /* HL3 */
1324 if (rc < 0)
1325 return rc;
1326 rc = progressive_rfx_upgrade_block(&state, &current[3879], &sign[3879], 72, shift->LH3,
1327 bitPos->LH3, numBits->LH3); /* LH3 */
1328 if (rc < 0)
1329 return rc;
1330 rc = progressive_rfx_upgrade_block(&state, &current[3951], &sign[3951], 64, shift->HH3,
1331 bitPos->HH3, numBits->HH3); /* HH3 */
1332 if (rc < 0)
1333 return rc;
1334
1335 state.nonLL = FALSE;
1336 rc = progressive_rfx_upgrade_block(&state, &current[4015], &sign[4015], 81, shift->LL3,
1337 bitPos->LL3, numBits->LL3); /* LL3 */
1338 if (rc < 0)
1339 return rc;
1340 rc = progressive_rfx_upgrade_state_finish(&state);
1341 if (rc < 0)
1342 return rc;
1343 return progressive_rfx_dwt_2d_decode(progressive, buffer, current, coeffDiff, extrapolate,
1344 TRUE);
1345}
1346
1347static inline int
1348progressive_decompress_tile_upgrade(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
1349 RFX_PROGRESSIVE_TILE* WINPR_RESTRICT tile,
1350 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region,
1351 const PROGRESSIVE_BLOCK_CONTEXT* WINPR_RESTRICT context)
1352{
1353 int status = 0;
1354 BOOL coeffDiff = 0;
1355 BOOL sub = 0;
1356 BOOL extrapolate = 0;
1357 BYTE* pBuffer = nullptr;
1358 INT16* pSign[3] = WINPR_C_ARRAY_INIT;
1359 INT16* pSrcDst[3] = WINPR_C_ARRAY_INIT;
1360 INT16* pCurrent[3] = WINPR_C_ARRAY_INIT;
1361 RFX_COMPONENT_CODEC_QUANT shiftY = WINPR_C_ARRAY_INIT;
1362 RFX_COMPONENT_CODEC_QUANT shiftCb = WINPR_C_ARRAY_INIT;
1363 RFX_COMPONENT_CODEC_QUANT shiftCr = WINPR_C_ARRAY_INIT;
1364 RFX_COMPONENT_CODEC_QUANT yBitPos = WINPR_C_ARRAY_INIT;
1365 RFX_COMPONENT_CODEC_QUANT cbBitPos = WINPR_C_ARRAY_INIT;
1366 RFX_COMPONENT_CODEC_QUANT crBitPos = WINPR_C_ARRAY_INIT;
1367 RFX_COMPONENT_CODEC_QUANT yNumBits = WINPR_C_ARRAY_INIT;
1368 RFX_COMPONENT_CODEC_QUANT cbNumBits = WINPR_C_ARRAY_INIT;
1369 RFX_COMPONENT_CODEC_QUANT crNumBits = WINPR_C_ARRAY_INIT;
1370 RFX_COMPONENT_CODEC_QUANT* quantY = nullptr;
1371 RFX_COMPONENT_CODEC_QUANT* quantCb = nullptr;
1372 RFX_COMPONENT_CODEC_QUANT* quantCr = nullptr;
1373 RFX_COMPONENT_CODEC_QUANT* quantProgY = nullptr;
1374 RFX_COMPONENT_CODEC_QUANT* quantProgCb = nullptr;
1375 RFX_COMPONENT_CODEC_QUANT* quantProgCr = nullptr;
1376 RFX_PROGRESSIVE_CODEC_QUANT* quantProg = nullptr;
1377 static const prim_size_t roi_64x64 = { 64, 64 };
1378 const primitives_t* prims = primitives_get();
1379
1380 coeffDiff = tile->flags & RFX_TILE_DIFFERENCE;
1381 sub = context->flags & RFX_SUBBAND_DIFFING;
1382 extrapolate = region->flags & RFX_DWT_REDUCE_EXTRAPOLATE;
1383
1384 tile->pass++;
1385
1386#if defined(WITH_DEBUG_CODECS)
1387 WLog_Print(progressive->log, WLOG_DEBUG,
1388 "ProgressiveTileUpgrade: pass: %" PRIu16 " quantIdx Y: %" PRIu8 " Cb: %" PRIu8
1389 " Cr: %" PRIu8 " xIdx: %" PRIu16 " yIdx: %" PRIu16 " quality: %" PRIu8
1390 " ySrlLen: %" PRIu16 " yRawLen: %" PRIu16 " cbSrlLen: %" PRIu16 " cbRawLen: %" PRIu16
1391 " crSrlLen: %" PRIu16 " crRawLen: %" PRIu16 "",
1392 tile->pass, tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx,
1393 tile->yIdx, tile->quality, tile->ySrlLen, tile->yRawLen, tile->cbSrlLen,
1394 tile->cbRawLen, tile->crSrlLen, tile->crRawLen);
1395#endif
1396
1397 if (tile->quantIdxY >= region->numQuant)
1398 {
1399 WLog_ERR(TAG, "quantIdxY %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxY, region->numQuant);
1400 return -1;
1401 }
1402
1403 quantY = &(region->quantVals[tile->quantIdxY]);
1404
1405 if (tile->quantIdxCb >= region->numQuant)
1406 {
1407 WLog_ERR(TAG, "quantIdxCb %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCb,
1408 region->numQuant);
1409 return -1;
1410 }
1411
1412 quantCb = &(region->quantVals[tile->quantIdxCb]);
1413
1414 if (tile->quantIdxCr >= region->numQuant)
1415 {
1416 WLog_ERR(TAG, "quantIdxCr %" PRIu8 " > numQuant %" PRIu8, tile->quantIdxCr,
1417 region->numQuant);
1418 return -1;
1419 }
1420
1421 quantCr = &(region->quantVals[tile->quantIdxCr]);
1422
1423 if (tile->quality == 0xFF)
1424 {
1425 quantProg = &(progressive->quantProgValFull);
1426 }
1427 else
1428 {
1429 if (tile->quality >= region->numProgQuant)
1430 {
1431 WLog_ERR(TAG, "quality %" PRIu8 " > numProgQuant %" PRIu8, tile->quality,
1432 region->numProgQuant);
1433 return -1;
1434 }
1435
1436 quantProg = &(region->quantProgVals[tile->quality]);
1437 }
1438
1439 quantProgY = &(quantProg->yQuantValues);
1440 quantProgCb = &(quantProg->cbQuantValues);
1441 quantProgCr = &(quantProg->crQuantValues);
1442
1443 if (!progressive_rfx_quant_cmp_equal(quantY, &(tile->yQuant)))
1444 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantY has changed!");
1445
1446 if (!progressive_rfx_quant_cmp_equal(quantCb, &(tile->cbQuant)))
1447 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCb has changed!");
1448
1449 if (!progressive_rfx_quant_cmp_equal(quantCr, &(tile->crQuant)))
1450 WLog_Print(progressive->log, WLOG_WARN, "non-progressive quantCr has changed!");
1451
1452 if (!(context->flags & RFX_SUBBAND_DIFFING))
1453 WLog_WARN(TAG, "PROGRESSIVE_BLOCK_CONTEXT::flags & RFX_SUBBAND_DIFFING not set");
1454
1455 progressive_rfx_quant_add(quantY, quantProgY, &yBitPos);
1456 progressive_rfx_quant_add(quantCb, quantProgCb, &cbBitPos);
1457 progressive_rfx_quant_add(quantCr, quantProgCr, &crBitPos);
1458 if (!progressive_rfx_quant_sub(&(tile->yBitPos), &yBitPos, &yNumBits))
1459 goto fail;
1460 if (!progressive_rfx_quant_sub(&(tile->cbBitPos), &cbBitPos, &cbNumBits))
1461 goto fail;
1462 if (!progressive_rfx_quant_sub(&(tile->crBitPos), &crBitPos, &crNumBits))
1463 goto fail;
1464 progressive_rfx_quant_add(quantY, quantProgY, &shiftY);
1465 if (!progressive_rfx_quant_lsub(&shiftY, 1)) /* -6 + 5 = -1 */
1466 goto fail;
1467 progressive_rfx_quant_add(quantCb, quantProgCb, &shiftCb);
1468 if (!progressive_rfx_quant_lsub(&shiftCb, 1)) /* -6 + 5 = -1 */
1469 goto fail;
1470 progressive_rfx_quant_add(quantCr, quantProgCr, &shiftCr);
1471 if (!progressive_rfx_quant_lsub(&shiftCr, 1)) /* -6 + 5 = -1 */
1472 goto fail;
1473
1474 tile->yBitPos = yBitPos;
1475 tile->cbBitPos = cbBitPos;
1476 tile->crBitPos = crBitPos;
1477 tile->yQuant = *quantY;
1478 tile->cbQuant = *quantCb;
1479 tile->crQuant = *quantCr;
1480 tile->yProgQuant = *quantProgY;
1481 tile->cbProgQuant = *quantProgCb;
1482 tile->crProgQuant = *quantProgCr;
1483
1484 pSign[0] =
1485 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->sign[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1486 pSign[1] =
1487 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->sign[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1488 pSign[2] =
1489 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->sign[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1490
1491 pCurrent[0] =
1492 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->current[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1493 pCurrent[1] =
1494 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->current[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1495 pCurrent[2] =
1496 WINPR_PACKED_ALIGN_CAST(INT16*, (&tile->current[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
1497
1498 pBuffer = (BYTE*)BufferPool_Take(progressive->bufferPool, -1);
1499 pSrcDst[0] =
1500 WINPR_PACKED_ALIGN_CAST(INT16*, (&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
1501 pSrcDst[1] =
1502 WINPR_PACKED_ALIGN_CAST(INT16*, (&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
1503 pSrcDst[2] =
1504 WINPR_PACKED_ALIGN_CAST(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 = FALSE;
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 const RECTANGLE_16* rect = &updateRects[j];
2404 if (rect->left < updateRect.left)
2405 goto fail;
2406 const UINT32 nXSrc = rect->left - updateRect.left;
2407 const UINT32 nYSrc = rect->top - updateRect.top;
2408 const UINT32 width = rect->right - rect->left;
2409 const UINT32 height = rect->bottom - rect->top;
2410
2411 if (rect->left + width > surface->width)
2412 goto fail;
2413 if (rect->top + height > surface->height)
2414 goto fail;
2415 const BOOL res = freerdp_image_copy_no_overlap(
2416 pDstData, DstFormat, nDstStep, rect->left, rect->top, width, height, tile->data,
2417 progressive->format, tile->stride, nXSrc, nYSrc, nullptr, FREERDP_KEEP_DST_ALPHA);
2418 if (!res)
2419 goto fail;
2420
2421 if (invalidRegion)
2422 {
2423 if (!region16_union_rect(invalidRegion, invalidRegion, rect))
2424 {
2425 region16_uninit(&updateRegion);
2426 goto fail;
2427 }
2428 }
2429 }
2430
2431 region16_uninit(&updateRegion);
2432 tile->dirty = FALSE;
2433 }
2434
2435 rc = TRUE;
2436
2437fail:
2438 region16_uninit(&clippingRects);
2439 return rc;
2440}
2441
2442INT32 progressive_decompress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2443 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize,
2444 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStep,
2445 UINT32 nXDst, UINT32 nYDst, REGION16* WINPR_RESTRICT invalidRegion,
2446 UINT16 surfaceId, UINT32 frameId)
2447{
2448 INT32 rc = -1;
2449
2450 WINPR_ASSERT(progressive);
2451 PROGRESSIVE_SURFACE_CONTEXT* surface = progressive_get_surface_data(progressive, surfaceId);
2452
2453 if (!surface)
2454 {
2455 WLog_Print(progressive->log, WLOG_ERROR, "ProgressiveRegion no surface for %" PRIu16,
2456 surfaceId);
2457 return -1001;
2458 }
2459
2460 PROGRESSIVE_BLOCK_REGION* WINPR_RESTRICT region = &progressive->region;
2461 WINPR_ASSERT(region);
2462
2463 if (surface->frameId != frameId)
2464 {
2465 surface->frameId = frameId;
2466 surface->numUpdatedTiles = 0;
2467 }
2468
2469 wStream ss = WINPR_C_ARRAY_INIT;
2470 wStream* s = Stream_StaticConstInit(&ss, pSrcData, SrcSize);
2471 WINPR_ASSERT(s);
2472
2473 switch (DstFormat)
2474 {
2475 case PIXEL_FORMAT_RGBA32:
2476 case PIXEL_FORMAT_RGBX32:
2477 case PIXEL_FORMAT_BGRA32:
2478 case PIXEL_FORMAT_BGRX32:
2479 progressive->format = DstFormat;
2480 break;
2481 default:
2482 progressive->format = PIXEL_FORMAT_XRGB32;
2483 break;
2484 }
2485
2486 const size_t start = Stream_GetPosition(s);
2487 progressive->state = 0; /* Set state to not initialized */
2488 while (Stream_GetRemainingLength(s) > 0)
2489 {
2490 if (progressive_parse_block(progressive, s, surface, region) < 0)
2491 goto fail;
2492 }
2493
2494 {
2495 const size_t end = Stream_GetPosition(s);
2496 if ((end - start) != SrcSize)
2497 {
2498 WLog_Print(progressive->log, WLOG_ERROR,
2499 "total block len %" PRIuz " does not match read data %" PRIu32, end - start,
2500 SrcSize);
2501 rc = -1041;
2502 goto fail;
2503 }
2504 }
2505
2506 if (!update_tiles(progressive, surface, pDstData, DstFormat, nDstStep, nXDst, nYDst, region,
2507 invalidRegion))
2508 return -2002;
2509
2510 rc = 1;
2511fail:
2512 return rc;
2513}
2514
2515BOOL progressive_rfx_write_message_progressive_simple(
2516 PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive, wStream* WINPR_RESTRICT s,
2517 const RFX_MESSAGE* WINPR_RESTRICT msg)
2518{
2519 RFX_CONTEXT* context = nullptr;
2520
2521 WINPR_ASSERT(progressive);
2522 WINPR_ASSERT(s);
2523 WINPR_ASSERT(msg);
2524 context = progressive->rfx_context;
2525 return rfx_write_message_progressive_simple(context, s, msg);
2526}
2527
2528int progressive_compress(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive,
2529 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize, UINT32 SrcFormat,
2530 UINT32 Width, UINT32 Height, UINT32 ScanLine,
2531 const REGION16* WINPR_RESTRICT invalidRegion,
2532 BYTE** WINPR_RESTRICT ppDstData, UINT32* WINPR_RESTRICT pDstSize)
2533{
2534 BOOL rc = FALSE;
2535 int res = -6;
2536 wStream* s = nullptr;
2537 UINT32 numRects = 0;
2538 RFX_RECT* rects = nullptr;
2539 RFX_MESSAGE* message = nullptr;
2540
2541 if (!progressive || !pSrcData || !ppDstData || !pDstSize)
2542 {
2543 return -1;
2544 }
2545
2546 if (ScanLine == 0)
2547 {
2548 switch (SrcFormat)
2549 {
2550 case PIXEL_FORMAT_ABGR32:
2551 case PIXEL_FORMAT_ARGB32:
2552 case PIXEL_FORMAT_XBGR32:
2553 case PIXEL_FORMAT_XRGB32:
2554 case PIXEL_FORMAT_BGRA32:
2555 case PIXEL_FORMAT_BGRX32:
2556 case PIXEL_FORMAT_RGBA32:
2557 case PIXEL_FORMAT_RGBX32:
2558 ScanLine = Width * 4;
2559 break;
2560 default:
2561 return -2;
2562 }
2563 }
2564
2565 if (SrcSize < Height * ScanLine)
2566 return -4;
2567
2568 if (!invalidRegion)
2569 {
2570 numRects = (Width + 63) / 64;
2571 numRects *= (Height + 63) / 64;
2572 }
2573 else
2574 {
2575 const int nr = region16_n_rects(invalidRegion);
2576 numRects = WINPR_ASSERTING_INT_CAST(uint32_t, nr);
2577 }
2578
2579 if (numRects == 0)
2580 return 0;
2581
2582 if (!Stream_EnsureRemainingCapacity(progressive->rects, numRects * sizeof(RFX_RECT)))
2583 return -5;
2584 rects = Stream_BufferAs(progressive->rects, RFX_RECT);
2585 if (invalidRegion)
2586 {
2587 const RECTANGLE_16* region_rects = region16_rects(invalidRegion, nullptr);
2588 for (UINT32 idx = 0; idx < numRects; idx++)
2589 {
2590 const RECTANGLE_16* r = &region_rects[idx];
2591 RFX_RECT* rect = &rects[idx];
2592
2593 rect->x = r->left;
2594 rect->y = r->top;
2595 rect->width = r->right - r->left;
2596 rect->height = r->bottom - r->top;
2597 }
2598 }
2599 else
2600 {
2601 UINT16 x = 0;
2602 UINT16 y = 0;
2603
2604 for (UINT32 i = 0; i < numRects; i++)
2605 {
2606 RFX_RECT* r = &rects[i];
2607 r->x = x;
2608 r->y = y;
2609
2610 WINPR_ASSERT(Width >= x);
2611 WINPR_ASSERT(Height >= y);
2612 r->width = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Width - x));
2613 r->height = MIN(64, WINPR_ASSERTING_INT_CAST(UINT16, Height - y));
2614
2615 if (x + 64UL >= Width)
2616 {
2617 y += 64;
2618 x = 0;
2619 }
2620 else
2621 x += 64;
2622
2623 WINPR_ASSERT(r->x % 64 == 0);
2624 WINPR_ASSERT(r->y % 64 == 0);
2625 WINPR_ASSERT(r->width <= 64);
2626 WINPR_ASSERT(r->height <= 64);
2627 }
2628 }
2629 s = progressive->buffer;
2630 Stream_ResetPosition(s);
2631
2632 progressive->rfx_context->mode = RLGR1;
2633
2634 progressive->rfx_context->width = WINPR_ASSERTING_INT_CAST(UINT16, Width);
2635 progressive->rfx_context->height = WINPR_ASSERTING_INT_CAST(UINT16, Height);
2636 rfx_context_set_pixel_format(progressive->rfx_context, SrcFormat);
2637 message = rfx_encode_message(progressive->rfx_context, rects, numRects, pSrcData, Width, Height,
2638 ScanLine);
2639 if (!message)
2640 {
2641 WLog_ERR(TAG, "failed to encode rfx message");
2642 goto fail;
2643 }
2644
2645 rc = progressive_rfx_write_message_progressive_simple(progressive, s, message);
2646 rfx_message_free(progressive->rfx_context, message);
2647 if (!rc)
2648 goto fail;
2649
2650 {
2651 const size_t pos = Stream_GetPosition(s);
2652 WINPR_ASSERT(pos <= UINT32_MAX);
2653 *pDstSize = (UINT32)pos;
2654 }
2655 *ppDstData = Stream_Buffer(s);
2656 res = 1;
2657fail:
2658 return res;
2659}
2660
2661BOOL progressive_context_reset(PROGRESSIVE_CONTEXT* WINPR_RESTRICT progressive)
2662{
2663 return (progressive != nullptr);
2664}
2665
2666PROGRESSIVE_CONTEXT* progressive_context_new(BOOL Compressor)
2667{
2668 return progressive_context_new_ex(Compressor, 0);
2669}
2670
2671PROGRESSIVE_CONTEXT* progressive_context_new_ex(BOOL Compressor, UINT32 ThreadingFlags)
2672{
2673 PROGRESSIVE_CONTEXT* progressive =
2674 (PROGRESSIVE_CONTEXT*)winpr_aligned_calloc(1, sizeof(PROGRESSIVE_CONTEXT), 32);
2675
2676 if (!progressive)
2677 return nullptr;
2678
2679 progressive->Compressor = Compressor;
2680 progressive->quantProgValFull.quality = 100;
2681 progressive->log = WLog_Get(TAG);
2682 if (!progressive->log)
2683 goto fail;
2684 progressive->rfx_context = rfx_context_new_ex(Compressor, ThreadingFlags);
2685 if (!progressive->rfx_context)
2686 goto fail;
2687 progressive->buffer = Stream_New(nullptr, 1024);
2688 if (!progressive->buffer)
2689 goto fail;
2690 progressive->rects = Stream_New(nullptr, 1024);
2691 if (!progressive->rects)
2692 goto fail;
2693 progressive->bufferPool = BufferPool_New(TRUE, (8192LL + 32LL) * 3LL, 16);
2694 if (!progressive->bufferPool)
2695 goto fail;
2696 progressive->SurfaceContexts = HashTable_New(TRUE);
2697 if (!progressive->SurfaceContexts)
2698 goto fail;
2699
2700 {
2701 wObject* obj = HashTable_ValueObject(progressive->SurfaceContexts);
2702 WINPR_ASSERT(obj);
2703 obj->fnObjectFree = progressive_surface_context_free;
2704 }
2705 return progressive;
2706fail:
2707 WINPR_PRAGMA_DIAG_PUSH
2708 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2709 progressive_context_free(progressive);
2710 WINPR_PRAGMA_DIAG_POP
2711 return nullptr;
2712}
2713
2714void progressive_context_free(PROGRESSIVE_CONTEXT* progressive)
2715{
2716 if (!progressive)
2717 return;
2718
2719 Stream_Free(progressive->buffer, TRUE);
2720 Stream_Free(progressive->rects, TRUE);
2721 rfx_context_free(progressive->rfx_context);
2722
2723 BufferPool_Free(progressive->bufferPool);
2724 HashTable_Free(progressive->SurfaceContexts);
2725
2726 winpr_aligned_free(progressive);
2727}
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