FreeRDP
Loading...
Searching...
No Matches
nsc.c
1
23#include <freerdp/config.h>
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28
29#include <winpr/assert.h>
30#include <winpr/cast.h>
31#include <winpr/crt.h>
32
33#include <freerdp/codec/nsc.h>
34#include <freerdp/codec/color.h>
35
36#include "nsc_types.h"
37#include "nsc_encode.h"
38
39#include "sse/nsc_sse2.h"
40#include "neon/nsc_neon.h"
41
42#include <freerdp/log.h>
43
44static BOOL nsc_decode(NSC_CONTEXT* WINPR_RESTRICT context)
45{
46 size_t pos = 0;
47
48 if (!context)
49 return FALSE;
50
51 const UINT16 rw = ROUND_UP_TO(context->width, 8);
52 WINPR_ASSERT(context->ColorLossLevel >= 1);
53 const BYTE shift = WINPR_ASSERTING_INT_CAST(BYTE, context->ColorLossLevel -
54 1); /* colorloss recovery + YCoCg shift */
55 BYTE* bmpdata = context->BitmapData;
56
57 if (!bmpdata)
58 return FALSE;
59
60 for (size_t y = 0; y < context->height; y++)
61 {
62 const BYTE* yplane = nullptr;
63 const BYTE* coplane = nullptr;
64 const BYTE* cgplane = nullptr;
65 const BYTE* aplane = context->priv->PlaneBuffers[3] + y * context->width; /* A */
66
67 if (context->ChromaSubsamplingLevel)
68 {
69 yplane = context->priv->PlaneBuffers[0] + y * rw; /* Y */
70 coplane = context->priv->PlaneBuffers[1] + (y >> 1) * (rw >> 1); /* Co, supersampled */
71 cgplane = context->priv->PlaneBuffers[2] + (y >> 1) * (rw >> 1); /* Cg, supersampled */
72 }
73 else
74 {
75 yplane = context->priv->PlaneBuffers[0] + y * context->width; /* Y */
76 coplane = context->priv->PlaneBuffers[1] + y * context->width; /* Co */
77 cgplane = context->priv->PlaneBuffers[2] + y * context->width; /* Cg */
78 }
79
80 for (UINT32 x = 0; x < context->width; x++)
81 {
82 INT16 y_val = (INT16)*yplane;
83 INT16 co_val = (INT16)(INT8)(((INT16)*coplane) << shift);
84 INT16 cg_val = (INT16)(INT8)(((INT16)*cgplane) << shift);
85 INT16 r_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + co_val - cg_val);
86 INT16 g_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + cg_val);
87 INT16 b_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val - co_val - cg_val);
88
89 if (pos + 4 > context->BitmapDataLength)
90 return FALSE;
91
92 pos += 4;
93 *bmpdata++ = MINMAX(b_val, 0, 0xFF);
94 *bmpdata++ = MINMAX(g_val, 0, 0xFF);
95 *bmpdata++ = MINMAX(r_val, 0, 0xFF);
96 *bmpdata++ = *aplane;
97 yplane++;
98 coplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
99 cgplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
100 aplane++;
101 }
102 }
103
104 return TRUE;
105}
106
107static BOOL nsc_rle_decode(const BYTE* WINPR_RESTRICT in, size_t inSize, BYTE* WINPR_RESTRICT out,
108 UINT32 outSize, UINT32 originalSize)
109{
110 UINT32 left = originalSize;
111
112 while (left > 4)
113 {
114 if (inSize < 1)
115 return FALSE;
116 inSize--;
117
118 const BYTE value = *in++;
119 UINT32 len = 0;
120
121 if (left == 5)
122 {
123 if (outSize < 1)
124 return FALSE;
125
126 outSize--;
127 *out++ = value;
128 left--;
129 }
130 else if (inSize < 1)
131 return FALSE;
132 else if (value == *in)
133 {
134 inSize--;
135 in++;
136
137 if (inSize < 1)
138 return FALSE;
139 else if (*in < 0xFF)
140 {
141 inSize--;
142 len = (UINT32)*in++;
143 len += 2;
144 }
145 else
146 {
147 if (inSize < 5)
148 return FALSE;
149 inSize -= 5;
150 in++;
151 len = ((UINT32)(*in++));
152 len |= ((UINT32)(*in++)) << 8U;
153 len |= ((UINT32)(*in++)) << 16U;
154 len |= ((UINT32)(*in++)) << 24U;
155 }
156
157 if ((outSize < len) || (left < len))
158 return FALSE;
159
160 outSize -= len;
161 FillMemory(out, len, value);
162 out += len;
163 left -= len;
164 }
165 else
166 {
167 if (outSize < 1)
168 return FALSE;
169
170 outSize--;
171 *out++ = value;
172 left--;
173 }
174 }
175
176 if ((outSize < 4) || (left < 4))
177 return FALSE;
178
179 if (inSize < 4)
180 return FALSE;
181 memcpy(out, in, 4);
182 return TRUE;
183}
184
185static BOOL nsc_rle_decompress_data(NSC_CONTEXT* WINPR_RESTRICT context)
186{
187 if (!context)
188 return FALSE;
189
190 const BYTE* rle = context->Planes;
191 size_t rleSize = context->PlanesSize;
192 WINPR_ASSERT(rle);
193
194 for (size_t i = 0; i < 4; i++)
195 {
196 const UINT32 originalSize = context->OrgByteCount[i];
197 const UINT32 planeSize = context->PlaneByteCount[i];
198
199 if (rleSize < planeSize)
200 return FALSE;
201
202 if (planeSize == 0)
203 {
204 if (context->priv->PlaneBuffersLength < originalSize)
205 return FALSE;
206
207 FillMemory(context->priv->PlaneBuffers[i], originalSize, 0xFF);
208 }
209 else if (planeSize < originalSize)
210 {
211 if (!nsc_rle_decode(rle, rleSize, context->priv->PlaneBuffers[i],
212 context->priv->PlaneBuffersLength, originalSize))
213 return FALSE;
214 }
215 else
216 {
217 if (context->priv->PlaneBuffersLength < originalSize)
218 return FALSE;
219
220 if (rleSize < originalSize)
221 return FALSE;
222
223 CopyMemory(context->priv->PlaneBuffers[i], rle, originalSize);
224 }
225
226 rle += planeSize;
227 rleSize -= planeSize;
228 }
229
230 return TRUE;
231}
232
233static BOOL nsc_stream_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
234{
235 WINPR_ASSERT(context);
236 WINPR_ASSERT(context->priv);
237 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 20))
238 return FALSE;
239
240 size_t total = 0;
241 for (size_t i = 0; i < 4; i++)
242 {
243 Stream_Read_UINT32(s, context->PlaneByteCount[i]);
244 total += context->PlaneByteCount[i];
245 }
246
247 Stream_Read_UINT8(s, context->ColorLossLevel); /* ColorLossLevel (1 byte) */
248 if ((context->ColorLossLevel < 1) || (context->ColorLossLevel > 7))
249 {
250 WLog_Print(context->priv->log, WLOG_ERROR,
251 "ColorLossLevel=%" PRIu8 " out of range, must be [1,7] inclusive",
252 context->ColorLossLevel);
253 return FALSE;
254 }
255 Stream_Read_UINT8(s, context->ChromaSubsamplingLevel); /* ChromaSubsamplingLevel (1 byte) */
256 Stream_Seek(s, 2); /* Reserved (2 bytes) */
257 context->Planes = Stream_Pointer(s);
258 context->PlanesSize = total;
259 return Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, total);
260}
261
262static BOOL nsc_context_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
263{
264 if (!nsc_stream_initialize(context, s))
265 return FALSE;
266
267 const size_t blength = 4ull * context->width * context->height;
268
269 if (!context->BitmapData || (blength > context->BitmapDataLength))
270 {
271 void* tmp = winpr_aligned_recalloc(context->BitmapData, blength + 16, sizeof(BYTE), 32);
272
273 if (!tmp)
274 return FALSE;
275
276 context->BitmapData = tmp;
277 context->BitmapDataLength = blength;
278 }
279
280 const UINT32 tempWidth = ROUND_UP_TO(context->width, 8);
281 const UINT32 tempHeight = ROUND_UP_TO(context->height, 2);
282 /* The maximum length a decoded plane can reach in all cases */
283 const size_t plength = 1ull * tempWidth * tempHeight;
284 if (plength > UINT32_MAX)
285 return FALSE;
286
287 if (plength > context->priv->PlaneBuffersLength)
288 {
289 for (size_t i = 0; i < 4; i++)
290 {
291 void* tmp = (BYTE*)winpr_aligned_recalloc(context->priv->PlaneBuffers[i], plength,
292 sizeof(BYTE), 32);
293
294 if (!tmp)
295 return FALSE;
296
297 context->priv->PlaneBuffers[i] = tmp;
298 }
299
300 context->priv->PlaneBuffersLength = (UINT32)plength;
301 }
302
303 for (size_t i = 0; i < 4; i++)
304 context->OrgByteCount[i] = context->width * context->height;
305
306 if (context->ChromaSubsamplingLevel)
307 {
308 context->OrgByteCount[0] = tempWidth * context->height;
309 context->OrgByteCount[1] = (tempWidth >> 1) * (tempHeight >> 1);
310 context->OrgByteCount[2] = context->OrgByteCount[1];
311 }
312
313 return TRUE;
314}
315
316static void nsc_profiler_print(NSC_CONTEXT_PRIV* WINPR_RESTRICT priv)
317{
318 WINPR_UNUSED(priv);
319
320 PROFILER_PRINT_HEADER
321 PROFILER_PRINT(priv->prof_nsc_rle_decompress_data)
322 PROFILER_PRINT(priv->prof_nsc_decode)
323 PROFILER_PRINT(priv->prof_nsc_rle_compress_data)
324 PROFILER_PRINT(priv->prof_nsc_encode)
325 PROFILER_PRINT_FOOTER
326}
327
328BOOL nsc_context_reset(NSC_CONTEXT* WINPR_RESTRICT context, UINT32 width, UINT32 height)
329{
330 if (!context)
331 return FALSE;
332
333 if ((width > UINT16_MAX) || (height > UINT16_MAX))
334 return FALSE;
335
336 context->width = (UINT16)width;
337 context->height = (UINT16)height;
338 return TRUE;
339}
340
341NSC_CONTEXT* nsc_context_new(void)
342{
343 NSC_CONTEXT* context = (NSC_CONTEXT*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT), 32);
344
345 if (!context)
346 return nullptr;
347
348 context->priv = (NSC_CONTEXT_PRIV*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT_PRIV), 32);
349
350 if (!context->priv)
351 goto error;
352
353 context->priv->log = WLog_Get("com.freerdp.codec.nsc");
354 context->BitmapData = nullptr;
355 context->decode = nsc_decode;
356 context->encode = nsc_encode;
357
358 PROFILER_CREATE(context->priv->prof_nsc_rle_decompress_data, "nsc_rle_decompress_data")
359 PROFILER_CREATE(context->priv->prof_nsc_decode, "nsc_decode")
360 PROFILER_CREATE(context->priv->prof_nsc_rle_compress_data, "nsc_rle_compress_data")
361 PROFILER_CREATE(context->priv->prof_nsc_encode, "nsc_encode")
362 /* Default encoding parameters */
363 context->ColorLossLevel = 3;
364 context->ChromaSubsamplingLevel = 1;
365 /* init optimized methods */
366 nsc_init_sse2(context);
367 nsc_init_neon(context);
368 return context;
369error:
370 WINPR_PRAGMA_DIAG_PUSH
371 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
372 nsc_context_free(context);
373 WINPR_PRAGMA_DIAG_POP
374 return nullptr;
375}
376
377void nsc_context_free(NSC_CONTEXT* context)
378{
379 if (!context)
380 return;
381
382 if (context->priv)
383 {
384 for (size_t i = 0; i < 5; i++)
385 winpr_aligned_free(context->priv->PlaneBuffers[i]);
386
387 nsc_profiler_print(context->priv);
388 PROFILER_FREE(context->priv->prof_nsc_rle_decompress_data)
389 PROFILER_FREE(context->priv->prof_nsc_decode)
390 PROFILER_FREE(context->priv->prof_nsc_rle_compress_data)
391 PROFILER_FREE(context->priv->prof_nsc_encode)
392 winpr_aligned_free(context->priv);
393 }
394
395 winpr_aligned_free(context->BitmapData);
396 winpr_aligned_free(context);
397}
398
399#if defined(WITH_FREERDP_DEPRECATED)
400BOOL nsc_context_set_pixel_format(NSC_CONTEXT* context, UINT32 pixel_format)
401{
402 return nsc_context_set_parameters(context, NSC_COLOR_FORMAT, pixel_format);
403}
404#endif
405
406BOOL nsc_context_set_parameters(NSC_CONTEXT* WINPR_RESTRICT context, NSC_PARAMETER what,
407 UINT32 value)
408{
409 if (!context)
410 return FALSE;
411
412 switch (what)
413 {
414 case NSC_COLOR_LOSS_LEVEL:
415 context->ColorLossLevel = value;
416 break;
417 case NSC_ALLOW_SUBSAMPLING:
418 context->ChromaSubsamplingLevel = value;
419 break;
420 case NSC_DYNAMIC_COLOR_FIDELITY:
421 context->DynamicColorFidelity = value != 0;
422 break;
423 case NSC_COLOR_FORMAT:
424 context->format = value;
425 break;
426 default:
427 return FALSE;
428 }
429 return TRUE;
430}
431
432BOOL nsc_process_message(NSC_CONTEXT* WINPR_RESTRICT context, UINT16 bpp, UINT32 width,
433 UINT32 height, const BYTE* data, UINT32 length,
434 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStride,
435 UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 flip)
436{
437 WINPR_ASSERT(context);
438 WINPR_ASSERT(context->priv);
439
440 wStream sbuffer = WINPR_C_ARRAY_INIT;
441 BOOL ret = 0;
442 if (!data || !pDstData)
443 {
444 WLog_Print(context->priv->log, WLOG_ERROR, "Invalid argument: data=%p, pDstData=%p",
445 (const void*)data, (void*)pDstData);
446 return FALSE;
447 }
448
449 if (nXDst > nWidth)
450 {
451 WLog_Print(context->priv->log, WLOG_ERROR, "nXDst %" PRIu32 " > nWidth %" PRIu32, nXDst,
452 nWidth);
453 return FALSE;
454 }
455 if (nYDst > nHeight)
456 {
457 WLog_Print(context->priv->log, WLOG_ERROR, "nYDst %" PRIu32 " > nHeight %" PRIu32, nYDst,
458 nHeight);
459 return FALSE;
460 }
461
462 wStream* s = Stream_StaticConstInit(&sbuffer, data, length);
463 if (!s)
464 return FALSE;
465
466 const UINT32 minStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
467 if (nDstStride == 0)
468 nDstStride = minStride;
469 if (nDstStride < minStride)
470 {
471 WLog_Print(context->priv->log, WLOG_ERROR,
472 "nDstStride %" PRIu32 " < minimum stride %" PRIu32, nDstStride, minStride);
473 return FALSE;
474 }
475
476 switch (bpp)
477 {
478 case 32:
479 context->format = PIXEL_FORMAT_BGRA32;
480 break;
481
482 case 24:
483 context->format = PIXEL_FORMAT_BGR24;
484 break;
485
486 case 16:
487 context->format = PIXEL_FORMAT_BGR16;
488 break;
489
490 case 8:
491 context->format = PIXEL_FORMAT_RGB8;
492 break;
493
494 case 4:
495 context->format = PIXEL_FORMAT_A4;
496 break;
497
498 default:
499 return FALSE;
500 }
501
502 context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
503 context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
504 ret = nsc_context_initialize(context, s);
505
506 if (!ret)
507 return FALSE;
508
509 /* RLE decode */
510 {
511 BOOL rc = 0;
512 PROFILER_ENTER(context->priv->prof_nsc_rle_decompress_data)
513 rc = nsc_rle_decompress_data(context);
514 PROFILER_EXIT(context->priv->prof_nsc_rle_decompress_data)
515
516 if (!rc)
517 return FALSE;
518 }
519 /* Colorloss recover, Chroma supersample and AYCoCg to ARGB Conversion in one step */
520 {
521 BOOL rc = 0;
522 PROFILER_ENTER(context->priv->prof_nsc_decode)
523 rc = context->decode(context);
524 PROFILER_EXIT(context->priv->prof_nsc_decode)
525
526 if (!rc)
527 return FALSE;
528 }
529
530 return (freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStride, nXDst, nYDst, width,
531 height, context->BitmapData, PIXEL_FORMAT_BGRA32, 0, 0, 0,
532 nullptr, flip));
533}
NSC_CONTEXT_PRIV
Definition nsc_types.h:42