/src/FreeRDP/libfreerdp/primitives/prim_copy.c

Source (jump to first uncovered line)
/* FreeRDP: A Remote Desktop Protocol Client
 * Copy operations.
 * vi:ts=4 sw=4:
 *
 * (c) Copyright 2012 Hewlett-Packard Development Company, L.P.
 * 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 <string.h>
#include <freerdp/types.h>
#include <freerdp/primitives.h>
#include <freerdp/log.h>

#include "prim_internal.h"
#include "prim_copy.h"
#include "../codec/color.h"

#include <freerdp/codec/color.h>

static primitives_t* generic = NULL;

/* ------------------------------------------------------------------------- */
/*static inline BOOL memory_regions_overlap_1d(*/
static BOOL memory_regions_overlap_1d(const BYTE* p1, const BYTE* p2, size_t bytes)
{
  const ULONG_PTR p1m = (const ULONG_PTR)p1;
  const ULONG_PTR p2m = (const ULONG_PTR)p2;

  if (p1m <= p2m)
  {
    if (p1m + bytes > p2m)
      return TRUE;
  }
  else
  {
    if (p2m + bytes > p1m)
      return TRUE;
  }

  /* else */
  return FALSE;
}

/* ------------------------------------------------------------------------- */
/*static inline BOOL memory_regions_overlap_2d( */
static BOOL memory_regions_overlap_2d(const BYTE* p1, int p1Step, int p1Size, const BYTE* p2,
                                      int p2Step, int p2Size, int width, int height)
{
  ULONG_PTR p1m = (ULONG_PTR)p1;
  ULONG_PTR p2m = (ULONG_PTR)p2;

  if (p1m <= p2m)
  {
    ULONG_PTR p1mEnd = p1m +
                       1ull * (WINPR_ASSERTING_INT_CAST(uint32_t, height - 1)) *
                           WINPR_ASSERTING_INT_CAST(uint32_t, p1Step) +
                       1ull * WINPR_ASSERTING_INT_CAST(uint32_t, width* p1Size);

    if (p1mEnd > p2m)
      return TRUE;
  }
  else
  {
    ULONG_PTR p2mEnd = p2m +
                       1ull * (WINPR_ASSERTING_INT_CAST(uintptr_t, height - 1)) *
                           WINPR_ASSERTING_INT_CAST(uintptr_t, p2Step) +
                       1ull * WINPR_ASSERTING_INT_CAST(uintptr_t, width* p2Size);

    if (p2mEnd > p1m)
      return TRUE;
  }

  /* else */
  return FALSE;
}

/* ------------------------------------------------------------------------- */
static pstatus_t general_copy_8u(const BYTE* WINPR_RESTRICT pSrc, BYTE* WINPR_RESTRICT pDst,
                                 INT32 len)
{
  if (memory_regions_overlap_1d(pSrc, pDst, (size_t)len))
  {
    memmove((void*)pDst, (const void*)pSrc, (size_t)len);
  }
  else
  {
    memcpy((void*)pDst, (const void*)pSrc, (size_t)len);
  }

  return PRIMITIVES_SUCCESS;
}

/* ------------------------------------------------------------------------- */
/* Copy a block of pixels from one buffer to another.
 * The addresses are assumed to have been already offset to the upper-left
 * corners of the source and destination region of interest.
 */
static pstatus_t general_copy_8u_AC4r(const BYTE* WINPR_RESTRICT pSrc, INT32 srcStep,
                                      BYTE* WINPR_RESTRICT pDst, INT32 dstStep, INT32 width,
                                      INT32 height)
{
  const BYTE* src = pSrc;
  BYTE* dst = pDst;
  const size_t rowbytes = WINPR_ASSERTING_INT_CAST(size_t, width) * sizeof(UINT32);

  if ((width == 0) || (height == 0))
    return PRIMITIVES_SUCCESS;

  if (memory_regions_overlap_2d(pSrc, srcStep, sizeof(UINT32), pDst, dstStep, sizeof(UINT32),
                                width, height))
  {
    do
    {
      generic->copy(src, dst, WINPR_ASSERTING_INT_CAST(int32_t, rowbytes));
      src += srcStep;
      dst += dstStep;
    } while (--height);
  }
  else
  {
    /* TODO: do it in one operation when the rowdata is adjacent. */
    do
    {
      /* If we find a replacement for memcpy that is consistently
       * faster, this could be replaced with that.
       */
      memcpy(dst, src, rowbytes);
      src += srcStep;
      dst += dstStep;
    } while (--height);
  }

  return PRIMITIVES_SUCCESS;
}

static INLINE pstatus_t generic_image_copy_bgr24_bgrx32(BYTE* WINPR_RESTRICT pDstData,
                                                        UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
                                                        UINT32 nWidth, UINT32 nHeight,
                                                        const BYTE* WINPR_RESTRICT pSrcData,
                                                        UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
                                                        int64_t srcVMultiplier, int64_t srcVOffset,
                                                        int64_t dstVMultiplier, int64_t dstVOffset)
{

  const int64_t srcByte = 3;
  const int64_t dstByte = 4;

  const UINT32 width = nWidth - nWidth % 8;

  for (int64_t y = 0; y < nHeight; y++)
  {
    const BYTE* WINPR_RESTRICT srcLine =
        &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
    BYTE* WINPR_RESTRICT dstLine =
        &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];

    int64_t x = 0;
    WINPR_PRAGMA_UNROLL_LOOP
    for (; x < width; x++)
    {
      dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
      dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
      dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
    }

    for (; x < nWidth; x++)
    {
      dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
      dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
      dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
    }
  }

  return PRIMITIVES_SUCCESS;
}

static INLINE pstatus_t generic_image_copy_bgrx32_bgrx32(
    BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
    UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, UINT32 nSrcStep, UINT32 nXSrc,
    UINT32 nYSrc, int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier,
    int64_t dstVOffset)
{

  const int64_t srcByte = 4;
  const int64_t dstByte = 4;

  const UINT32 width = nWidth - nWidth % 8;

  for (int64_t y = 0; y < nHeight; y++)
  {
    const BYTE* WINPR_RESTRICT srcLine =
        &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
    BYTE* WINPR_RESTRICT dstLine =
        &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];

    int64_t x = 0;
    WINPR_PRAGMA_UNROLL_LOOP
    for (; x < width; x++)
    {
      dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
      dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
      dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
    }
    for (; x < nWidth; x++)
    {
      dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
      dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
      dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
    }
  }

  return PRIMITIVES_SUCCESS;
}

pstatus_t generic_image_copy_no_overlap_convert(
    BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
    UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
    int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset)
{
  const int64_t srcByte = FreeRDPGetBytesPerPixel(SrcFormat);
  const int64_t dstByte = FreeRDPGetBytesPerPixel(DstFormat);

  const UINT32 width = nWidth - nWidth % 8;
  for (int64_t y = 0; y < nHeight; y++)
  {
    const BYTE* WINPR_RESTRICT srcLine =
        &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
    BYTE* WINPR_RESTRICT dstLine =
        &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];

    int64_t x = 0;
    // WINPR_PRAGMA_UNROLL_LOOP
    for (; x < width; x++)
    {
      const UINT32 color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
      const UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
      FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
    }
    for (; x < nWidth; x++)
    {
      const UINT32 color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
      const UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
      FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
    }
  }
  return PRIMITIVES_SUCCESS;
}

pstatus_t generic_image_copy_no_overlap_memcpy(
    BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
    UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
    WINPR_ATTR_UNUSED const gdiPalette* WINPR_RESTRICT palette, int64_t srcVMultiplier,
    int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset, WINPR_ATTR_UNUSED UINT32 flags)
{
  const int64_t dstByte = FreeRDPGetBytesPerPixel(DstFormat);
  const int64_t srcByte = FreeRDPGetBytesPerPixel(SrcFormat);
  const int64_t copyDstWidth = nWidth * dstByte;
  const int64_t xSrcOffset = nXSrc * srcByte;
  const int64_t xDstOffset = nXDst * dstByte;

  for (int64_t y = 0; y < nHeight; y++)
  {
    const BYTE* WINPR_RESTRICT srcLine =
        &pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
    BYTE* WINPR_RESTRICT dstLine =
        &pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
    memcpy(&dstLine[xDstOffset], &srcLine[xSrcOffset],
           WINPR_ASSERTING_INT_CAST(size_t, copyDstWidth));
  }

  return PRIMITIVES_SUCCESS;
}

static INLINE pstatus_t generic_image_copy_no_overlap_dst_alpha(
    BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
    UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
    int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset)
{
  WINPR_ASSERT(pDstData);
  WINPR_ASSERT(pSrcData);

  switch (SrcFormat)
  {
    case PIXEL_FORMAT_BGR24:
      switch (DstFormat)
      {
        case PIXEL_FORMAT_BGRX32:
        case PIXEL_FORMAT_BGRA32:
          return generic_image_copy_bgr24_bgrx32(
              pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
              nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
        default:
          break;
      }
      break;
    case PIXEL_FORMAT_BGRX32:
    case PIXEL_FORMAT_BGRA32:
      switch (DstFormat)
      {
        case PIXEL_FORMAT_BGRX32:
        case PIXEL_FORMAT_BGRA32:
          return generic_image_copy_bgrx32_bgrx32(
              pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
              nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
        default:
          break;
      }
      break;
    case PIXEL_FORMAT_RGBX32:
    case PIXEL_FORMAT_RGBA32:
      switch (DstFormat)
      {
        case PIXEL_FORMAT_RGBX32:
        case PIXEL_FORMAT_RGBA32:
          return generic_image_copy_bgrx32_bgrx32(
              pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
              nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
        case PIXEL_FORMAT_RGB24:
          return generic_image_copy_bgr24_bgrx32(
              pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
              nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
        default:
          break;
      }
      break;
    default:
      break;
  }

  return generic_image_copy_no_overlap_convert(
      pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, SrcFormat, nSrcStep,
      nXSrc, nYSrc, palette, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
}

static INLINE pstatus_t generic_image_copy_no_overlap_no_alpha(
    BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
    UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
    UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
    int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset,
    UINT32 flags)
{
  if (FreeRDPAreColorFormatsEqualNoAlpha(SrcFormat, DstFormat))
    return generic_image_copy_no_overlap_memcpy(pDstData, DstFormat, nDstStep, nXDst, nYDst,
                                                nWidth, nHeight, pSrcData, SrcFormat, nSrcStep,
                                                nXSrc, nYSrc, palette, srcVMultiplier,
                                                srcVOffset, dstVMultiplier, dstVOffset, flags);
  else
    return generic_image_copy_no_overlap_convert(pDstData, DstFormat, nDstStep, nXDst, nYDst,
                                                 nWidth, nHeight, pSrcData, SrcFormat, nSrcStep,
                                                 nXSrc, nYSrc, palette, srcVMultiplier,
                                                 srcVOffset, dstVMultiplier, dstVOffset);
}

static pstatus_t generic_image_copy_no_overlap(BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat,
                                               UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
                                               UINT32 nWidth, UINT32 nHeight,
                                               const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
                                               UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
                                               const gdiPalette* WINPR_RESTRICT palette,
                                               UINT32 flags)
{
  const BOOL vSrcVFlip = (flags & FREERDP_FLIP_VERTICAL) ? TRUE : FALSE;
  int64_t srcVOffset = 0;
  int64_t srcVMultiplier = 1;
  int64_t dstVOffset = 0;
  int64_t dstVMultiplier = 1;

  if ((nWidth == 0) || (nHeight == 0))
    return PRIMITIVES_SUCCESS;

  if ((nHeight > INT32_MAX) || (nWidth > INT32_MAX))
    return -1;

  if (!pDstData || !pSrcData)
    return -1;

  if (nDstStep == 0)
    nDstStep = nWidth * FreeRDPGetBytesPerPixel(DstFormat);

  if (nSrcStep == 0)
    nSrcStep = nWidth * FreeRDPGetBytesPerPixel(SrcFormat);

  if (vSrcVFlip)
  {
    srcVOffset = (nHeight - 1ll) * nSrcStep;
    srcVMultiplier = -1;
  }

  if (((flags & FREERDP_KEEP_DST_ALPHA) != 0) && FreeRDPColorHasAlpha(DstFormat))
    return generic_image_copy_no_overlap_dst_alpha(
        pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, SrcFormat,
        nSrcStep, nXSrc, nYSrc, palette, srcVMultiplier, srcVOffset, dstVMultiplier,
        dstVOffset);
  else
    return generic_image_copy_no_overlap_no_alpha(
        pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, SrcFormat,
        nSrcStep, nXSrc, nYSrc, palette, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset,
        flags);

  return PRIMITIVES_SUCCESS;
}

/* ------------------------------------------------------------------------- */
void primitives_init_copy(primitives_t* WINPR_RESTRICT prims)
{
  /* Start with the default. */
  prims->copy_8u = general_copy_8u;
  prims->copy_8u_AC4r = general_copy_8u_AC4r;
  prims->copy = WINPR_FUNC_PTR_CAST(prims->copy_8u, fn_copy_t);
  prims->copy_no_overlap = generic_image_copy_no_overlap;
}

void primitives_init_copy_opt(primitives_t* WINPR_RESTRICT prims)
{
  primitives_init_copy(prims);
  primitives_init_copy_sse41(prims);
#if defined(WITH_AVX2)
  primitives_init_copy_avx2(prims);
#endif
}

Coverage Report

Created: 2025-07-01 06:46

Line	Count	Source (jump to first uncovered line)
1		/* FreeRDP: A Remote Desktop Protocol Client
2		* Copy operations.
3		* vi:ts=4 sw=4:
4		*
5		* (c) Copyright 2012 Hewlett-Packard Development Company, L.P.
6		* Licensed under the Apache License, Version 2.0 (the "License"); you may
7		* not use this file except in compliance with the License. You may obtain
8		* a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
9		* Unless required by applicable law or agreed to in writing, software
10		* distributed under the License is distributed on an "AS IS" BASIS,
11		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		#include <freerdp/config.h>
17
18		#include <string.h>
19		#include <freerdp/types.h>
20		#include <freerdp/primitives.h>
21		#include <freerdp/log.h>
22
23		#include "prim_internal.h"
24		#include "prim_copy.h"
25		#include "../codec/color.h"
26
27		#include <freerdp/codec/color.h>
28
29		static primitives_t* generic = NULL;
30
31		/* ------------------------------------------------------------------------- */
32		/static inline BOOL memory_regions_overlap_1d(/
33		static BOOL memory_regions_overlap_1d(const BYTE* p1, const BYTE* p2, size_t bytes)
34	0	{
35	0	const ULONG_PTR p1m = (const ULONG_PTR)p1;
36	0	const ULONG_PTR p2m = (const ULONG_PTR)p2;
37
38	0	if (p1m <= p2m)
39	0	{
40	0	if (p1m + bytes > p2m)
41	0	return TRUE;
42	0	}
43	0	else
44	0	{
45	0	if (p2m + bytes > p1m)
46	0	return TRUE;
47	0	}
48
49		/* else */
50	0	return FALSE;
51	0	}
52
53		/* ------------------------------------------------------------------------- */
54		/static inline BOOL memory_regions_overlap_2d( /
55		static BOOL memory_regions_overlap_2d(const BYTE* p1, int p1Step, int p1Size, const BYTE* p2,
56		int p2Step, int p2Size, int width, int height)
57	0	{
58	0	ULONG_PTR p1m = (ULONG_PTR)p1;
59	0	ULONG_PTR p2m = (ULONG_PTR)p2;
60
61	0	if (p1m <= p2m)
62	0	{
63	0	ULONG_PTR p1mEnd = p1m +
64	0	1ull * (WINPR_ASSERTING_INT_CAST(uint32_t, height - 1)) *
65	0	WINPR_ASSERTING_INT_CAST(uint32_t, p1Step) +
66	0	1ull * WINPR_ASSERTING_INT_CAST(uint32_t, width* p1Size);
67
68	0	if (p1mEnd > p2m)
69	0	return TRUE;
70	0	}
71	0	else
72	0	{
73	0	ULONG_PTR p2mEnd = p2m +
74	0	1ull * (WINPR_ASSERTING_INT_CAST(uintptr_t, height - 1)) *
75	0	WINPR_ASSERTING_INT_CAST(uintptr_t, p2Step) +
76	0	1ull * WINPR_ASSERTING_INT_CAST(uintptr_t, width* p2Size);
77
78	0	if (p2mEnd > p1m)
79	0	return TRUE;
80	0	}
81
82		/* else */
83	0	return FALSE;
84	0	}
85
86		/* ------------------------------------------------------------------------- */
87		static pstatus_t general_copy_8u(const BYTE* WINPR_RESTRICT pSrc, BYTE* WINPR_RESTRICT pDst,
88		INT32 len)
89	0	{
90	0	if (memory_regions_overlap_1d(pSrc, pDst, (size_t)len))
91	0	{
92	0	memmove((void)pDst, (const void)pSrc, (size_t)len);
93	0	}
94	0	else
95	0	{
96	0	memcpy((void)pDst, (const void)pSrc, (size_t)len);
97	0	}
98
99	0	return PRIMITIVES_SUCCESS;
100	0	}
101
102		/* ------------------------------------------------------------------------- */
103		/* Copy a block of pixels from one buffer to another.
104		* The addresses are assumed to have been already offset to the upper-left
105		* corners of the source and destination region of interest.
106		*/
107		static pstatus_t general_copy_8u_AC4r(const BYTE* WINPR_RESTRICT pSrc, INT32 srcStep,
108		BYTE* WINPR_RESTRICT pDst, INT32 dstStep, INT32 width,
109		INT32 height)
110	0	{
111	0	const BYTE* src = pSrc;
112	0	BYTE* dst = pDst;
113	0	const size_t rowbytes = WINPR_ASSERTING_INT_CAST(size_t, width) * sizeof(UINT32);
114
115	0	if ((width == 0) \|\| (height == 0))
116	0	return PRIMITIVES_SUCCESS;
117
118	0	if (memory_regions_overlap_2d(pSrc, srcStep, sizeof(UINT32), pDst, dstStep, sizeof(UINT32),
119	0	width, height))
120	0	{
121	0	do
122	0	{
123	0	generic->copy(src, dst, WINPR_ASSERTING_INT_CAST(int32_t, rowbytes));
124	0	src += srcStep;
125	0	dst += dstStep;
126	0	} while (--height);
127	0	}
128	0	else
129	0	{
130		/* TODO: do it in one operation when the rowdata is adjacent. */
131	0	do
132	0	{
133		/* If we find a replacement for memcpy that is consistently
134		* faster, this could be replaced with that.
135		*/
136	0	memcpy(dst, src, rowbytes);
137	0	src += srcStep;
138	0	dst += dstStep;
139	0	} while (--height);
140	0	}
141
142	0	return PRIMITIVES_SUCCESS;
143	0	}
144
145		static INLINE pstatus_t generic_image_copy_bgr24_bgrx32(BYTE* WINPR_RESTRICT pDstData,
146		UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
147		UINT32 nWidth, UINT32 nHeight,
148		const BYTE* WINPR_RESTRICT pSrcData,
149		UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
150		int64_t srcVMultiplier, int64_t srcVOffset,
151		int64_t dstVMultiplier, int64_t dstVOffset)
152	0	{
153
154	0	const int64_t srcByte = 3;
155	0	const int64_t dstByte = 4;
156
157	0	const UINT32 width = nWidth - nWidth % 8;
158
159	0	for (int64_t y = 0; y < nHeight; y++)
160	0	{
161	0	const BYTE* WINPR_RESTRICT srcLine =
162	0	&pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
163	0	BYTE* WINPR_RESTRICT dstLine =
164	0	&pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
165
166	0	int64_t x = 0;
167	0	WINPR_PRAGMA_UNROLL_LOOP
168	0	for (; x < width; x++)
169	0	{
170	0	dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
171	0	dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
172	0	dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
173	0	}
174
175	0	for (; x < nWidth; x++)
176	0	{
177	0	dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
178	0	dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
179	0	dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
180	0	}
181	0	}
182
183	0	return PRIMITIVES_SUCCESS;
184	0	}
185
186		static INLINE pstatus_t generic_image_copy_bgrx32_bgrx32(
187		BYTE* WINPR_RESTRICT pDstData, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
188		UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, UINT32 nSrcStep, UINT32 nXSrc,
189		UINT32 nYSrc, int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier,
190		int64_t dstVOffset)
191	0	{
192
193	0	const int64_t srcByte = 4;
194	0	const int64_t dstByte = 4;
195
196	0	const UINT32 width = nWidth - nWidth % 8;
197
198	0	for (int64_t y = 0; y < nHeight; y++)
199	0	{
200	0	const BYTE* WINPR_RESTRICT srcLine =
201	0	&pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
202	0	BYTE* WINPR_RESTRICT dstLine =
203	0	&pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
204
205	0	int64_t x = 0;
206	0	WINPR_PRAGMA_UNROLL_LOOP
207	0	for (; x < width; x++)
208	0	{
209	0	dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
210	0	dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
211	0	dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
212	0	}
213	0	for (; x < nWidth; x++)
214	0	{
215	0	dstLine[(x + nXDst) * dstByte + 0] = srcLine[(x + nXSrc) * srcByte + 0];
216	0	dstLine[(x + nXDst) * dstByte + 1] = srcLine[(x + nXSrc) * srcByte + 1];
217	0	dstLine[(x + nXDst) * dstByte + 2] = srcLine[(x + nXSrc) * srcByte + 2];
218	0	}
219	0	}
220
221	0	return PRIMITIVES_SUCCESS;
222	0	}
223
224		pstatus_t generic_image_copy_no_overlap_convert(
225		BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
226		UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
227		UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
228		int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset)
229	0	{
230	0	const int64_t srcByte = FreeRDPGetBytesPerPixel(SrcFormat);
231	0	const int64_t dstByte = FreeRDPGetBytesPerPixel(DstFormat);
232
233	0	const UINT32 width = nWidth - nWidth % 8;
234	0	for (int64_t y = 0; y < nHeight; y++)
235	0	{
236	0	const BYTE* WINPR_RESTRICT srcLine =
237	0	&pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
238	0	BYTE* WINPR_RESTRICT dstLine =
239	0	&pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
240
241	0	int64_t x = 0;
242		// WINPR_PRAGMA_UNROLL_LOOP
243	0	for (; x < width; x++)
244	0	{
245	0	const UINT32 color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
246	0	const UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
247	0	FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
248	0	}
249	0	for (; x < nWidth; x++)
250	0	{
251	0	const UINT32 color = FreeRDPReadColor_int(&srcLine[(x + nXSrc) * srcByte], SrcFormat);
252	0	const UINT32 dstColor = FreeRDPConvertColor(color, SrcFormat, DstFormat, palette);
253	0	FreeRDPWriteColor_int(&dstLine[(x + nXDst) * dstByte], DstFormat, dstColor);
254	0	}
255	0	}
256	0	return PRIMITIVES_SUCCESS;
257	0	}
258
259		pstatus_t generic_image_copy_no_overlap_memcpy(
260		BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
261		UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
262		UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
263		WINPR_ATTR_UNUSED const gdiPalette* WINPR_RESTRICT palette, int64_t srcVMultiplier,
264		int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset, WINPR_ATTR_UNUSED UINT32 flags)
265	0	{
266	0	const int64_t dstByte = FreeRDPGetBytesPerPixel(DstFormat);
267	0	const int64_t srcByte = FreeRDPGetBytesPerPixel(SrcFormat);
268	0	const int64_t copyDstWidth = nWidth * dstByte;
269	0	const int64_t xSrcOffset = nXSrc * srcByte;
270	0	const int64_t xDstOffset = nXDst * dstByte;
271
272	0	for (int64_t y = 0; y < nHeight; y++)
273	0	{
274	0	const BYTE* WINPR_RESTRICT srcLine =
275	0	&pSrcData[srcVMultiplier * (y + nYSrc) * nSrcStep + srcVOffset];
276	0	BYTE* WINPR_RESTRICT dstLine =
277	0	&pDstData[dstVMultiplier * (y + nYDst) * nDstStep + dstVOffset];
278	0	memcpy(&dstLine[xDstOffset], &srcLine[xSrcOffset],
279	0	WINPR_ASSERTING_INT_CAST(size_t, copyDstWidth));
280	0	}
281
282	0	return PRIMITIVES_SUCCESS;
283	0	}
284
285		static INLINE pstatus_t generic_image_copy_no_overlap_dst_alpha(
286		BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
287		UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
288		UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
289		int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset)
290	0	{
291	0	WINPR_ASSERT(pDstData);
292	0	WINPR_ASSERT(pSrcData);
293
294	0	switch (SrcFormat)
295	0	{
296	0	case PIXEL_FORMAT_BGR24:
297	0	switch (DstFormat)
298	0	{
299	0	case PIXEL_FORMAT_BGRX32:
300	0	case PIXEL_FORMAT_BGRA32:
301	0	return generic_image_copy_bgr24_bgrx32(
302	0	pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
303	0	nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
304	0	default:
305	0	break;
306	0	}
307	0	break;
308	0	case PIXEL_FORMAT_BGRX32:
309	0	case PIXEL_FORMAT_BGRA32:
310	0	switch (DstFormat)
311	0	{
312	0	case PIXEL_FORMAT_BGRX32:
313	0	case PIXEL_FORMAT_BGRA32:
314	0	return generic_image_copy_bgrx32_bgrx32(
315	0	pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
316	0	nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
317	0	default:
318	0	break;
319	0	}
320	0	break;
321	0	case PIXEL_FORMAT_RGBX32:
322	0	case PIXEL_FORMAT_RGBA32:
323	0	switch (DstFormat)
324	0	{
325	0	case PIXEL_FORMAT_RGBX32:
326	0	case PIXEL_FORMAT_RGBA32:
327	0	return generic_image_copy_bgrx32_bgrx32(
328	0	pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
329	0	nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
330	0	case PIXEL_FORMAT_RGB24:
331	0	return generic_image_copy_bgr24_bgrx32(
332	0	pDstData, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, nSrcStep,
333	0	nXSrc, nYSrc, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
334	0	default:
335	0	break;
336	0	}
337	0	break;
338	0	default:
339	0	break;
340	0	}
341
342	0	return generic_image_copy_no_overlap_convert(
343	0	pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, SrcFormat, nSrcStep,
344	0	nXSrc, nYSrc, palette, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset);
345	0	}
346
347		static INLINE pstatus_t generic_image_copy_no_overlap_no_alpha(
348		BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
349		UINT32 nWidth, UINT32 nHeight, const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
350		UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc, const gdiPalette* WINPR_RESTRICT palette,
351		int64_t srcVMultiplier, int64_t srcVOffset, int64_t dstVMultiplier, int64_t dstVOffset,
352		UINT32 flags)
353	0	{
354	0	if (FreeRDPAreColorFormatsEqualNoAlpha(SrcFormat, DstFormat))
355	0	return generic_image_copy_no_overlap_memcpy(pDstData, DstFormat, nDstStep, nXDst, nYDst,
356	0	nWidth, nHeight, pSrcData, SrcFormat, nSrcStep,
357	0	nXSrc, nYSrc, palette, srcVMultiplier,
358	0	srcVOffset, dstVMultiplier, dstVOffset, flags);
359	0	else
360	0	return generic_image_copy_no_overlap_convert(pDstData, DstFormat, nDstStep, nXDst, nYDst,
361	0	nWidth, nHeight, pSrcData, SrcFormat, nSrcStep,
362	0	nXSrc, nYSrc, palette, srcVMultiplier,
363	0	srcVOffset, dstVMultiplier, dstVOffset);
364	0	}
365
366		static pstatus_t generic_image_copy_no_overlap(BYTE* WINPR_RESTRICT pDstData, DWORD DstFormat,
367		UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
368		UINT32 nWidth, UINT32 nHeight,
369		const BYTE* WINPR_RESTRICT pSrcData, DWORD SrcFormat,
370		UINT32 nSrcStep, UINT32 nXSrc, UINT32 nYSrc,
371		const gdiPalette* WINPR_RESTRICT palette,
372		UINT32 flags)
373	0	{
374	0	const BOOL vSrcVFlip = (flags & FREERDP_FLIP_VERTICAL) ? TRUE : FALSE;
375	0	int64_t srcVOffset = 0;
376	0	int64_t srcVMultiplier = 1;
377	0	int64_t dstVOffset = 0;
378	0	int64_t dstVMultiplier = 1;
379
380	0	if ((nWidth == 0) \|\| (nHeight == 0))
381	0	return PRIMITIVES_SUCCESS;
382
383	0	if ((nHeight > INT32_MAX) \|\| (nWidth > INT32_MAX))
384	0	return -1;
385
386	0	if (!pDstData \|\| !pSrcData)
387	0	return -1;
388
389	0	if (nDstStep == 0)
390	0	nDstStep = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
391
392	0	if (nSrcStep == 0)
393	0	nSrcStep = nWidth * FreeRDPGetBytesPerPixel(SrcFormat);
394
395	0	if (vSrcVFlip)
396	0	{
397	0	srcVOffset = (nHeight - 1ll) * nSrcStep;
398	0	srcVMultiplier = -1;
399	0	}
400
401	0	if (((flags & FREERDP_KEEP_DST_ALPHA) != 0) && FreeRDPColorHasAlpha(DstFormat))
402	0	return generic_image_copy_no_overlap_dst_alpha(
403	0	pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, SrcFormat,
404	0	nSrcStep, nXSrc, nYSrc, palette, srcVMultiplier, srcVOffset, dstVMultiplier,
405	0	dstVOffset);
406	0	else
407	0	return generic_image_copy_no_overlap_no_alpha(
408	0	pDstData, DstFormat, nDstStep, nXDst, nYDst, nWidth, nHeight, pSrcData, SrcFormat,
409	0	nSrcStep, nXSrc, nYSrc, palette, srcVMultiplier, srcVOffset, dstVMultiplier, dstVOffset,
410	0	flags);
411
412	0	return PRIMITIVES_SUCCESS;
413	0	}
414
415		/* ------------------------------------------------------------------------- */
416		void primitives_init_copy(primitives_t* WINPR_RESTRICT prims)
417	0	{
418		/* Start with the default. */
419	0	prims->copy_8u = general_copy_8u;
420	0	prims->copy_8u_AC4r = general_copy_8u_AC4r;
421	0	prims->copy = WINPR_FUNC_PTR_CAST(prims->copy_8u, fn_copy_t);
422	0	prims->copy_no_overlap = generic_image_copy_no_overlap;
423	0	}
424
425		void primitives_init_copy_opt(primitives_t* WINPR_RESTRICT prims)
426	0	{
427	0	primitives_init_copy(prims);
428	0	primitives_init_copy_sse41(prims);
429	0	#if defined(WITH_AVX2)
430	0	primitives_init_copy_avx2(prims);
431	0	#endif
432	0	}