/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Generic YUV/RGB conversion operations

 *

 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2015-2017 Armin Novak <armin.novak@thincast.com>

 * Copyright 2015-2017 Norbert Federa <norbert.federa@thincast.com>

 * Copyright 2015-2017 Vic Lee

 * Copyright 2015-2017 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 <winpr/wtypes.h>

#include <freerdp/config.h>

#include <freerdp/types.h>

#include <freerdp/primitives.h>

#include <freerdp/codec/color.h>

#include "prim_internal.h"

#include "prim_YUV.h"

static pstatus_t general_LumaToYUV444(const BYTE* const WINPR_RESTRICT pSrcRaw[3],

                                      const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDstRaw[3],

                                      const UINT32 dstStep[3],

                                      const RECTANGLE_16* WINPR_RESTRICT roi)

{

  const UINT32 nWidth = roi->right - roi->left;

  const UINT32 nHeight = roi->bottom - roi->top;

  const UINT32 halfWidth = (nWidth + 1) / 2;

  const UINT32 halfHeight = (nHeight + 1) / 2;

  const UINT32 oddY = 1;

  const UINT32 evenY = 0;

  const UINT32 oddX = 1;

  const UINT32 evenX = 0;

  const BYTE* pSrc[3] = { pSrcRaw[0] + 1ULL * roi->top * srcStep[0] + roi->left,

                        pSrcRaw[1] + 1ULL * roi->top / 2 * srcStep[1] + roi->left / 2,

                        pSrcRaw[2] + 1ULL * roi->top / 2 * srcStep[2] + roi->left / 2 };

  BYTE* pDst[3] = { pDstRaw[0] + 1ULL * roi->top * dstStep[0] + roi->left,

                  pDstRaw[1] + 1ULL * roi->top * dstStep[1] + roi->left,

                  pDstRaw[2] + 1ULL * roi->top * dstStep[2] + roi->left };

  /* Y data is already here... */

  /* B1 */

  for (size_t y = 0; y < nHeight; y++)

  {

    const BYTE* Ym = pSrc[0] + y * srcStep[0];

    BYTE* pY = pDst[0] + dstStep[0] * y;

    memcpy(pY, Ym, nWidth);

  }

  /* The first half of U, V are already here part of this frame. */

  /* B2 and B3 */

  for (size_t y = 0; y < halfHeight; y++)

  {

    const UINT32 val2y = (2ULL * y + evenY);

    const UINT32 val2y1 = val2y + oddY;

    const BYTE* Um = pSrc[1] + y * srcStep[1];

    const BYTE* Vm = pSrc[2] + y * srcStep[2];

    BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;

    BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;

    BYTE* pU1 = pDst[1] + 1ULL * dstStep[1] * val2y1;

    BYTE* pV1 = pDst[2] + 1ULL * dstStep[2] * val2y1;

    for (size_t x = 0; x < halfWidth; x++)

    {

      const UINT32 val2x = 2UL * x + evenX;

      const UINT32 val2x1 = val2x + oddX;

      pU[val2x] = Um[x];

      pV[val2x] = Vm[x];

      pU[val2x1] = Um[x];

      pV[val2x1] = Vm[x];

      pU1[val2x] = Um[x];

      pV1[val2x] = Vm[x];

      pU1[val2x1] = Um[x];

      pV1[val2x1] = Vm[x];

    }

  }

  return PRIMITIVES_SUCCESS;

}

static pstatus_t general_ChromaFilter(BYTE* WINPR_RESTRICT pDst[3], const UINT32 dstStep[3],

                                      const RECTANGLE_16* WINPR_RESTRICT roi)

{

  const UINT32 oddY = 1;

  const UINT32 evenY = 0;

  const UINT32 nWidth = roi->right - roi->left;

  const UINT32 nHeight = roi->bottom - roi->top;

  const UINT32 halfHeight = (nHeight + 1) / 2;

  const UINT32 halfWidth = (nWidth + 1) / 2;

  /* Filter */

  for (UINT32 y = roi->top; y < halfHeight + roi->top; y++)

  {

    const UINT32 val2y = (y * 2 + evenY);

    const UINT32 val2y1 = val2y + oddY;

    BYTE* pU1 = pDst[1] + 1ULL * dstStep[1] * val2y1;

    BYTE* pV1 = pDst[2] + 1ULL * dstStep[2] * val2y1;

    BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;

    BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;

    if (val2y1 > nHeight)

      continue;

    for (UINT32 x = roi->left; x < halfWidth + roi->left; x++)

    {

      const UINT32 val2x = (x * 2);

      const UINT32 val2x1 = val2x + 1;

      const BYTE inU = pU[val2x];

      const BYTE inV = pV[val2x];

      const INT32 up = inU * 4;

      const INT32 vp = inV * 4;

      INT32 u2020 = 0;

      INT32 v2020 = 0;

      if (val2x1 > nWidth)

        continue;

      u2020 = up - pU[val2x1] - pU1[val2x] - pU1[val2x1];

      v2020 = vp - pV[val2x1] - pV1[val2x] - pV1[val2x1];

      pU[val2x] = CONDITIONAL_CLIP(u2020, inU);

      pV[val2x] = CONDITIONAL_CLIP(v2020, inV);

    }

  }

  return PRIMITIVES_SUCCESS;

}

static pstatus_t general_ChromaV1ToYUV444(const BYTE* const WINPR_RESTRICT pSrcRaw[3],

                                          const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDstRaw[3],

                                          const UINT32 dstStep[3],

                                          const RECTANGLE_16* WINPR_RESTRICT roi)

{

  const UINT32 mod = 16;

  UINT32 uY = 0;

  UINT32 vY = 0;

  const UINT32 nWidth = roi->right - roi->left;

  const UINT32 nHeight = roi->bottom - roi->top;

  const UINT32 halfWidth = (nWidth) / 2;

  const UINT32 halfHeight = (nHeight) / 2;

  const UINT32 oddY = 1;

  const UINT32 evenY = 0;

  const UINT32 oddX = 1;

  /* The auxilary frame is aligned to multiples of 16x16.

   * We need the padded height for B4 and B5 conversion. */

  const UINT32 padHeigth = nHeight + 16 - nHeight % 16;

  const BYTE* pSrc[3] = { pSrcRaw[0] + 1ULL * roi->top * srcStep[0] + roi->left,

                        pSrcRaw[1] + 1ULL * roi->top / 2 * srcStep[1] + roi->left / 2,

                        pSrcRaw[2] + 1ULL * roi->top / 2 * srcStep[2] + roi->left / 2 };

  BYTE* pDst[3] = { pDstRaw[0] + 1ULL * roi->top * dstStep[0] + roi->left,

                  pDstRaw[1] + 1ULL * roi->top * dstStep[1] + roi->left,

                  pDstRaw[2] + 1ULL * roi->top * dstStep[2] + roi->left };

  /* The second half of U and V is a bit more tricky... */

  /* B4 and B5 */

  for (size_t y = 0; y < padHeigth; y++)

  {

    const BYTE* Ya = pSrc[0] + y * srcStep[0];

    BYTE* pX = NULL;

    if ((y) % mod < (mod + 1) / 2)

    {

      const size_t pos = (2 * uY++ + oddY);

      if (pos >= nHeight)

        continue;

      pX = pDst[1] + dstStep[1] * pos;

    }

    else

    {

      const size_t pos = (2 * vY++ + oddY);

      if (pos >= nHeight)

        continue;

      pX = pDst[2] + dstStep[2] * pos;

    }

    memcpy(pX, Ya, nWidth);

  }

  /* B6 and B7 */

  for (size_t y = 0; y < halfHeight; y++)

  {

    const UINT32 val2y = (y * 2ULL + evenY);

    const BYTE* Ua = pSrc[1] + y * srcStep[1];

    const BYTE* Va = pSrc[2] + y * srcStep[2];

    BYTE* pU = pDst[1] + 1ULL * dstStep[1] * val2y;

    BYTE* pV = pDst[2] + 1ULL * dstStep[2] * val2y;

    for (size_t x = 0; x < halfWidth; x++)

    {

      const UINT32 val2x1 = (x * 2 + oddX);

      pU[val2x1] = Ua[x];

      pV[val2x1] = Va[x];

    }

  }

  /* Filter */

  return general_ChromaFilter(pDst, dstStep, roi);

}

static pstatus_t general_ChromaV2ToYUV444(const BYTE* const WINPR_RESTRICT pSrc[3],

                                          const UINT32 srcStep[3], UINT32 nTotalWidth,

                                          UINT32 nTotalHeight, BYTE* WINPR_RESTRICT pDst[3],

                                          const UINT32 dstStep[3],

                                          const RECTANGLE_16* WINPR_RESTRICT roi)

{

  const UINT32 nWidth = roi->right - roi->left;

  const UINT32 nHeight = roi->bottom - roi->top;

  const UINT32 halfWidth = (nWidth + 1) / 2;

  const UINT32 halfHeight = (nHeight + 1) / 2;

  const UINT32 quaterWidth = (nWidth + 3) / 4;

  /* B4 and B5: odd UV values for width/2, height */

  for (UINT32 y = 0; y < nHeight; y++)

  {

    const UINT32 yTop = y + roi->top;

    const BYTE* pYaU = pSrc[0] + 1ULL * srcStep[0] * yTop + roi->left / 2;

    const BYTE* pYaV = pYaU + nTotalWidth / 2;

    BYTE* pU = pDst[1] + 1ULL * dstStep[1] * yTop + roi->left;

    BYTE* pV = pDst[2] + 1ULL * dstStep[2] * yTop + roi->left;

    for (size_t x = 0; x < halfWidth; x++)

    {

      const UINT32 odd = 2 * x + 1;

      pU[odd] = *pYaU++;

      pV[odd] = *pYaV++;

    }

  }

  /* B6 - B9 */

  for (size_t y = 0; y < halfHeight; y++)

  {

    const BYTE* pUaU = pSrc[1] + srcStep[1] * (y + roi->top / 2) + roi->left / 4;

    const BYTE* pUaV = pUaU + nTotalWidth / 4;

    const BYTE* pVaU = pSrc[2] + srcStep[2] * (y + roi->top / 2) + roi->left / 4;

    const BYTE* pVaV = pVaU + nTotalWidth / 4;

    BYTE* pU = pDst[1] + 1ULL * dstStep[1] * (2ULL * y + 1 + roi->top) + roi->left;

    BYTE* pV = pDst[2] + 1ULL * dstStep[2] * (2ULL * y + 1 + roi->top) + roi->left;

    for (size_t x = 0; x < quaterWidth; x++)

    {

      pU[4 * x + 0] = *pUaU++;

      pV[4 * x + 0] = *pUaV++;

      pU[4 * x + 2] = *pVaU++;

      pV[4 * x + 2] = *pVaV++;

    }

  }

  return general_ChromaFilter(pDst, dstStep, roi);

}

static pstatus_t general_YUV420CombineToYUV444(avc444_frame_type type,

                                               const BYTE* const WINPR_RESTRICT pSrc[3],

                                               const UINT32 srcStep[3], UINT32 nWidth,

                                               UINT32 nHeight, BYTE* WINPR_RESTRICT pDst[3],

                                               const UINT32 dstStep[3],

                                               const RECTANGLE_16* WINPR_RESTRICT roi)

{

  if (!pSrc || !pSrc[0] || !pSrc[1] || !pSrc[2])

    return -1;

  if (!pDst || !pDst[0] || !pDst[1] || !pDst[2])

    return -1;

  if (!roi)

    return -1;

  switch (type)

  {

    case AVC444_LUMA:

      return general_LumaToYUV444(pSrc, srcStep, pDst, dstStep, roi);

    case AVC444_CHROMAv1:

      return general_ChromaV1ToYUV444(pSrc, srcStep, pDst, dstStep, roi);

    case AVC444_CHROMAv2:

      return general_ChromaV2ToYUV444(pSrc, srcStep, nWidth, nHeight, pDst, dstStep, roi);

    default:

      return -1;

  }

}

static pstatus_t

general_YUV444SplitToYUV420(const BYTE* const WINPR_RESTRICT pSrc[3], const UINT32 srcStep[3],

                            BYTE* WINPR_RESTRICT pMainDst[3], const UINT32 dstMainStep[3],

                            BYTE* WINPR_RESTRICT pAuxDst[3], const UINT32 dstAuxStep[3],

                            const prim_size_t* WINPR_RESTRICT roi)

{

  UINT32 uY = 0;

  UINT32 vY = 0;

  UINT32 halfWidth = 0;

  UINT32 halfHeight = 0;

  /* The auxilary frame is aligned to multiples of 16x16.

   * We need the padded height for B4 and B5 conversion. */

  const UINT32 padHeigth = roi->height + 16 - roi->height % 16;

  halfWidth = (roi->width + 1) / 2;

  halfHeight = (roi->height + 1) / 2;

  /* B1 */

  for (size_t y = 0; y < roi->height; y++)

  {

    const BYTE* pSrcY = pSrc[0] + y * srcStep[0];

    BYTE* pY = pMainDst[0] + y * dstMainStep[0];

    memcpy(pY, pSrcY, roi->width);

  }

  /* B2 and B3 */

  for (size_t y = 0; y < halfHeight; y++)

  {

    const BYTE* pSrcU = pSrc[1] + 2ULL * y * srcStep[1];

    const BYTE* pSrcV = pSrc[2] + 2ULL * y * srcStep[2];

    const BYTE* pSrcU1 = pSrc[1] + (2ULL * y + 1ULL) * srcStep[1];

    const BYTE* pSrcV1 = pSrc[2] + (2ULL * y + 1ULL) * srcStep[2];

    BYTE* pU = pMainDst[1] + y * dstMainStep[1];

    BYTE* pV = pMainDst[2] + y * dstMainStep[2];

    for (size_t x = 0; x < halfWidth; x++)

    {

      /* Filter */

      const INT32 u = pSrcU[2 * x] + pSrcU[2 * x + 1] + pSrcU1[2 * x] + pSrcU1[2 * x + 1];

      const INT32 v = pSrcV[2 * x] + pSrcV[2 * x + 1] + pSrcV1[2 * x] + pSrcV1[2 * x + 1];

      pU[x] = CLIP(u / 4L);

      pV[x] = CLIP(v / 4L);

    }

  }

  /* B4 and B5 */

  for (size_t y = 0; y < padHeigth; y++)

  {

    BYTE* pY = pAuxDst[0] + y * dstAuxStep[0];

    if (y % 16 < 8)

    {

      const size_t pos = (2 * uY++ + 1);

      const BYTE* pSrcU = pSrc[1] + pos * srcStep[1];

      if (pos >= roi->height)

        continue;

      memcpy(pY, pSrcU, roi->width);

    }

    else

    {

      const size_t pos = (2 * vY++ + 1);

      const BYTE* pSrcV = pSrc[2] + pos * srcStep[2];

      if (pos >= roi->height)

        continue;

      memcpy(pY, pSrcV, roi->width);

    }

  }

  /* B6 and B7 */

  for (size_t y = 0; y < halfHeight; y++)

  {

    const BYTE* pSrcU = pSrc[1] + 2 * y * srcStep[1];

    const BYTE* pSrcV = pSrc[2] + 2 * y * srcStep[2];

    BYTE* pU = pAuxDst[1] + y * dstAuxStep[1];

    BYTE* pV = pAuxDst[2] + y * dstAuxStep[2];

    for (size_t x = 0; x < halfWidth; x++)

    {

      pU[x] = pSrcU[2 * x + 1];

      pV[x] = pSrcV[2 * x + 1];

    }

  }

  return PRIMITIVES_SUCCESS;

}

static pstatus_t general_YUV444ToRGB_8u_P3AC4R_general(const BYTE* const WINPR_RESTRICT pSrc[3],

                                                       const UINT32 srcStep[3],

                                                       BYTE* WINPR_RESTRICT pDst, UINT32 dstStep,

                                                       UINT32 DstFormat,

                                                       const prim_size_t* WINPR_RESTRICT roi)

{

  const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);

  fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);

  WINPR_ASSERT(pSrc);

  WINPR_ASSERT(pDst);

  WINPR_ASSERT(roi);

  const UINT32 nWidth = roi->width;

  const UINT32 nHeight = roi->height;

  for (size_t y = 0; y < nHeight; y++)

  {

    const BYTE* pY = pSrc[0] + y * srcStep[0];

    const BYTE* pU = pSrc[1] + y * srcStep[1];

    const BYTE* pV = pSrc[2] + y * srcStep[2];

    BYTE* pRGB = pDst + y * dstStep;

    for (size_t x = 0; x < nWidth; x++)

    {

      const BYTE Y = pY[x];

      const BYTE U = pU[x];

      const BYTE V = pV[x];

      const BYTE r = YUV2R(Y, U, V);

      const BYTE g = YUV2G(Y, U, V);

      const BYTE b = YUV2B(Y, U, V);

      pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);

    }

  }

  return PRIMITIVES_SUCCESS;

}

static pstatus_t general_YUV444ToRGB_8u_P3AC4R_BGRX(const BYTE* const WINPR_RESTRICT pSrc[3],

                                                    const UINT32 srcStep[3],

                                                    BYTE* WINPR_RESTRICT pDst, UINT32 dstStep,

                                                    UINT32 DstFormat,

                                                    const prim_size_t* WINPR_RESTRICT roi)

{

  const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);

  WINPR_ASSERT(pSrc);

  WINPR_ASSERT(pDst);

  WINPR_ASSERT(roi);

  const UINT32 nWidth = roi->width;

  const UINT32 nHeight = roi->height;

  for (size_t y = 0; y < nHeight; y++)

  {

    const BYTE* pY = pSrc[0] + y * srcStep[0];

    const BYTE* pU = pSrc[1] + y * srcStep[1];

    const BYTE* pV = pSrc[2] + y * srcStep[2];

    BYTE* pRGB = pDst + y * dstStep;

    for (size_t x = 0; x < nWidth; x++)

    {

      const BYTE Y = pY[x];

      const BYTE U = pU[x];

      const BYTE V = pV[x];

      const BYTE r = YUV2R(Y, U, V);

      const BYTE g = YUV2G(Y, U, V);

      const BYTE b = YUV2B(Y, U, V);

      pRGB = writePixelBGRX(pRGB, formatSize, DstFormat, r, g, b, 0);

    }

  }

  return PRIMITIVES_SUCCESS;

}

static pstatus_t general_YUV444ToRGB_8u_P3AC4R(const BYTE* const WINPR_RESTRICT pSrc[3],

                                               const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,

                                               UINT32 dstStep, UINT32 DstFormat,

                                               const prim_size_t* WINPR_RESTRICT roi)

{

  switch (DstFormat)

  {

    case PIXEL_FORMAT_BGRA32:

    case PIXEL_FORMAT_BGRX32:

      return general_YUV444ToRGB_8u_P3AC4R_BGRX(pSrc, srcStep, pDst, dstStep, DstFormat, roi);

    default:

      return general_YUV444ToRGB_8u_P3AC4R_general(pSrc, srcStep, pDst, dstStep, DstFormat,

                                                   roi);

  }

}

/**

 * | R |   ( | 256     0    403 | |    Y    | )

 * | G | = ( | 256   -48   -120 | | U - 128 | ) >> 8

 * | B |   ( | 256   475      0 | | V - 128 | )

 */

static pstatus_t general_YUV420ToRGB_8u_P3AC4R(const BYTE* const WINPR_RESTRICT pSrc[3],

                                               const UINT32 srcStep[3], BYTE* WINPR_RESTRICT pDst,

                                               UINT32 dstStep, UINT32 DstFormat,

                                               const prim_size_t* WINPR_RESTRICT roi)

{

  UINT32 dstPad = 0;

  UINT32 srcPad[3];

  BYTE Y = 0;

  BYTE U = 0;

  BYTE V = 0;

  UINT32 halfWidth = 0;

  UINT32 halfHeight = 0;

  const BYTE* pY = NULL;

  const BYTE* pU = NULL;

  const BYTE* pV = NULL;

  BYTE* pRGB = pDst;

  UINT32 nWidth = 0;

  UINT32 nHeight = 0;

  UINT32 lastRow = 0;

  UINT32 lastCol = 0;

  const DWORD formatSize = FreeRDPGetBytesPerPixel(DstFormat);

  fkt_writePixel writePixel = getPixelWriteFunction(DstFormat, FALSE);

  pY = pSrc[0];

  pU = pSrc[1];

  pV = pSrc[2];

  lastCol = roi->width & 0x01;

  lastRow = roi->height & 0x01;

  nWidth = (roi->width + 1) & ~0x0001;

  nHeight = (roi->height + 1) & ~0x0001;

  halfWidth = nWidth / 2;

  halfHeight = nHeight / 2;

  srcPad[0] = (srcStep[0] - nWidth);

  srcPad[1] = (srcStep[1] - halfWidth);

  srcPad[2] = (srcStep[2] - halfWidth);

  dstPad = (dstStep - (nWidth * 4));

  for (UINT32 y = 0; y < halfHeight;)

  {

    if (++y == halfHeight)

      lastRow <<= 1;

    for (UINT32 x = 0; x < halfWidth;)

    {

      BYTE r = 0;

      BYTE g = 0;

      BYTE b = 0;

      if (++x == halfWidth)

        lastCol <<= 1;

      U = *pU++;

      V = *pV++;

      /* 1st pixel */

      Y = *pY++;

      r = YUV2R(Y, U, V);

      g = YUV2G(Y, U, V);

      b = YUV2B(Y, U, V);

      pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);

      /* 2nd pixel */

      if (!(lastCol & 0x02))

      {

        Y = *pY++;

        r = YUV2R(Y, U, V);

        g = YUV2G(Y, U, V);

        b = YUV2B(Y, U, V);

        pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);

      }

      else

      {

        pY++;

        pRGB += formatSize;

        lastCol >>= 1;

      }

    }

    pY += srcPad[0];

    pU -= halfWidth;

    pV -= halfWidth;

    pRGB += dstPad;

    if (lastRow & 0x02)

      break;

    for (UINT32 x = 0; x < halfWidth;)

    {

      BYTE r = 0;

      BYTE g = 0;

      BYTE b = 0;

      if (++x == halfWidth)

        lastCol <<= 1;

      U = *pU++;

      V = *pV++;

      /* 3rd pixel */

      Y = *pY++;

      r = YUV2R(Y, U, V);

      g = YUV2G(Y, U, V);

      b = YUV2B(Y, U, V);

      pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);

      /* 4th pixel */

      if (!(lastCol & 0x02))

      {

        Y = *pY++;

        r = YUV2R(Y, U, V);

        g = YUV2G(Y, U, V);

        b = YUV2B(Y, U, V);

        pRGB = writePixel(pRGB, formatSize, DstFormat, r, g, b, 0);

      }

      else

      {

        pY++;

        pRGB += formatSize;

        lastCol >>= 1;

      }

    }

    pY += srcPad[0];

    pU += srcPad[1];

    pV += srcPad[2];

    pRGB += dstPad;

  }

  return PRIMITIVES_SUCCESS;

}

/**

 * | Y |    ( |  54   183     18 | | R | )        |  0  |

 * | U | =  ( | -29   -99    128 | | G | ) >> 8 + | 128 |

 * | V |    ( | 128  -116    -12 | | B | )        | 128 |

 */

static INLINE BYTE RGB2Y(BYTE R, BYTE G, BYTE B)

{

  return (54 * R + 183 * G + 18 * B) >> 8;

}

static INLINE BYTE RGB2U(BYTE R, BYTE G, BYTE B)

{

  return ((-29 * R - 99 * G + 128 * B) >> 8) + 128;

}

static INLINE BYTE RGB2V(INT32 R, INT32 G, INT32 B)

{

  return ((128 * R - 116 * G - 12 * B) >> 8) + 128;

}

static pstatus_t general_RGBToYUV444_8u_P3AC4R(const BYTE* WINPR_RESTRICT pSrc, UINT32 SrcFormat,

                                               const UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],

                                               UINT32 dstStep[3],

                                               const prim_size_t* WINPR_RESTRICT roi)

{

  const UINT32 bpp = FreeRDPGetBytesPerPixel(SrcFormat);

  UINT32 nWidth = 0;

  UINT32 nHeight = 0;

  nWidth = roi->width;

  nHeight = roi->height;

  for (size_t y = 0; y < nHeight; y++)

  {

    const BYTE* pRGB = pSrc + y * srcStep;

    BYTE* pY = pDst[0] + y * dstStep[0];

    BYTE* pU = pDst[1] + y * dstStep[1];

    BYTE* pV = pDst[2] + y * dstStep[2];

    for (size_t x = 0; x < nWidth; x++)

    {

      BYTE B = 0;

      BYTE G = 0;

      BYTE R = 0;

      const UINT32 color = FreeRDPReadColor(&pRGB[x * bpp], SrcFormat);

      FreeRDPSplitColor(color, SrcFormat, &R, &G, &B, NULL, NULL);

      pY[x] = RGB2Y(R, G, B);

      pU[x] = RGB2U(R, G, B);

      pV[x] = RGB2V(R, G, B);

    }

  }

  return PRIMITIVES_SUCCESS;

}

static INLINE pstatus_t general_RGBToYUV420_BGRX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,

                                                 BYTE* WINPR_RESTRICT pDst[3],

                                                 const UINT32 dstStep[3],

                                                 const prim_size_t* WINPR_RESTRICT roi)

{

  size_t i = 0;

  size_t x1 = 0;

  size_t x2 = 4;

  size_t x3 = srcStep;

  size_t x4 = srcStep + 4;

  size_t y1 = 0;

  size_t y2 = 1;

  size_t y3 = dstStep[0];

  size_t y4 = dstStep[0] + 1;

  UINT32 max_x = roi->width - 1;

  UINT32 max_y = roi->height - 1;

  for (size_t y = i = 0; y < roi->height; y += 2, i++)

  {

    const BYTE* src = pSrc + y * srcStep;

    BYTE* ydst = pDst[0] + y * dstStep[0];

    BYTE* udst = pDst[1] + i * dstStep[1];

    BYTE* vdst = pDst[2] + i * dstStep[2];

    for (size_t x = 0; x < roi->width; x += 2)

    {

      BYTE R = 0;

      BYTE G = 0;

      BYTE B = 0;

      INT32 Ra = 0;

      INT32 Ga = 0;

      INT32 Ba = 0;

      /* row 1, pixel 1 */

      Ba = B = *(src + x1 + 0);

      Ga = G = *(src + x1 + 1);

      Ra = R = *(src + x1 + 2);

      ydst[y1] = RGB2Y(R, G, B);

      if (x < max_x)

      {

        /* row 1, pixel 2 */

        Ba += B = *(src + x2 + 0);

        Ga += G = *(src + x2 + 1);

        Ra += R = *(src + x2 + 2);

        ydst[y2] = RGB2Y(R, G, B);

      }

      if (y < max_y)

      {

        /* row 2, pixel 1 */

        Ba += B = *(src + x3 + 0);

        Ga += G = *(src + x3 + 1);

        Ra += R = *(src + x3 + 2);

        ydst[y3] = RGB2Y(R, G, B);

        if (x < max_x)

        {

          /* row 2, pixel 2 */

          Ba += B = *(src + x4 + 0);

          Ga += G = *(src + x4 + 1);

          Ra += R = *(src + x4 + 2);

          ydst[y4] = RGB2Y(R, G, B);

        }

      }

      Ba >>= 2;

      Ga >>= 2;

      Ra >>= 2;

      *udst++ = RGB2U(Ra, Ga, Ba);

      *vdst++ = RGB2V(Ra, Ga, Ba);

      ydst += 2;

      src += 8;

    }

  }

  return PRIMITIVES_SUCCESS;

}

static INLINE pstatus_t general_RGBToYUV420_RGBX(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcStep,

                                                 BYTE* WINPR_RESTRICT pDst[3],

                                                 const UINT32 dstStep[3],

                                                 const prim_size_t* WINPR_RESTRICT roi)

{

  size_t x1 = 0;

  size_t x2 = 4;

  size_t x3 = srcStep;

  size_t x4 = srcStep + 4;

  size_t y1 = 0;

  size_t y2 = 1;

  size_t y3 = dstStep[0];

  size_t y4 = dstStep[0] + 1;

  UINT32 max_x = roi->width - 1;

  UINT32 max_y = roi->height - 1;

  for (size_t y = 0, i = 0; y < roi->height; y += 2, i++)

  {

    const BYTE* src = pSrc + y * srcStep;

    BYTE* ydst = pDst[0] + y * dstStep[0];

    BYTE* udst = pDst[1] + i * dstStep[1];

    BYTE* vdst = pDst[2] + i * dstStep[2];

    for (UINT32 x = 0; x < roi->width; x += 2)

    {

      BYTE R = 0;

      BYTE G = 0;

      BYTE B = 0;

      INT32 Ra = 0;

      INT32 Ga = 0;

      INT32 Ba = 0;

      /* row 1, pixel 1 */

      Ra = R = *(src + x1 + 0);

      Ga = G = *(src + x1 + 1);

      Ba = B = *(src + x1 + 2);

      ydst[y1] = RGB2Y(R, G, B);

      if (x < max_x)

      {

        /* row 1, pixel 2 */

        Ra += R = *(src + x2 + 0);

        Ga += G = *(src + x2 + 1);

        Ba += B = *(src + x2 + 2);

        ydst[y2] = RGB2Y(R, G, B);

      }

      if (y < max_y)

      {

        /* row 2, pixel 1 */

        Ra += R = *(src + x3 + 0);

        Ga += G = *(src + x3 + 1);

        Ba += B = *(src + x3 + 2);

        ydst[y3] = RGB2Y(R, G, B);

        if (x < max_x)

        {

          /* row 2, pixel 2 */

          Ra += R = *(src + x4 + 0);

          Ga += G = *(src + x4 + 1);

          Ba += B = *(src + x4 + 2);

          ydst[y4] = RGB2Y(R, G, B);

        }

      }

      Ba >>= 2;

      Ga >>= 2;

      Ra >>= 2;

      *udst++ = RGB2U(Ra, Ga, Ba);

      *vdst++ = RGB2V(Ra, Ga, Ba);

      ydst += 2;

      src += 8;

    }

  }

  return PRIMITIVES_SUCCESS;

}

static INLINE pstatus_t general_RGBToYUV420_ANY(const BYTE* WINPR_RESTRICT pSrc, UINT32 srcFormat,

                                                UINT32 srcStep, BYTE* WINPR_RESTRICT pDst[3],

                                                const UINT32 dstStep[3],

                                                const prim_size_t* WINPR_RESTRICT roi)

{

  const UINT32 bpp = FreeRDPGetBytesPerPixel(srcFormat);

  size_t x1 = 0;

  size_t x2 = bpp;

  size_t x3 = srcStep;

  size_t x4 = srcStep + bpp;

  size_t y1 = 0;

  size_t y2 = 1;

  size_t y3 = dstStep[0];

  size_t y4 = dstStep[0] + 1;

  UINT32 max_x = roi->width - 1;

  UINT32 max_y = roi->height - 1;

  for (size_t y = 0, i = 0; y < roi->height; y += 2, i++)

  {

    const BYTE* src = pSrc + y * srcStep;

    BYTE* ydst = pDst[0] + y * dstStep[0];

    BYTE* udst = pDst[1] + i * dstStep[1];

    BYTE* vdst = pDst[2] + i * dstStep[2];

    for (size_t x = 0; x < roi->width; x += 2)

    {

      BYTE R = 0;

      BYTE G = 0;

      BYTE B = 0;

      INT32 Ra = 0;

      INT32 Ga = 0;

      INT32 Ba = 0;

      UINT32 color = 0;

      /* row 1, pixel 1 */

      color = FreeRDPReadColor(src + x1, srcFormat);

      FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);

      Ra = R;

      Ga = G;

      Ba = B;

      ydst[y1] = RGB2Y(R, G, B);

      if (x < max_x)

      {

        /* row 1, pixel 2 */

        color = FreeRDPReadColor(src + x2, srcFormat);

        FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);

        Ra += R;

        Ga += G;

        Ba += B;

        ydst[y2] = RGB2Y(R, G, B);

      }

      if (y < max_y)

      {

        /* row 2, pixel 1 */

        color = FreeRDPReadColor(src + x3, srcFormat);

        FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);

        Ra += R;

        Ga += G;

        Ba += B;

        ydst[y3] = RGB2Y(R, G, B);

        if (x < max_x)

        {

          /* row 2, pixel 2 */

          color = FreeRDPReadColor(src + x4, srcFormat);

          FreeRDPSplitColor(color, srcFormat, &R, &G, &B, NULL, NULL);

          Ra += R;

          Ga += G;

          Ba += B;

          ydst[y4] = RGB2Y(R, G, B);

        }

      }

      Ra >>= 2;