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 = NULL;
63 const BYTE* coplane = NULL;
64 const BYTE* cgplane = NULL;
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 NULL;
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 WLog_OpenAppender(context->priv->log);
355 context->BitmapData = NULL;
356 context->decode = nsc_decode;
357 context->encode = nsc_encode;
358
359 PROFILER_CREATE(context->priv->prof_nsc_rle_decompress_data, "nsc_rle_decompress_data")
360 PROFILER_CREATE(context->priv->prof_nsc_decode, "nsc_decode")
361 PROFILER_CREATE(context->priv->prof_nsc_rle_compress_data, "nsc_rle_compress_data")
362 PROFILER_CREATE(context->priv->prof_nsc_encode, "nsc_encode")
363 /* Default encoding parameters */
364 context->ColorLossLevel = 3;
365 context->ChromaSubsamplingLevel = 1;
366 /* init optimized methods */
367 nsc_init_sse2(context);
368 nsc_init_neon(context);
369 return context;
370error:
371 WINPR_PRAGMA_DIAG_PUSH
372 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
373 nsc_context_free(context);
374 WINPR_PRAGMA_DIAG_POP
375 return NULL;
376}
377
378void nsc_context_free(NSC_CONTEXT* context)
379{
380 if (!context)
381 return;
382
383 if (context->priv)
384 {
385 for (size_t i = 0; i < 5; i++)
386 winpr_aligned_free(context->priv->PlaneBuffers[i]);
387
388 nsc_profiler_print(context->priv);
389 PROFILER_FREE(context->priv->prof_nsc_rle_decompress_data)
390 PROFILER_FREE(context->priv->prof_nsc_decode)
391 PROFILER_FREE(context->priv->prof_nsc_rle_compress_data)
392 PROFILER_FREE(context->priv->prof_nsc_encode)
393 winpr_aligned_free(context->priv);
394 }
395
396 winpr_aligned_free(context->BitmapData);
397 winpr_aligned_free(context);
398}
399
400#if defined(WITH_FREERDP_DEPRECATED)
401BOOL nsc_context_set_pixel_format(NSC_CONTEXT* context, UINT32 pixel_format)
402{
403 return nsc_context_set_parameters(context, NSC_COLOR_FORMAT, pixel_format);
404}
405#endif
406
407BOOL nsc_context_set_parameters(NSC_CONTEXT* WINPR_RESTRICT context, NSC_PARAMETER what,
408 UINT32 value)
409{
410 if (!context)
411 return FALSE;
412
413 switch (what)
414 {
415 case NSC_COLOR_LOSS_LEVEL:
416 context->ColorLossLevel = value;
417 break;
418 case NSC_ALLOW_SUBSAMPLING:
419 context->ChromaSubsamplingLevel = value;
420 break;
421 case NSC_DYNAMIC_COLOR_FIDELITY:
422 context->DynamicColorFidelity = value != 0;
423 break;
424 case NSC_COLOR_FORMAT:
425 context->format = value;
426 break;
427 default:
428 return FALSE;
429 }
430 return TRUE;
431}
432
433BOOL nsc_process_message(NSC_CONTEXT* WINPR_RESTRICT context, UINT16 bpp, UINT32 width,
434 UINT32 height, const BYTE* data, UINT32 length,
435 BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStride,
436 UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
437 WINPR_ATTR_UNUSED UINT32 nHeight, UINT32 flip)
438{
439 wStream* s = NULL;
440 wStream sbuffer = { 0 };
441 BOOL ret = 0;
442 if (!context || !data || !pDstData)
443 return FALSE;
444
445 s = Stream_StaticConstInit(&sbuffer, data, length);
446
447 if (!s)
448 return FALSE;
449
450 if (nDstStride == 0)
451 nDstStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
452
453 switch (bpp)
454 {
455 case 32:
456 context->format = PIXEL_FORMAT_BGRA32;
457 break;
458
459 case 24:
460 context->format = PIXEL_FORMAT_BGR24;
461 break;
462
463 case 16:
464 context->format = PIXEL_FORMAT_BGR16;
465 break;
466
467 case 8:
468 context->format = PIXEL_FORMAT_RGB8;
469 break;
470
471 case 4:
472 context->format = PIXEL_FORMAT_A4;
473 break;
474
475 default:
476 return FALSE;
477 }
478
479 context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
480 context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
481 ret = nsc_context_initialize(context, s);
482
483 if (!ret)
484 return FALSE;
485
486 /* RLE decode */
487 {
488 BOOL rc = 0;
489 PROFILER_ENTER(context->priv->prof_nsc_rle_decompress_data)
490 rc = nsc_rle_decompress_data(context);
491 PROFILER_EXIT(context->priv->prof_nsc_rle_decompress_data)
492
493 if (!rc)
494 return FALSE;
495 }
496 /* Colorloss recover, Chroma supersample and AYCoCg to ARGB Conversion in one step */
497 {
498 BOOL rc = 0;
499 PROFILER_ENTER(context->priv->prof_nsc_decode)
500 rc = context->decode(context);
501 PROFILER_EXIT(context->priv->prof_nsc_decode)
502
503 if (!rc)
504 return FALSE;
505 }
506
507 if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStride, nXDst, nYDst, width, height,
508 context->BitmapData, PIXEL_FORMAT_BGRA32, 0, 0, 0, NULL,
509 flip))
510 return FALSE;
511
512 return TRUE;
513}
NSC_CONTEXT_PRIV
Definition nsc_types.h:42