/src/FreeRDP/libfreerdp/codec/nsc.c

Source
/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * NSCodec Codec
 *
 * Copyright 2011 Samsung, Author Jiten Pathy
 * Copyright 2012 Vic Lee
 * Copyright 2016 Armin Novak <armin.novak@thincast.com>
 * Copyright 2016 Thincast Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <freerdp/config.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <winpr/assert.h>
#include <winpr/cast.h>
#include <winpr/crt.h>

#include <freerdp/codec/nsc.h>
#include <freerdp/codec/color.h>

#include "nsc_types.h"
#include "nsc_encode.h"

#include "sse/nsc_sse2.h"
#include "neon/nsc_neon.h"

#include <freerdp/log.h>

static BOOL nsc_decode(NSC_CONTEXT* WINPR_RESTRICT context)
{
  size_t pos = 0;

  if (!context)
    return FALSE;

  const UINT16 rw = ROUND_UP_TO(context->width, 8);
  WINPR_ASSERT(context->ColorLossLevel >= 1);
  const BYTE shift = WINPR_ASSERTING_INT_CAST(BYTE, context->ColorLossLevel -
                                                        1); /* colorloss recovery + YCoCg shift */
  BYTE* bmpdata = context->BitmapData;

  if (!bmpdata)
    return FALSE;

  for (size_t y = 0; y < context->height; y++)
  {
    const BYTE* yplane = nullptr;
    const BYTE* coplane = nullptr;
    const BYTE* cgplane = nullptr;
    const BYTE* aplane = context->priv->PlaneBuffers[3] + y * context->width; /* A */

    if (context->ChromaSubsamplingLevel)
    {
      yplane = context->priv->PlaneBuffers[0] + y * rw;                /* Y */
      coplane = context->priv->PlaneBuffers[1] + (y >> 1) * (rw >> 1); /* Co, supersampled */
      cgplane = context->priv->PlaneBuffers[2] + (y >> 1) * (rw >> 1); /* Cg, supersampled */
    }
    else
    {
      yplane = context->priv->PlaneBuffers[0] + y * context->width;  /* Y */
      coplane = context->priv->PlaneBuffers[1] + y * context->width; /* Co */
      cgplane = context->priv->PlaneBuffers[2] + y * context->width; /* Cg */
    }

    for (UINT32 x = 0; x < context->width; x++)
    {
      INT16 y_val = (INT16)*yplane;
      INT16 co_val = (INT16)(INT8)(((INT16)*coplane) << shift);
      INT16 cg_val = (INT16)(INT8)(((INT16)*cgplane) << shift);
      INT16 r_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + co_val - cg_val);
      INT16 g_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + cg_val);
      INT16 b_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val - co_val - cg_val);

      if (pos + 4 > context->BitmapDataLength)
        return FALSE;

      pos += 4;
      *bmpdata++ = MINMAX(b_val, 0, 0xFF);
      *bmpdata++ = MINMAX(g_val, 0, 0xFF);
      *bmpdata++ = MINMAX(r_val, 0, 0xFF);
      *bmpdata++ = *aplane;
      yplane++;
      coplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
      cgplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
      aplane++;
    }
  }

  return TRUE;
}

static BOOL nsc_rle_decode(const BYTE* WINPR_RESTRICT in, size_t inSize, BYTE* WINPR_RESTRICT out,
                           UINT32 outSize, UINT32 originalSize)
{
  UINT32 left = originalSize;

  while (left > 4)
  {
    if (inSize < 1)
      return FALSE;
    inSize--;

    const BYTE value = *in++;
    UINT32 len = 0;

    if (left == 5)
    {
      if (outSize < 1)
        return FALSE;

      outSize--;
      *out++ = value;
      left--;
    }
    else if (inSize < 1)
      return FALSE;
    else if (value == *in)
    {
      inSize--;
      in++;

      if (inSize < 1)
        return FALSE;
      else if (*in < 0xFF)
      {
        inSize--;
        len = (UINT32)*in++;
        len += 2;
      }
      else
      {
        if (inSize < 5)
          return FALSE;
        inSize -= 5;
        in++;
        len = ((UINT32)(*in++));
        len |= ((UINT32)(*in++)) << 8U;
        len |= ((UINT32)(*in++)) << 16U;
        len |= ((UINT32)(*in++)) << 24U;
      }

      if ((outSize < len) || (left < len))
        return FALSE;

      outSize -= len;
      FillMemory(out, len, value);
      out += len;
      left -= len;
    }
    else
    {
      if (outSize < 1)
        return FALSE;

      outSize--;
      *out++ = value;
      left--;
    }
  }

  if ((outSize < 4) || (left < 4))
    return FALSE;

  if (inSize < 4)
    return FALSE;
  memcpy(out, in, 4);
  return TRUE;
}

static BOOL nsc_rle_decompress_data(NSC_CONTEXT* WINPR_RESTRICT context)
{
  if (!context)
    return FALSE;

  const BYTE* rle = context->Planes;
  size_t rleSize = context->PlanesSize;
  WINPR_ASSERT(rle);

  for (size_t i = 0; i < 4; i++)
  {
    const UINT32 originalSize = context->OrgByteCount[i];
    const UINT32 planeSize = context->PlaneByteCount[i];

    if (rleSize < planeSize)
      return FALSE;

    if (planeSize == 0)
    {
      if (context->priv->PlaneBuffersLength < originalSize)
        return FALSE;

      FillMemory(context->priv->PlaneBuffers[i], originalSize, 0xFF);
    }
    else if (planeSize < originalSize)
    {
      if (!nsc_rle_decode(rle, rleSize, context->priv->PlaneBuffers[i],
                          context->priv->PlaneBuffersLength, originalSize))
        return FALSE;
    }
    else
    {
      if (context->priv->PlaneBuffersLength < originalSize)
        return FALSE;

      if (rleSize < originalSize)
        return FALSE;

      CopyMemory(context->priv->PlaneBuffers[i], rle, originalSize);
    }

    rle += planeSize;
    rleSize -= planeSize;
  }

  return TRUE;
}

static BOOL nsc_stream_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(context->priv);
  if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 20))
    return FALSE;

  size_t total = 0;
  for (size_t i = 0; i < 4; i++)
  {
    Stream_Read_UINT32(s, context->PlaneByteCount[i]);
    total += context->PlaneByteCount[i];
  }

  Stream_Read_UINT8(s, context->ColorLossLevel);         /* ColorLossLevel (1 byte) */
  if ((context->ColorLossLevel < 1) || (context->ColorLossLevel > 7))
  {
    WLog_Print(context->priv->log, WLOG_ERROR,
               "ColorLossLevel=%" PRIu8 " out of range, must be [1,7] inclusive",
               context->ColorLossLevel);
    return FALSE;
  }
  Stream_Read_UINT8(s, context->ChromaSubsamplingLevel); /* ChromaSubsamplingLevel (1 byte) */
  Stream_Seek(s, 2);                                     /* Reserved (2 bytes) */
  context->Planes = Stream_Pointer(s);
  context->PlanesSize = total;
  return Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, total);
}

static BOOL nsc_context_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
{
  if (!nsc_stream_initialize(context, s))
    return FALSE;

  const size_t blength = 4ull * context->width * context->height;

  if (!context->BitmapData || (blength > context->BitmapDataLength))
  {
    void* tmp = winpr_aligned_recalloc(context->BitmapData, blength + 16, sizeof(BYTE), 32);

    if (!tmp)
      return FALSE;

    context->BitmapData = tmp;
    context->BitmapDataLength = blength;
  }

  const UINT32 tempWidth = ROUND_UP_TO(context->width, 8);
  const UINT32 tempHeight = ROUND_UP_TO(context->height, 2);
  /* The maximum length a decoded plane can reach in all cases */
  const size_t plength = 1ull * tempWidth * tempHeight;
  if (plength > UINT32_MAX)
    return FALSE;

  if (plength > context->priv->PlaneBuffersLength)
  {
    for (size_t i = 0; i < 4; i++)
    {
      void* tmp = (BYTE*)winpr_aligned_recalloc(context->priv->PlaneBuffers[i], plength,
                                                sizeof(BYTE), 32);

      if (!tmp)
        return FALSE;

      context->priv->PlaneBuffers[i] = tmp;
    }

    context->priv->PlaneBuffersLength = (UINT32)plength;
  }

  for (size_t i = 0; i < 4; i++)
    context->OrgByteCount[i] = context->width * context->height;

  if (context->ChromaSubsamplingLevel)
  {
    context->OrgByteCount[0] = tempWidth * context->height;
    context->OrgByteCount[1] = (tempWidth >> 1) * (tempHeight >> 1);
    context->OrgByteCount[2] = context->OrgByteCount[1];
  }

  return TRUE;
}

static void nsc_profiler_print(NSC_CONTEXT_PRIV* WINPR_RESTRICT priv)
{
  WINPR_UNUSED(priv);

  PROFILER_PRINT_HEADER
  PROFILER_PRINT(priv->prof_nsc_rle_decompress_data)
  PROFILER_PRINT(priv->prof_nsc_decode)
  PROFILER_PRINT(priv->prof_nsc_rle_compress_data)
  PROFILER_PRINT(priv->prof_nsc_encode)
  PROFILER_PRINT_FOOTER
}

BOOL nsc_context_reset(NSC_CONTEXT* WINPR_RESTRICT context, UINT32 width, UINT32 height)
{
  if (!context)
    return FALSE;

  if ((width > UINT16_MAX) || (height > UINT16_MAX))
    return FALSE;

  context->width = (UINT16)width;
  context->height = (UINT16)height;
  return TRUE;
}

NSC_CONTEXT* nsc_context_new(void)
{
  NSC_CONTEXT* context = (NSC_CONTEXT*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT), 32);

  if (!context)
    return nullptr;

  context->priv = (NSC_CONTEXT_PRIV*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT_PRIV), 32);

  if (!context->priv)
    goto error;

  context->priv->log = WLog_Get("com.freerdp.codec.nsc");
  context->BitmapData = nullptr;
  context->decode = nsc_decode;
  context->encode = nsc_encode;

  PROFILER_CREATE(context->priv->prof_nsc_rle_decompress_data, "nsc_rle_decompress_data")
  PROFILER_CREATE(context->priv->prof_nsc_decode, "nsc_decode")
  PROFILER_CREATE(context->priv->prof_nsc_rle_compress_data, "nsc_rle_compress_data")
  PROFILER_CREATE(context->priv->prof_nsc_encode, "nsc_encode")
  /* Default encoding parameters */
  context->ColorLossLevel = 3;
  context->ChromaSubsamplingLevel = 1;
  /* init optimized methods */
  nsc_init_sse2(context);
  nsc_init_neon(context);
  return context;
error:
  WINPR_PRAGMA_DIAG_PUSH
  WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
  nsc_context_free(context);
  WINPR_PRAGMA_DIAG_POP
  return nullptr;
}

void nsc_context_free(NSC_CONTEXT* context)
{
  if (!context)
    return;

  if (context->priv)
  {
    for (size_t i = 0; i < 5; i++)
      winpr_aligned_free(context->priv->PlaneBuffers[i]);

    nsc_profiler_print(context->priv);
    PROFILER_FREE(context->priv->prof_nsc_rle_decompress_data)
    PROFILER_FREE(context->priv->prof_nsc_decode)
    PROFILER_FREE(context->priv->prof_nsc_rle_compress_data)
    PROFILER_FREE(context->priv->prof_nsc_encode)
    winpr_aligned_free(context->priv);
  }

  winpr_aligned_free(context->BitmapData);
  winpr_aligned_free(context);
}

#if defined(WITH_FREERDP_DEPRECATED)
BOOL nsc_context_set_pixel_format(NSC_CONTEXT* context, UINT32 pixel_format)
{
  return nsc_context_set_parameters(context, NSC_COLOR_FORMAT, pixel_format);
}
#endif

BOOL nsc_context_set_parameters(NSC_CONTEXT* WINPR_RESTRICT context, NSC_PARAMETER what,
                                UINT32 value)
{
  if (!context)
    return FALSE;

  switch (what)
  {
    case NSC_COLOR_LOSS_LEVEL:
      context->ColorLossLevel = value;
      break;
    case NSC_ALLOW_SUBSAMPLING:
      context->ChromaSubsamplingLevel = value;
      break;
    case NSC_DYNAMIC_COLOR_FIDELITY:
      context->DynamicColorFidelity = value != 0;
      break;
    case NSC_COLOR_FORMAT:
      context->format = value;
      break;
    default:
      return FALSE;
  }
  return TRUE;
}

BOOL nsc_process_message(NSC_CONTEXT* WINPR_RESTRICT context, UINT16 bpp, UINT32 width,
                         UINT32 height, const BYTE* data, UINT32 length,
                         BYTE* WINPR_RESTRICT pDstData, UINT32 DstFormat, UINT32 nDstStride,
                         UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight, UINT32 flip)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(context->priv);

  wStream sbuffer = WINPR_C_ARRAY_INIT;
  BOOL ret = 0;
  if (!data || !pDstData)
  {
    WLog_Print(context->priv->log, WLOG_ERROR, "Invalid argument: data=%p, pDstData=%p",
               (const void*)data, (void*)pDstData);
    return FALSE;
  }

  if (nXDst > nWidth)
  {
    WLog_Print(context->priv->log, WLOG_ERROR, "nXDst %" PRIu32 " > nWidth %" PRIu32, nXDst,
               nWidth);
    return FALSE;
  }
  if (nYDst > nHeight)
  {
    WLog_Print(context->priv->log, WLOG_ERROR, "nYDst %" PRIu32 " > nHeight %" PRIu32, nYDst,
               nHeight);
    return FALSE;
  }

  wStream* s = Stream_StaticConstInit(&sbuffer, data, length);
  if (!s)
    return FALSE;

  const UINT32 minStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
  if (nDstStride == 0)
    nDstStride = minStride;
  if (nDstStride < minStride)
  {
    WLog_Print(context->priv->log, WLOG_ERROR,
               "nDstStride %" PRIu32 " < minimum stride %" PRIu32, nDstStride, minStride);
    return FALSE;
  }

  switch (bpp)
  {
    case 32:
      context->format = PIXEL_FORMAT_BGRA32;
      break;

    case 24:
      context->format = PIXEL_FORMAT_BGR24;
      break;

    case 16:
      context->format = PIXEL_FORMAT_BGR16;
      break;

    case 8:
      context->format = PIXEL_FORMAT_RGB8;
      break;

    case 4:
      context->format = PIXEL_FORMAT_A4;
      break;

    default:
      return FALSE;
  }

  context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
  context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
  ret = nsc_context_initialize(context, s);

  if (!ret)
    return FALSE;

  /* RLE decode */
  {
    BOOL rc = 0;
    PROFILER_ENTER(context->priv->prof_nsc_rle_decompress_data)
    rc = nsc_rle_decompress_data(context);
    PROFILER_EXIT(context->priv->prof_nsc_rle_decompress_data)

    if (!rc)
      return FALSE;
  }
  /* Colorloss recover, Chroma supersample and AYCoCg to ARGB Conversion in one step */
  {
    BOOL rc = 0;
    PROFILER_ENTER(context->priv->prof_nsc_decode)
    rc = context->decode(context);
    PROFILER_EXIT(context->priv->prof_nsc_decode)

    if (!rc)
      return FALSE;
  }

  return (freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStride, nXDst, nYDst, width,
                                        height, context->BitmapData, PIXEL_FORMAT_BGRA32, 0, 0, 0,
                                        nullptr, flip));
}

Coverage Report

Created: 2026-03-04 06:14

Line	Count	Source
1		/**
2		* FreeRDP: A Remote Desktop Protocol Implementation
3		* NSCodec Codec
4		*
5		* Copyright 2011 Samsung, Author Jiten Pathy
6		* Copyright 2012 Vic Lee
7		* Copyright 2016 Armin Novak <armin.novak@thincast.com>
8		* Copyright 2016 Thincast Technologies GmbH
9		*
10		* Licensed under the Apache License, Version 2.0 (the "License");
11		* you may not use this file except in compliance with the License.
12		* You may obtain a copy of the License at
13		*
14		* http://www.apache.org/licenses/LICENSE-2.0
15		*
16		* Unless required by applicable law or agreed to in writing, software
17		* distributed under the License is distributed on an "AS IS" BASIS,
18		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19		* See the License for the specific language governing permissions and
20		* limitations under the License.
21		*/
22
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	365	{
46	365	size_t pos = 0;
47
48	365	if (!context)
49	0	return FALSE;
50
51	365	const UINT16 rw = ROUND_UP_TO(context->width, 8);
52	365	WINPR_ASSERT(context->ColorLossLevel >= 1);
53	365	const BYTE shift = WINPR_ASSERTING_INT_CAST(BYTE, context->ColorLossLevel -
54	365	1); /* colorloss recovery + YCoCg shift */
55	365	BYTE* bmpdata = context->BitmapData;
56
57	365	if (!bmpdata)
58	0	return FALSE;
59
60	2.47k	for (size_t y = 0; y < context->height; y++)
61	2.11k	{
62	2.11k	const BYTE* yplane = nullptr;
63	2.11k	const BYTE* coplane = nullptr;
64	2.11k	const BYTE* cgplane = nullptr;
65	2.11k	const BYTE* aplane = context->priv->PlaneBuffers[3] + y * context->width; /* A */
66
67	2.11k	if (context->ChromaSubsamplingLevel)
68	1.14k	{
69	1.14k	yplane = context->priv->PlaneBuffers[0] + y * rw; /* Y */
70	1.14k	coplane = context->priv->PlaneBuffers[1] + (y >> 1) * (rw >> 1); /* Co, supersampled */
71	1.14k	cgplane = context->priv->PlaneBuffers[2] + (y >> 1) * (rw >> 1); /* Cg, supersampled */
72	1.14k	}
73	972	else
74	972	{
75	972	yplane = context->priv->PlaneBuffers[0] + y * context->width; /* Y */
76	972	coplane = context->priv->PlaneBuffers[1] + y * context->width; /* Co */
77	972	cgplane = context->priv->PlaneBuffers[2] + y * context->width; /* Cg */
78	972	}
79
80	48.6k	for (UINT32 x = 0; x < context->width; x++)
81	46.5k	{
82	46.5k	INT16 y_val = (INT16)*yplane;
83	46.5k	INT16 co_val = (INT16)(INT8)(((INT16)*coplane) << shift);
84	46.5k	INT16 cg_val = (INT16)(INT8)(((INT16)*cgplane) << shift);
85	46.5k	INT16 r_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + co_val - cg_val);
86	46.5k	INT16 g_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val + cg_val);
87	46.5k	INT16 b_val = WINPR_ASSERTING_INT_CAST(int16_t, y_val - co_val - cg_val);
88
89	46.5k	if (pos + 4 > context->BitmapDataLength)
90	0	return FALSE;
91
92	46.5k	pos += 4;
93	46.5k	*bmpdata++ = MINMAX(b_val, 0, 0xFF);
94	46.5k	*bmpdata++ = MINMAX(g_val, 0, 0xFF);
95	46.5k	*bmpdata++ = MINMAX(r_val, 0, 0xFF);
96	46.5k	bmpdata++ = aplane;
97	46.5k	yplane++;
98	46.5k	coplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
99	46.5k	cgplane += (context->ChromaSubsamplingLevel ? x % 2 : 1);
100	46.5k	aplane++;
101	46.5k	}
102	2.11k	}
103
104	365	return TRUE;
105	365	}
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	456	{
110	456	UINT32 left = originalSize;
111
112	11.1k	while (left > 4)
113	10.8k	{
114	10.8k	if (inSize < 1)
115	15	return FALSE;
116	10.8k	inSize--;
117
118	10.8k	const BYTE value = *in++;
119	10.8k	UINT32 len = 0;
120
121	10.8k	if (left == 5)
122	231	{
123	231	if (outSize < 1)
124	0	return FALSE;
125
126	231	outSize--;
127	231	*out++ = value;
128	231	left--;
129	231	}
130	10.6k	else if (inSize < 1)
131	36	return FALSE;
132	10.5k	else if (value == *in)
133	1.16k	{
134	1.16k	inSize--;
135	1.16k	in++;
136
137	1.16k	if (inSize < 1)
138	17	return FALSE;
139	1.14k	else if (*in < 0xFF)
140	968	{
141	968	inSize--;
142	968	len = (UINT32)*in++;
143	968	len += 2;
144	968	}
145	180	else
146	180	{
147	180	if (inSize < 5)
148	9	return FALSE;
149	171	inSize -= 5;
150	171	in++;
151	171	len = ((UINT32)(*in++));
152	171	len \|= ((UINT32)(*in++)) << 8U;
153	171	len \|= ((UINT32)(*in++)) << 16U;
154	171	len \|= ((UINT32)(*in++)) << 24U;
155	171	}
156
157	1.13k	if ((outSize < len) \|\| (left < len))
158	81	return FALSE;
159
160	1.05k	outSize -= len;
161	1.05k	FillMemory(out, len, value);
162	1.05k	out += len;
163	1.05k	left -= len;
164	1.05k	}
165	9.40k	else
166	9.40k	{
167	9.40k	if (outSize < 1)
168	0	return FALSE;
169
170	9.40k	outSize--;
171	9.40k	*out++ = value;
172	9.40k	left--;
173	9.40k	}
174	10.8k	}
175
176	298	if ((outSize < 4) \|\| (left < 4))
177	18	return FALSE;
178
179	280	if (inSize < 4)
180	19	return FALSE;
181	261	memcpy(out, in, 4);
182	261	return TRUE;
183	280	}
184
185		static BOOL nsc_rle_decompress_data(NSC_CONTEXT* WINPR_RESTRICT context)
186	560	{
187	560	if (!context)
188	0	return FALSE;
189
190	560	const BYTE* rle = context->Planes;
191	560	size_t rleSize = context->PlanesSize;
192	560	WINPR_ASSERT(rle);
193
194	2.16k	for (size_t i = 0; i < 4; i++)
195	1.79k	{
196	1.79k	const UINT32 originalSize = context->OrgByteCount[i];
197	1.79k	const UINT32 planeSize = context->PlaneByteCount[i];
198
199	1.79k	if (rleSize < planeSize)
200	0	return FALSE;
201
202	1.79k	if (planeSize == 0)
203	1.08k	{
204	1.08k	if (context->priv->PlaneBuffersLength < originalSize)
205	0	return FALSE;
206
207	1.08k	FillMemory(context->priv->PlaneBuffers[i], originalSize, 0xFF);
208	1.08k	}
209	717	else if (planeSize < originalSize)
210	456	{
211	456	if (!nsc_rle_decode(rle, rleSize, context->priv->PlaneBuffers[i],
212	456	context->priv->PlaneBuffersLength, originalSize))
213	195	return FALSE;
214	456	}
215	261	else
216	261	{
217	261	if (context->priv->PlaneBuffersLength < originalSize)
218	0	return FALSE;
219
220	261	if (rleSize < originalSize)
221	0	return FALSE;
222
223	261	CopyMemory(context->priv->PlaneBuffers[i], rle, originalSize);
224	261	}
225
226	1.60k	rle += planeSize;
227	1.60k	rleSize -= planeSize;
228	1.60k	}
229
230	365	return TRUE;
231	560	}
232
233		static BOOL nsc_stream_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
234	705	{
235	705	WINPR_ASSERT(context);
236	705	WINPR_ASSERT(context->priv);
237	705	if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 20))
238	74	return FALSE;
239
240	631	size_t total = 0;
241	3.15k	for (size_t i = 0; i < 4; i++)
242	2.52k	{
243	2.52k	Stream_Read_UINT32(s, context->PlaneByteCount[i]);
244	2.52k	total += context->PlaneByteCount[i];
245	2.52k	}
246
247	631	Stream_Read_UINT8(s, context->ColorLossLevel); /* ColorLossLevel (1 byte) */
248	631	if ((context->ColorLossLevel < 1) \|\| (context->ColorLossLevel > 7))
249	46	{
250	46	WLog_Print(context->priv->log, WLOG_ERROR,
251	46	"ColorLossLevel=%" PRIu8 " out of range, must be [1,7] inclusive",
252	46	context->ColorLossLevel);
253	46	return FALSE;
254	46	}
255	585	Stream_Read_UINT8(s, context->ChromaSubsamplingLevel); /* ChromaSubsamplingLevel (1 byte) */
256	585	Stream_Seek(s, 2); /* Reserved (2 bytes) */
257	585	context->Planes = Stream_Pointer(s);
258	585	context->PlanesSize = total;
259	585	return Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, total);
260	631	}
261
262		static BOOL nsc_context_initialize(NSC_CONTEXT* WINPR_RESTRICT context, wStream* WINPR_RESTRICT s)
263	705	{
264	705	if (!nsc_stream_initialize(context, s))
265	145	return FALSE;
266
267	560	const size_t blength = 4ull * context->width * context->height;
268
269	560	if (!context->BitmapData \|\| (blength > context->BitmapDataLength))
270	536	{
271	536	void* tmp = winpr_aligned_recalloc(context->BitmapData, blength + 16, sizeof(BYTE), 32);
272
273	536	if (!tmp)
274	0	return FALSE;
275
276	536	context->BitmapData = tmp;
277	536	context->BitmapDataLength = blength;
278	536	}
279
280	560	const UINT32 tempWidth = ROUND_UP_TO(context->width, 8);
281	560	const UINT32 tempHeight = ROUND_UP_TO(context->height, 2);
282		/* The maximum length a decoded plane can reach in all cases */
283	560	const size_t plength = 1ull * tempWidth * tempHeight;
284	560	if (plength > UINT32_MAX)
285	0	return FALSE;
286
287	560	if (plength > context->priv->PlaneBuffersLength)
288	482	{
289	2.41k	for (size_t i = 0; i < 4; i++)
290	1.92k	{
291	1.92k	void* tmp = (BYTE*)winpr_aligned_recalloc(context->priv->PlaneBuffers[i], plength,
292	1.92k	sizeof(BYTE), 32);
293
294	1.92k	if (!tmp)
295	0	return FALSE;
296
297	1.92k	context->priv->PlaneBuffers[i] = tmp;
298	1.92k	}
299
300	482	context->priv->PlaneBuffersLength = (UINT32)plength;
301	482	}
302
303	2.80k	for (size_t i = 0; i < 4; i++)
304	2.24k	context->OrgByteCount[i] = context->width * context->height;
305
306	560	if (context->ChromaSubsamplingLevel)
307	282	{
308	282	context->OrgByteCount[0] = tempWidth * context->height;
309	282	context->OrgByteCount[1] = (tempWidth >> 1) * (tempHeight >> 1);
310	282	context->OrgByteCount[2] = context->OrgByteCount[1];
311	282	}
312
313	560	return TRUE;
314	560	}
315
316		static void nsc_profiler_print(NSC_CONTEXT_PRIV* WINPR_RESTRICT priv)
317	17.0k	{
318	17.0k	WINPR_UNUSED(priv);
319
320	17.0k	PROFILER_PRINT_HEADER
321	17.0k	PROFILER_PRINT(priv->prof_nsc_rle_decompress_data)
322	17.0k	PROFILER_PRINT(priv->prof_nsc_decode)
323	17.0k	PROFILER_PRINT(priv->prof_nsc_rle_compress_data)
324	17.0k	PROFILER_PRINT(priv->prof_nsc_encode)
325	17.0k	PROFILER_PRINT_FOOTER
326	17.0k	}
327
328		BOOL nsc_context_reset(NSC_CONTEXT* WINPR_RESTRICT context, UINT32 width, UINT32 height)
329	0	{
330	0	if (!context)
331	0	return FALSE;
332
333	0	if ((width > UINT16_MAX) \|\| (height > UINT16_MAX))
334	0	return FALSE;
335
336	0	context->width = (UINT16)width;
337	0	context->height = (UINT16)height;
338	0	return TRUE;
339	0	}
340
341		NSC_CONTEXT* nsc_context_new(void)
342	17.0k	{
343	17.0k	NSC_CONTEXT* context = (NSC_CONTEXT*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT), 32);
344
345	17.0k	if (!context)
346	0	return nullptr;
347
348	17.0k	context->priv = (NSC_CONTEXT_PRIV*)winpr_aligned_calloc(1, sizeof(NSC_CONTEXT_PRIV), 32);
349
350	17.0k	if (!context->priv)
351	0	goto error;
352
353	17.0k	context->priv->log = WLog_Get("com.freerdp.codec.nsc");
354	17.0k	context->BitmapData = nullptr;
355	17.0k	context->decode = nsc_decode;
356	17.0k	context->encode = nsc_encode;
357
358	17.0k	PROFILER_CREATE(context->priv->prof_nsc_rle_decompress_data, "nsc_rle_decompress_data")
359	17.0k	PROFILER_CREATE(context->priv->prof_nsc_decode, "nsc_decode")
360	17.0k	PROFILER_CREATE(context->priv->prof_nsc_rle_compress_data, "nsc_rle_compress_data")
361	17.0k	PROFILER_CREATE(context->priv->prof_nsc_encode, "nsc_encode")
362		/* Default encoding parameters */
363	17.0k	context->ColorLossLevel = 3;
364	17.0k	context->ChromaSubsamplingLevel = 1;
365		/* init optimized methods */
366	17.0k	nsc_init_sse2(context);
367	17.0k	nsc_init_neon(context);
368	17.0k	return context;
369	0	error:
370	0	WINPR_PRAGMA_DIAG_PUSH
371	0	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
372	0	nsc_context_free(context);
373	0	WINPR_PRAGMA_DIAG_POP
374	0	return nullptr;
375	17.0k	}
376
377		void nsc_context_free(NSC_CONTEXT* context)
378	17.0k	{
379	17.0k	if (!context)
380	0	return;
381
382	17.0k	if (context->priv)
383	17.0k	{
384	102k	for (size_t i = 0; i < 5; i++)
385	85.4k	winpr_aligned_free(context->priv->PlaneBuffers[i]);
386
387	17.0k	nsc_profiler_print(context->priv);
388	17.0k	PROFILER_FREE(context->priv->prof_nsc_rle_decompress_data)
389	17.0k	PROFILER_FREE(context->priv->prof_nsc_decode)
390	17.0k	PROFILER_FREE(context->priv->prof_nsc_rle_compress_data)
391	17.0k	PROFILER_FREE(context->priv->prof_nsc_encode)
392	17.0k	winpr_aligned_free(context->priv);
393	17.0k	}
394
395	17.0k	winpr_aligned_free(context->BitmapData);
396	17.0k	winpr_aligned_free(context);
397	17.0k	}
398
399		#if defined(WITH_FREERDP_DEPRECATED)
400		BOOL 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
406		BOOL nsc_context_set_parameters(NSC_CONTEXT* WINPR_RESTRICT context, NSC_PARAMETER what,
407		UINT32 value)
408	34.1k	{
409	34.1k	if (!context)
410	0	return FALSE;
411
412	34.1k	switch (what)
413	34.1k	{
414	0	case NSC_COLOR_LOSS_LEVEL:
415	0	context->ColorLossLevel = value;
416	0	break;
417	0	case NSC_ALLOW_SUBSAMPLING:
418	0	context->ChromaSubsamplingLevel = value;
419	0	break;
420	0	case NSC_DYNAMIC_COLOR_FIDELITY:
421	0	context->DynamicColorFidelity = value != 0;
422	0	break;
423	34.1k	case NSC_COLOR_FORMAT:
424	34.1k	context->format = value;
425	34.1k	break;
426	0	default:
427	0	return FALSE;
428	34.1k	}
429	34.1k	return TRUE;
430	34.1k	}
431
432		BOOL 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	705	{
437	705	WINPR_ASSERT(context);
438	705	WINPR_ASSERT(context->priv);
439
440	705	wStream sbuffer = WINPR_C_ARRAY_INIT;
441	705	BOOL ret = 0;
442	705	if (!data \|\| !pDstData)
443	0	{
444	0	WLog_Print(context->priv->log, WLOG_ERROR, "Invalid argument: data=%p, pDstData=%p",
445	0	(const void)data, (void)pDstData);
446	0	return FALSE;
447	0	}
448
449	705	if (nXDst > nWidth)
450	0	{
451	0	WLog_Print(context->priv->log, WLOG_ERROR, "nXDst %" PRIu32 " > nWidth %" PRIu32, nXDst,
452	0	nWidth);
453	0	return FALSE;
454	0	}
455	705	if (nYDst > nHeight)
456	0	{
457	0	WLog_Print(context->priv->log, WLOG_ERROR, "nYDst %" PRIu32 " > nHeight %" PRIu32, nYDst,
458	0	nHeight);
459	0	return FALSE;
460	0	}
461
462	705	wStream* s = Stream_StaticConstInit(&sbuffer, data, length);
463	705	if (!s)
464	0	return FALSE;
465
466	705	const UINT32 minStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
467	705	if (nDstStride == 0)
468	705	nDstStride = minStride;
469	705	if (nDstStride < minStride)
470	0	{
471	0	WLog_Print(context->priv->log, WLOG_ERROR,
472	0	"nDstStride %" PRIu32 " < minimum stride %" PRIu32, nDstStride, minStride);
473	0	return FALSE;
474	0	}
475
476	705	switch (bpp)
477	705	{
478	705	case 32:
479	705	context->format = PIXEL_FORMAT_BGRA32;
480	705	break;
481
482	0	case 24:
483	0	context->format = PIXEL_FORMAT_BGR24;
484	0	break;
485
486	0	case 16:
487	0	context->format = PIXEL_FORMAT_BGR16;
488	0	break;
489
490	0	case 8:
491	0	context->format = PIXEL_FORMAT_RGB8;
492	0	break;
493
494	0	case 4:
495	0	context->format = PIXEL_FORMAT_A4;
496	0	break;
497
498	0	default:
499	0	return FALSE;
500	705	}
501
502	705	context->width = WINPR_ASSERTING_INT_CAST(UINT16, width);
503	705	context->height = WINPR_ASSERTING_INT_CAST(UINT16, height);
504	705	ret = nsc_context_initialize(context, s);
505
506	705	if (!ret)
507	145	return FALSE;
508
509		/* RLE decode */
510	560	{
511	560	BOOL rc = 0;
512	560	PROFILER_ENTER(context->priv->prof_nsc_rle_decompress_data)
513	560	rc = nsc_rle_decompress_data(context);
514	560	PROFILER_EXIT(context->priv->prof_nsc_rle_decompress_data)
515
516	560	if (!rc)
517	195	return FALSE;
518	560	}
519		/* Colorloss recover, Chroma supersample and AYCoCg to ARGB Conversion in one step */
520	365	{
521	365	BOOL rc = 0;
522	365	PROFILER_ENTER(context->priv->prof_nsc_decode)
523	365	rc = context->decode(context);
524	365	PROFILER_EXIT(context->priv->prof_nsc_decode)
525
526	365	if (!rc)
527	0	return FALSE;
528	365	}
529
530	365	return (freerdp_image_copy_no_overlap(pDstData, DstFormat, nDstStride, nXDst, nYDst, width,
531	365	height, context->BitmapData, PIXEL_FORMAT_BGRA32, 0, 0, 0,
532	365	nullptr, flip));
533	365	}