/*!

 * \copy

 *     Copyright (c)  2013, Cisco Systems

 *     All rights reserved.

 *

 *     Redistribution and use in source and binary forms, with or without

 *     modification, are permitted provided that the following conditions

 *     are met:

 *

 *        * Redistributions of source code must retain the above copyright

 *          notice, this list of conditions and the following disclaimer.

 *

 *        * Redistributions in binary form must reproduce the above copyright

 *          notice, this list of conditions and the following disclaimer in

 *          the documentation and/or other materials provided with the

 *          distribution.

 *

 *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

 *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

 *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 *     POSSIBILITY OF SUCH DAMAGE.

 *

 */

#include "downsample.h"

#include "cpu.h"

#include <assert.h>

WELSVP_NAMESPACE_BEGIN

#define MAX_SAMPLE_WIDTH 1920

#define MAX_SAMPLE_HEIGHT 1088

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

CDownsampling::CDownsampling (int32_t iCpuFlag) {

  m_iCPUFlag = iCpuFlag;

  m_eMethod   = METHOD_DOWNSAMPLE;

  WelsMemset (&m_pfDownsample, 0, sizeof (m_pfDownsample));

  InitDownsampleFuncs (m_pfDownsample, m_iCPUFlag);

  WelsMemset(m_pSampleBuffer,0,sizeof(m_pSampleBuffer));

  m_bNoSampleBuffer = AllocateSampleBuffer();

}

CDownsampling::~CDownsampling() {

  FreeSampleBuffer();

}

bool CDownsampling::AllocateSampleBuffer() {

  for (int32_t i = 0; i < 2; i++) {

    m_pSampleBuffer[i][0] = (uint8_t*)WelsMalloc (MAX_SAMPLE_WIDTH * MAX_SAMPLE_HEIGHT);

    if (!m_pSampleBuffer[i][0])

      goto FREE_RET;

    m_pSampleBuffer[i][1] = (uint8_t*)WelsMalloc (MAX_SAMPLE_WIDTH * MAX_SAMPLE_HEIGHT / 4);

    if (!m_pSampleBuffer[i][1])

      goto FREE_RET;

    m_pSampleBuffer[i][2] = (uint8_t*)WelsMalloc (MAX_SAMPLE_WIDTH * MAX_SAMPLE_HEIGHT / 4);

    if (!m_pSampleBuffer[i][2])

      goto FREE_RET;

  }

  return false;

FREE_RET:

  FreeSampleBuffer();

  return true;

}

void CDownsampling::FreeSampleBuffer() {

  for (int32_t i = 0; i < 2; i++) {

    WelsFree (m_pSampleBuffer[i][0]);

    m_pSampleBuffer[i][0] = NULL;

    WelsFree (m_pSampleBuffer[i][1]);

    m_pSampleBuffer[i][1] = NULL;

    WelsFree (m_pSampleBuffer[i][2]);

    m_pSampleBuffer[i][2] = NULL;

  }

}

void CDownsampling::InitDownsampleFuncs (SDownsampleFuncs& sDownsampleFunc,  int32_t iCpuFlag) {

  sDownsampleFunc.pfHalfAverageWidthx32 = DyadicBilinearDownsampler_c;

  sDownsampleFunc.pfHalfAverageWidthx16 = DyadicBilinearDownsampler_c;

  sDownsampleFunc.pfOneThirdDownsampler = DyadicBilinearOneThirdDownsampler_c;

  sDownsampleFunc.pfQuarterDownsampler  = DyadicBilinearQuarterDownsampler_c;

  sDownsampleFunc.pfGeneralRatioChroma  = GeneralBilinearAccurateDownsampler_c;

  sDownsampleFunc.pfGeneralRatioLuma    = GeneralBilinearFastDownsampler_c;

#if defined(X86_ASM)

  if (iCpuFlag & WELS_CPU_SSE) {

    sDownsampleFunc.pfHalfAverageWidthx32 = DyadicBilinearDownsamplerWidthx32_sse;

    sDownsampleFunc.pfHalfAverageWidthx16 = DyadicBilinearDownsamplerWidthx16_sse;

    sDownsampleFunc.pfQuarterDownsampler = DyadicBilinearQuarterDownsampler_sse;

  }

  if (iCpuFlag & WELS_CPU_SSE2) {

    sDownsampleFunc.pfGeneralRatioChroma = GeneralBilinearAccurateDownsamplerWrap_sse2;

    sDownsampleFunc.pfGeneralRatioLuma   = GeneralBilinearFastDownsamplerWrap_sse2;

  }

  if (iCpuFlag & WELS_CPU_SSSE3) {

    sDownsampleFunc.pfHalfAverageWidthx32 = DyadicBilinearDownsamplerWidthx32_ssse3;

    sDownsampleFunc.pfHalfAverageWidthx16 = DyadicBilinearDownsamplerWidthx16_ssse3;

    sDownsampleFunc.pfOneThirdDownsampler = DyadicBilinearOneThirdDownsampler_ssse3;

    sDownsampleFunc.pfQuarterDownsampler  = DyadicBilinearQuarterDownsampler_ssse3;

    sDownsampleFunc.pfGeneralRatioLuma    = GeneralBilinearFastDownsamplerWrap_ssse3;

  }

  if (iCpuFlag & WELS_CPU_SSE41) {

    sDownsampleFunc.pfOneThirdDownsampler = DyadicBilinearOneThirdDownsampler_sse4;

    sDownsampleFunc.pfQuarterDownsampler  = DyadicBilinearQuarterDownsampler_sse4;

    sDownsampleFunc.pfGeneralRatioChroma  = GeneralBilinearAccurateDownsamplerWrap_sse41;

  }

#ifdef HAVE_AVX2

  if (iCpuFlag & WELS_CPU_AVX2) {

    sDownsampleFunc.pfGeneralRatioChroma = GeneralBilinearAccurateDownsamplerWrap_avx2;

    sDownsampleFunc.pfGeneralRatioLuma   = GeneralBilinearFastDownsamplerWrap_avx2;

  }

#endif

#endif//X86_ASM

#if defined(HAVE_NEON)

  if (iCpuFlag & WELS_CPU_NEON) {

    sDownsampleFunc.pfHalfAverageWidthx32 = DyadicBilinearDownsamplerWidthx32_neon;

    sDownsampleFunc.pfHalfAverageWidthx16 = DyadicBilinearDownsampler_neon;

    sDownsampleFunc.pfOneThirdDownsampler = DyadicBilinearOneThirdDownsampler_neon;

    sDownsampleFunc.pfQuarterDownsampler  = DyadicBilinearQuarterDownsampler_neon;

    sDownsampleFunc.pfGeneralRatioChroma = GeneralBilinearAccurateDownsamplerWrap_neon;

    sDownsampleFunc.pfGeneralRatioLuma   = GeneralBilinearAccurateDownsamplerWrap_neon;

  }

#endif

#if defined(HAVE_NEON_AARCH64) && defined(__aarch64__)

  if (iCpuFlag & WELS_CPU_NEON) {

    sDownsampleFunc.pfHalfAverageWidthx32 = DyadicBilinearDownsamplerWidthx32_AArch64_neon;

    sDownsampleFunc.pfHalfAverageWidthx16 = DyadicBilinearDownsampler_AArch64_neon;

    sDownsampleFunc.pfOneThirdDownsampler = DyadicBilinearOneThirdDownsampler_AArch64_neon;

    sDownsampleFunc.pfQuarterDownsampler  = DyadicBilinearQuarterDownsampler_AArch64_neon;

    sDownsampleFunc.pfGeneralRatioChroma = GeneralBilinearAccurateDownsamplerWrap_AArch64_neon;

    sDownsampleFunc.pfGeneralRatioLuma   = GeneralBilinearAccurateDownsamplerWrap_AArch64_neon;

  }

#endif

}

EResult CDownsampling::Process (int32_t iType, SPixMap* pSrcPixMap, SPixMap* pDstPixMap) {

  int32_t iSrcWidthY = pSrcPixMap->sRect.iRectWidth;

  int32_t iSrcHeightY = pSrcPixMap->sRect.iRectHeight;

  int32_t iDstWidthY = pDstPixMap->sRect.iRectWidth;

  int32_t iDstHeightY = pDstPixMap->sRect.iRectHeight;

  int32_t iSrcWidthUV = iSrcWidthY >> 1;

  int32_t iSrcHeightUV = iSrcHeightY >> 1;

  int32_t iDstWidthUV = iDstWidthY >> 1;

  int32_t iDstHeightUV = iDstHeightY >> 1;

  if (iSrcWidthY <= iDstWidthY || iSrcHeightY <= iDstHeightY) {

    return RET_INVALIDPARAM;

  }

  if ((iSrcWidthY >> 1) > MAX_SAMPLE_WIDTH || (iSrcHeightY >> 1) > MAX_SAMPLE_HEIGHT || m_bNoSampleBuffer) {

    if ((iSrcWidthY >> 1) == iDstWidthY && (iSrcHeightY >> 1) == iDstHeightY) {

      // use half average functions

      DownsampleHalfAverage ((uint8_t*)pDstPixMap->pPixel[0], pDstPixMap->iStride[0],

          (uint8_t*)pSrcPixMap->pPixel[0], pSrcPixMap->iStride[0], iSrcWidthY, iSrcHeightY);

      DownsampleHalfAverage ((uint8_t*)pDstPixMap->pPixel[1], pDstPixMap->iStride[1],

          (uint8_t*)pSrcPixMap->pPixel[1], pSrcPixMap->iStride[1], iSrcWidthUV, iSrcHeightUV);

      DownsampleHalfAverage ((uint8_t*)pDstPixMap->pPixel[2], pDstPixMap->iStride[2],

          (uint8_t*)pSrcPixMap->pPixel[2], pSrcPixMap->iStride[2], iSrcWidthUV, iSrcHeightUV);

    } else if ((iSrcWidthY >> 2) == iDstWidthY && (iSrcHeightY >> 2) == iDstHeightY) {

      m_pfDownsample.pfQuarterDownsampler ((uint8_t*)pDstPixMap->pPixel[0], pDstPixMap->iStride[0],

                                           (uint8_t*)pSrcPixMap->pPixel[0], pSrcPixMap->iStride[0], iSrcWidthY, iSrcHeightY);

      m_pfDownsample.pfQuarterDownsampler ((uint8_t*)pDstPixMap->pPixel[1], pDstPixMap->iStride[1],

                                           (uint8_t*)pSrcPixMap->pPixel[1], pSrcPixMap->iStride[1], iSrcWidthUV, iSrcHeightUV);

      m_pfDownsample.pfQuarterDownsampler ((uint8_t*)pDstPixMap->pPixel[2], pDstPixMap->iStride[2],

                                           (uint8_t*)pSrcPixMap->pPixel[2], pSrcPixMap->iStride[2], iSrcWidthUV, iSrcHeightUV);

    } else if ((iSrcWidthY / 3) == iDstWidthY && (iSrcHeightY / 3) == iDstHeightY) {

      m_pfDownsample.pfOneThirdDownsampler ((uint8_t*)pDstPixMap->pPixel[0], pDstPixMap->iStride[0],

                                            (uint8_t*)pSrcPixMap->pPixel[0], pSrcPixMap->iStride[0], iSrcWidthY, iDstHeightY);

      m_pfDownsample.pfOneThirdDownsampler ((uint8_t*)pDstPixMap->pPixel[1], pDstPixMap->iStride[1],

                                            (uint8_t*)pSrcPixMap->pPixel[1], pSrcPixMap->iStride[1], iSrcWidthUV, iDstHeightUV);

      m_pfDownsample.pfOneThirdDownsampler ((uint8_t*)pDstPixMap->pPixel[2], pDstPixMap->iStride[2],

                                            (uint8_t*)pSrcPixMap->pPixel[2], pSrcPixMap->iStride[2], iSrcWidthUV, iDstHeightUV);

    } else {

      m_pfDownsample.pfGeneralRatioLuma ((uint8_t*)pDstPixMap->pPixel[0], pDstPixMap->iStride[0], iDstWidthY, iDstHeightY,

                                         (uint8_t*)pSrcPixMap->pPixel[0], pSrcPixMap->iStride[0], iSrcWidthY, iSrcHeightY);

      m_pfDownsample.pfGeneralRatioChroma ((uint8_t*)pDstPixMap->pPixel[1], pDstPixMap->iStride[1], iDstWidthUV, iDstHeightUV,

                                           (uint8_t*)pSrcPixMap->pPixel[1], pSrcPixMap->iStride[1], iSrcWidthUV, iSrcHeightUV);

      m_pfDownsample.pfGeneralRatioChroma ((uint8_t*)pDstPixMap->pPixel[2], pDstPixMap->iStride[2], iDstWidthUV, iDstHeightUV,

                                           (uint8_t*)pSrcPixMap->pPixel[2], pSrcPixMap->iStride[2], iSrcWidthUV, iSrcHeightUV);

    }

  } else {

    int32_t iIdx = 0;

    int32_t iHalfSrcWidth = iSrcWidthY >> 1;

    int32_t iHalfSrcHeight = iSrcHeightY >> 1;

    uint8_t* pSrcY = (uint8_t*)pSrcPixMap->pPixel[0];

    uint8_t* pSrcU = (uint8_t*)pSrcPixMap->pPixel[1];

    uint8_t* pSrcV = (uint8_t*)pSrcPixMap->pPixel[2];

    int32_t iSrcStrideY = pSrcPixMap->iStride[0];

    int32_t iSrcStrideU = pSrcPixMap->iStride[1];

    int32_t iSrcStrideV = pSrcPixMap->iStride[2];

    int32_t iDstStrideY = pDstPixMap->iStride[0];

    int32_t iDstStrideU = pDstPixMap->iStride[1];

    int32_t iDstStrideV = pDstPixMap->iStride[2];

    uint8_t* pDstY = (uint8_t*)m_pSampleBuffer[iIdx][0];

    uint8_t* pDstU = (uint8_t*)m_pSampleBuffer[iIdx][1];

    uint8_t* pDstV = (uint8_t*)m_pSampleBuffer[iIdx][2];

    iIdx++;

    do {

      if ((iHalfSrcWidth == iDstWidthY) && (iHalfSrcHeight == iDstHeightY)) { //end

        // use half average functions

        DownsampleHalfAverage ((uint8_t*)pDstPixMap->pPixel[0], pDstPixMap->iStride[0],

            (uint8_t*)pSrcY, iSrcStrideY, iSrcWidthY, iSrcHeightY);

        DownsampleHalfAverage ((uint8_t*)pDstPixMap->pPixel[1], pDstPixMap->iStride[1],

            (uint8_t*)pSrcU, iSrcStrideU, iSrcWidthUV, iSrcHeightUV);

        DownsampleHalfAverage ((uint8_t*)pDstPixMap->pPixel[2], pDstPixMap->iStride[2],

            (uint8_t*)pSrcV, iSrcStrideV, iSrcWidthUV, iSrcHeightUV);

        break;

      } else if ((iHalfSrcWidth > iDstWidthY) && (iHalfSrcHeight > iDstHeightY)){

        // use half average functions

        iDstStrideY = WELS_ALIGN (iHalfSrcWidth, 32);

        iDstStrideU = WELS_ALIGN (iHalfSrcWidth >> 1, 32);

        iDstStrideV = WELS_ALIGN (iHalfSrcWidth >> 1, 32);

        DownsampleHalfAverage ((uint8_t*)pDstY, iDstStrideY,

            (uint8_t*)pSrcY, iSrcStrideY, iSrcWidthY, iSrcHeightY);

        DownsampleHalfAverage ((uint8_t*)pDstU, iDstStrideU,

            (uint8_t*)pSrcU, iSrcStrideU, iSrcWidthUV, iSrcHeightUV);

        DownsampleHalfAverage ((uint8_t*)pDstV, iDstStrideV,

            (uint8_t*)pSrcV, iSrcStrideV, iSrcWidthUV, iSrcHeightUV);

        pSrcY = (uint8_t*)pDstY;

        pSrcU = (uint8_t*)pDstU;

        pSrcV = (uint8_t*)pDstV;

        iSrcWidthY = iHalfSrcWidth;

        iSrcWidthUV = iHalfSrcWidth >> 1;

        iSrcHeightY = iHalfSrcHeight;

        iSrcHeightUV = iHalfSrcHeight >> 1;

        iSrcStrideY = iDstStrideY;

        iSrcStrideU = iDstStrideU;

        iSrcStrideV = iDstStrideV;

        iHalfSrcWidth >>= 1;

        iHalfSrcHeight >>= 1;

        iIdx = iIdx % 2;

        pDstY = (uint8_t*)m_pSampleBuffer[iIdx][0];

        pDstU = (uint8_t*)m_pSampleBuffer[iIdx][1];

        pDstV = (uint8_t*)m_pSampleBuffer[iIdx][2];

        iIdx++;

      } else {

        m_pfDownsample.pfGeneralRatioLuma ((uint8_t*)pDstPixMap->pPixel[0], pDstPixMap->iStride[0], iDstWidthY, iDstHeightY,

                                           (uint8_t*)pSrcY, iSrcStrideY, iSrcWidthY, iSrcHeightY);

        m_pfDownsample.pfGeneralRatioChroma ((uint8_t*)pDstPixMap->pPixel[1], pDstPixMap->iStride[1], iDstWidthUV, iDstHeightUV,

                                             (uint8_t*)pSrcU, iSrcStrideU,  iSrcWidthUV, iSrcHeightUV);

        m_pfDownsample.pfGeneralRatioChroma ((uint8_t*)pDstPixMap->pPixel[2], pDstPixMap->iStride[2], iDstWidthUV, iDstHeightUV,

                                             (uint8_t*)pSrcV, iSrcStrideV, iSrcWidthUV, iSrcHeightUV);

        break;

      }

    } while (true);

  }

  return RET_SUCCESS;

}

void CDownsampling::DownsampleHalfAverage (uint8_t* pDst, int32_t iDstStride,

        uint8_t* pSrc, int32_t iSrcStride, int32_t iSrcWidth, int32_t iSrcHeight) {

  if ((iSrcStride & 31) == 0) {

    assert ((iDstStride & 15) == 0);

    m_pfDownsample.pfHalfAverageWidthx32 (pDst, iDstStride,

        pSrc, iSrcStride, WELS_ALIGN (iSrcWidth & ~1, 32), iSrcHeight);

  } else {

    assert ((iSrcStride & 15) == 0);

    assert ((iDstStride &  7) == 0);

    m_pfDownsample.pfHalfAverageWidthx16 (pDst, iDstStride,

        pSrc, iSrcStride, WELS_ALIGN (iSrcWidth & ~1, 16), iSrcHeight);

  }

}

WELSVP_NAMESPACE_END