FreeRDP
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 
44 static 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 
107 static 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 
185 static 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 
233 static 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 
262 static 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 
316 static 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 
328 BOOL 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 
341 NSC_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;
370 error:
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 
378 void 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)
401 BOOL 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 
407 BOOL 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 
433 BOOL 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, UINT32 nHeight, UINT32 flip)
437 {
438  wStream* s = NULL;
439  wStream sbuffer = { 0 };
440  BOOL ret = 0;
441  if (!context || !data || !pDstData)
442  return FALSE;
443 
444  s = Stream_StaticConstInit(&sbuffer, data, length);
445 
446  if (!s)
447  return FALSE;
448 
449  if (nDstStride == 0)
450  nDstStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
451 
452  switch (bpp)
453  {
454  case 32:
455  context->format = PIXEL_FORMAT_BGRA32;
456  break;
457 
458  case 24:
459  context->format = PIXEL_FORMAT_BGR24;
460  break;
461 
462  case 16:
463  context->format = PIXEL_FORMAT_BGR16;
464  break;
465 
466  case 8:
467  context->format = PIXEL_FORMAT_RGB8;
468  break;
469 
470  case 4:
471  context->format = PIXEL_FORMAT_A4;
472  break;
473 
474  default:
475  return FALSE;
476  }
477 
478  context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
479  context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
480  ret = nsc_context_initialize(context, s);
481 
482  if (!ret)
483  return FALSE;
484 
485  /* RLE decode */
486  {
487  BOOL rc = 0;
488  PROFILER_ENTER(context->priv->prof_nsc_rle_decompress_data)
489  rc = nsc_rle_decompress_data(context);
490  PROFILER_EXIT(context->priv->prof_nsc_rle_decompress_data)
491 
492  if (!rc)
493  return FALSE;
494  }
495  /* Colorloss recover, Chroma supersample and AYCoCg to ARGB Conversion in one step */
496  {
497  BOOL rc = 0;
498  PROFILER_ENTER(context->priv->prof_nsc_decode)
499  rc = context->decode(context);
500  PROFILER_EXIT(context->priv->prof_nsc_decode)
501 
502  if (!rc)
503  return FALSE;
504  }
505 
506  if (!freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStride, nXDst, nYDst, width, height,
507  context->BitmapData, PIXEL_FORMAT_BGRA32, 0, 0, 0, NULL,
508  flip))
509  return FALSE;
510 
511  return TRUE;
512 }
NSC_CONTEXT_PRIV
Definition: nsc_types.h:42