/*!
 * \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 "wels_preprocess.h"
#include "picture_handle.h"
#include "encoder_context.h"
#include "utils.h"
#include "encoder.h"

namespace {

void ClearEndOfLinePadding (uint8_t* pData, int32_t iStride, int32_t iWidth, int32_t iHeight) {
  if (iWidth < iStride) {
    for (int32_t i = 0; i < iHeight; ++i)
      memset (pData + i * iStride + iWidth, 0, iStride - iWidth);
  }
}

} // anon ns.

namespace WelsEnc {



//***** entry API declaration ************************************************************************//

int32_t WelsInitScaledPic (SWelsSvcCodingParam* pParam,  Scaled_Picture*  pScaledPic, CMemoryAlign* pMemoryAlign);
bool  JudgeNeedOfScaling (SWelsSvcCodingParam* pParam, Scaled_Picture* pScaledPic);
void    FreeScaledPic (Scaled_Picture*  pScaledPic, CMemoryAlign* pMemoryAlign);
void  WelsMoveMemory_c (uint8_t* pDstY, uint8_t* pDstU, uint8_t* pDstV,  int32_t iDstStrideY, int32_t iDstStrideUV,
                        uint8_t* pSrcY, uint8_t* pSrcU, uint8_t* pSrcV, int32_t iSrcStrideY, int32_t iSrcStrideUV, int32_t iWidth,
                        int32_t iHeight);

//******* table definition ***********************************************************************//
const uint8_t g_kuiRefTemporalIdx[MAX_TEMPORAL_LEVEL][MAX_GOP_SIZE] = {
  {  0, }, // 0
  {  0,  0, }, // 1
  {  0,  0,  0,  1, }, // 2
  {  0,  0,  0,  2,  0,  1,  1,  2, }, // 3
};

const int32_t g_kiPixMapSizeInBits = sizeof (uint8_t) * 8;


inline  void   WelsUpdateSpatialIdxMap (sWelsEncCtx* pEncCtx, const int32_t iPos, SPicture* const pPic,
                                        const int32_t iDidx) {
  pEncCtx->sSpatialIndexMap[iPos].pSrc = pPic;
  pEncCtx->sSpatialIndexMap[iPos].iDid = iDidx;
}


/***************************************************************************
*
*   implement of the interface
*
***************************************************************************/



CWelsPreProcess* CWelsPreProcess::CreatePreProcess (sWelsEncCtx* pEncCtx) {

  CWelsPreProcess* pPreProcess = NULL;
  switch (pEncCtx->pSvcParam->iUsageType) {
  case SCREEN_CONTENT_REAL_TIME:
    pPreProcess = WELS_NEW_OP (CWelsPreProcessScreen (pEncCtx),
                               CWelsPreProcessScreen);
    break;
  default:
    pPreProcess = WELS_NEW_OP (CWelsPreProcessVideo (pEncCtx),
                               CWelsPreProcessVideo);
    break;

  }
  WELS_VERIFY_RETURN_IF (NULL, NULL == pPreProcess)
  return pPreProcess;
}


CWelsPreProcess::CWelsPreProcess (sWelsEncCtx* pEncCtx) {
  m_pInterfaceVp = NULL;
  m_bInitDone = false;
  m_pEncCtx = pEncCtx;
  memset (&m_sScaledPicture, 0, sizeof (m_sScaledPicture));
  memset (m_pSpatialPic, 0, sizeof (m_pSpatialPic));
  memset (m_uiSpatialLayersInTemporal, 0, sizeof (m_uiSpatialLayersInTemporal));
  memset (m_uiSpatialPicNum, 0, sizeof (m_uiSpatialPicNum));
}

CWelsPreProcess::~CWelsPreProcess() {
  FreeScaledPic (&m_sScaledPicture,  m_pEncCtx->pMemAlign);
  WelsPreprocessDestroy();
}

int32_t CWelsPreProcess::WelsPreprocessCreate() {
  if (m_pInterfaceVp == NULL) {
    WelsCreateVpInterface ((void**) &m_pInterfaceVp, WELSVP_INTERFACE_VERION);
    if (!m_pInterfaceVp)
      goto exit;
  } else
    goto exit;

  return 0;

exit:
  WelsPreprocessDestroy();
  return 1;
}

int32_t CWelsPreProcess::WelsPreprocessDestroy() {
  WelsDestroyVpInterface (m_pInterfaceVp, WELSVP_INTERFACE_VERION);
  m_pInterfaceVp = NULL;

  return 0;
}

int32_t CWelsPreProcess::WelsPreprocessReset (sWelsEncCtx* pCtx, int32_t iWidth, int32_t iHeight) {
  int32_t iRet = -1;
  SWelsSvcCodingParam* pSvcParam = pCtx->pSvcParam;
  //init source width and height
  pSvcParam->SUsedPicRect.iLeft = 0;
  pSvcParam->SUsedPicRect.iTop  = 0;
  pSvcParam->SUsedPicRect.iWidth =  iWidth;
  pSvcParam->SUsedPicRect.iHeight = iHeight;
  if ((iWidth < 16) || ((iHeight < 16))) {
    WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "Don't support width(%d) or height(%d) which is less than 16 ", iWidth,
             iHeight);
    return iRet;
  }
  if (pCtx) {
    FreeScaledPic (&m_sScaledPicture, pCtx->pMemAlign);
    iRet = InitLastSpatialPictures (pCtx);
    iRet = WelsInitScaledPic (pCtx->pSvcParam, &m_sScaledPicture, pCtx->pMemAlign);
  }

  return iRet;
}

int32_t CWelsPreProcess::AllocSpatialPictures (sWelsEncCtx* pCtx, SWelsSvcCodingParam* pParam) {
  CMemoryAlign* pMa             = pCtx->pMemAlign;
  const int32_t kiDlayerCount   = pParam->iSpatialLayerNum;
  int32_t iDlayerIndex          = 0;

  // spatial pictures
  iDlayerIndex = 0;
  do {
    const int32_t kiPicWidth = pParam->sSpatialLayers[iDlayerIndex].iVideoWidth;
    const int32_t kiPicHeight   = pParam->sSpatialLayers[iDlayerIndex].iVideoHeight;
    const uint8_t kuiLayerInTemporal = 2 + WELS_MAX (pParam->sDependencyLayers[iDlayerIndex].iHighestTemporalId, 1);
    const uint8_t kuiRefNumInTemporal = kuiLayerInTemporal + pParam->iLTRRefNum;
    uint8_t i = 0;

    m_uiSpatialPicNum[iDlayerIndex] = kuiRefNumInTemporal;
    do {
      SPicture* pPic = AllocPicture (pMa, kiPicWidth, kiPicHeight, false, 0);
      WELS_VERIFY_RETURN_IF (1, (NULL == pPic))
      m_pSpatialPic[iDlayerIndex][i] = pPic;
      ++ i;
    } while (i < kuiRefNumInTemporal);

    if (pParam->iUsageType == SCREEN_CONTENT_REAL_TIME)
      m_uiSpatialLayersInTemporal[iDlayerIndex] = 1;
    else
      m_uiSpatialLayersInTemporal[iDlayerIndex] = kuiLayerInTemporal;

    ++ iDlayerIndex;
  } while (iDlayerIndex < kiDlayerCount);

  return 0;
}

void CWelsPreProcess::FreeSpatialPictures (sWelsEncCtx* pCtx) {
  CMemoryAlign* pMa = pCtx->pMemAlign;
  int32_t j = 0;
  while (j < pCtx->pSvcParam->iSpatialLayerNum) {
    uint8_t i = 0;
    uint8_t uiRefNumInTemporal = m_uiSpatialPicNum[j];

    while (i < uiRefNumInTemporal) {
      if (NULL != m_pSpatialPic[j][i]) {
        FreePicture (pMa, &m_pSpatialPic[j][i]);
      }
      ++ i;
    }
    m_uiSpatialLayersInTemporal[j] = 0;
    ++ j;
  }
}

int32_t CWelsPreProcess::BuildSpatialPicList (sWelsEncCtx* pCtx, const SSourcePicture* kpSrcPic) {
  SWelsSvcCodingParam* pSvcParam = pCtx->pSvcParam;
  int32_t iSpatialNum = 0;
  int32_t iWidth = ((kpSrcPic->iPicWidth >> 1) << 1);
  int32_t iHeight = ((kpSrcPic->iPicHeight >> 1) << 1);

  if (!m_bInitDone) {
    if (WelsPreprocessCreate() != 0)
      return -1;

    if (WelsPreprocessReset (pCtx, iWidth, iHeight) != 0)
      return -1;

    m_iAvaliableRefInSpatialPicList = pSvcParam->iNumRefFrame;

    m_bInitDone = true;
  } else {
    if ((iWidth != pSvcParam->SUsedPicRect.iWidth) || (iHeight != pSvcParam->SUsedPicRect.iHeight)) {
      if (WelsPreprocessReset (pCtx, iWidth, iHeight) != 0)
        return -1;
    }
  }

  if (m_pInterfaceVp == NULL)
    return -1;

  pCtx->pVaa->bSceneChangeFlag = pCtx->pVaa->bIdrPeriodFlag = false;

  iSpatialNum = SingleLayerPreprocess (pCtx, kpSrcPic, &m_sScaledPicture);

  return iSpatialNum;
}

SPicture* CWelsPreProcess::GetBestRefPic (EUsageType iUsageType, bool bSceneLtr, EWelsSliceType eSliceType,
    int32_t kiDidx, int32_t iRefTemporalIdx) {
  assert (iUsageType == SCREEN_CONTENT_REAL_TIME);
  SVAAFrameInfoExt* pVaaExt = static_cast<SVAAFrameInfoExt*> (m_pEncCtx->pVaa);
  SRefInfoParam* BestRefCandidateParam = (bSceneLtr) ? (& (pVaaExt->sVaaLtrBestRefCandidate[0])) :
                                         (& (pVaaExt->sVaaStrBestRefCandidate[0]));
  return m_pSpatialPic[0][BestRefCandidateParam->iSrcListIdx];

}
SPicture* CWelsPreProcess::GetBestRefPic (const int32_t kiDidx, const int32_t iRefTemporalIdx) {

  return m_pSpatialPic[kiDidx][iRefTemporalIdx];
}

int32_t CWelsPreProcess::AnalyzeSpatialPic (sWelsEncCtx* pCtx, const int32_t kiDidx) {
  SWelsSvcCodingParam* pSvcParam = pCtx->pSvcParam;
  bool bNeededMbAq = (pSvcParam->bEnableAdaptiveQuant && (pCtx->eSliceType == P_SLICE));
  bool bCalculateBGD = (pCtx->eSliceType == P_SLICE && pSvcParam->bEnableBackgroundDetection);
  SSpatialLayerInternal* pParamInternal = &pSvcParam->sDependencyLayers[kiDidx];
  int32_t iCurTemporalIdx  = m_uiSpatialLayersInTemporal[kiDidx] - 1;

  int32_t iRefTemporalIdx = (int32_t)g_kuiRefTemporalIdx[pSvcParam->iDecompStages][pParamInternal->iCodingIndex &
                            (pSvcParam->uiGopSize - 1)];
  if (pCtx->uiTemporalId == 0 && pCtx->pLtr[pCtx->uiDependencyId].bReceivedT0LostFlag)
    iRefTemporalIdx = m_uiSpatialLayersInTemporal[kiDidx] + pCtx->pVaa->uiValidLongTermPicIdx;

  SPicture* pCurPic = m_pSpatialPic[kiDidx][iCurTemporalIdx];
  bool bCalculateVar = (pSvcParam->iRCMode >= RC_BITRATE_MODE && pCtx->eSliceType == I_SLICE);

  if (pSvcParam->iUsageType == SCREEN_CONTENT_REAL_TIME) {
    SPicture* pRefPic = GetBestRefPic (pSvcParam->iUsageType, pCtx->bCurFrameMarkedAsSceneLtr, pCtx->eSliceType, kiDidx,
                                       iRefTemporalIdx);

    VaaCalculation (pCtx->pVaa, pCurPic, pRefPic, false, bCalculateVar, bCalculateBGD);

    if (pSvcParam->bEnableBackgroundDetection) {
      BackgroundDetection (pCtx->pVaa, pCurPic, pRefPic, bCalculateBGD && pRefPic->iPictureType != I_SLICE);
    }
    if (bNeededMbAq) {
      AdaptiveQuantCalculation (pCtx->pVaa, pCurPic, pRefPic);
    }
  } else {
    SPicture* pRefPic = GetBestRefPic (kiDidx, iRefTemporalIdx);
    SPicture* pLastPic = m_pLastSpatialPicture[kiDidx][0];
    bool bCalculateSQDiff = ((pLastPic->pData[0] == pRefPic->pData[0]) && bNeededMbAq);

    VaaCalculation (pCtx->pVaa, pCurPic, pRefPic, bCalculateSQDiff, bCalculateVar, bCalculateBGD);

    if (pSvcParam->bEnableBackgroundDetection) {
      BackgroundDetection (pCtx->pVaa, pCurPic, pRefPic, bCalculateBGD && pRefPic->iPictureType != I_SLICE);
    }

    if (bNeededMbAq) {
      AdaptiveQuantCalculation (pCtx->pVaa, m_pLastSpatialPicture[kiDidx][1], m_pLastSpatialPicture[kiDidx][0]);
    }
  }
  return 0;
}

int32_t CWelsPreProcess::GetCurPicPosition (const int32_t kiDidx) {
  return (m_uiSpatialLayersInTemporal[kiDidx] - 1);
}

int32_t CWelsPreProcess::UpdateSpatialPictures (sWelsEncCtx* pCtx, SWelsSvcCodingParam* pParam,
    const int8_t iCurTid, const int32_t kiDidx) {
  if (pCtx->pSvcParam->iUsageType == SCREEN_CONTENT_REAL_TIME)
    return 0;

  WelsExchangeSpatialPictures (&m_pLastSpatialPicture[kiDidx][1], &m_pLastSpatialPicture[kiDidx][0]);

  const int32_t kiCurPos = GetCurPicPosition (kiDidx);
  if (iCurTid < kiCurPos || pParam->iDecompStages == 0) {
    if ((iCurTid >= MAX_TEMPORAL_LEVEL) || (kiCurPos > MAX_TEMPORAL_LEVEL)) {
      InitLastSpatialPictures (pCtx);
      return 1;
    }
    if (pCtx->bRefOfCurTidIsLtr[kiDidx][iCurTid]) {
      const int32_t kiAvailableLtrPos = m_uiSpatialLayersInTemporal[kiDidx] + pCtx->pVaa->uiMarkLongTermPicIdx;
      WelsExchangeSpatialPictures (&m_pSpatialPic[kiDidx][kiAvailableLtrPos],
                                   &m_pSpatialPic[kiDidx][iCurTid]);
      pCtx->bRefOfCurTidIsLtr[kiDidx][iCurTid] = false;
    }
    WelsExchangeSpatialPictures (&m_pSpatialPic[kiDidx][kiCurPos],
                                 &m_pSpatialPic[kiDidx][iCurTid]);


  }
  return 0;
}


/*
 *   SingleLayerPreprocess: down sampling if applicable
 *  @return: exact number of spatial layers need to encoder indeed
 */
int32_t CWelsPreProcess::SingleLayerPreprocess (sWelsEncCtx* pCtx, const SSourcePicture* kpSrc,
    Scaled_Picture* pScaledPicture) {
  SWelsSvcCodingParam* pSvcParam    = pCtx->pSvcParam;
  int8_t  iDependencyId             = pSvcParam->iSpatialLayerNum - 1;

  SPicture* pSrcPic                 = NULL; // large
  SPicture* pDstPic                 = NULL; // small
  SSpatialLayerConfig* pDlayerParam = NULL;
  SSpatialLayerInternal* pDlayerParamInternal = NULL;
  int32_t iSpatialNum               = 0;
  int32_t iSrcWidth                 = 0;
  int32_t iSrcHeight                = 0;
  int32_t iTargetWidth              = 0;
  int32_t iTargetHeight             = 0;
  int32_t iTemporalId = 0;
  int32_t iClosestDid =  iDependencyId;
  pDlayerParamInternal = &pSvcParam->sDependencyLayers[iDependencyId];
  pDlayerParam = &pSvcParam->sSpatialLayers[iDependencyId];
  iTargetWidth   = pDlayerParam->iVideoWidth;
  iTargetHeight  = pDlayerParam->iVideoHeight;

  iSrcWidth   = pSvcParam->SUsedPicRect.iWidth;
  iSrcHeight  = pSvcParam->SUsedPicRect.iHeight;
  if (pSvcParam->uiIntraPeriod) {
    pCtx->pVaa->bIdrPeriodFlag = (1 + pDlayerParamInternal->iFrameIndex >= (int32_t)pSvcParam->uiIntraPeriod) ? true :
                                 false;
    if (pCtx->pVaa->bIdrPeriodFlag) {
      WelsLog (& (pCtx->sLogCtx), WELS_LOG_DEBUG,
           "pSvcParam->uiIntraPeriod=%d, pCtx->pVaa->bIdrPeriodFlag=%d",
             pSvcParam->uiIntraPeriod,
             pCtx->pVaa->bIdrPeriodFlag);
    }
  }

  pSrcPic = pScaledPicture->pScaledInputPicture ? pScaledPicture->pScaledInputPicture : GetCurrentOrigFrame (
              iDependencyId);

  WelsMoveMemoryWrapper (pSvcParam, pSrcPic, kpSrc, iSrcWidth, iSrcHeight);

  if (pSvcParam->bEnableDenoise)
    BilateralDenoising (pSrcPic, iSrcWidth, iSrcHeight);

  // different scaling in between input picture and dst highest spatial picture.
  int32_t iShrinkWidth  = iSrcWidth;
  int32_t iShrinkHeight = iSrcHeight;
  pDstPic = pSrcPic;
  if (pScaledPicture->pScaledInputPicture) {
    // for highest downsampling
    pDstPic = GetCurrentOrigFrame (iDependencyId);
    iShrinkWidth = pScaledPicture->iScaledWidth[iDependencyId];
    iShrinkHeight = pScaledPicture->iScaledHeight[iDependencyId];
  }
  DownsamplePadding (pSrcPic, pDstPic, iSrcWidth, iSrcHeight, iShrinkWidth, iShrinkHeight, iTargetWidth, iTargetHeight,
                     false);

  if (pSvcParam->bEnableSceneChangeDetect && !pCtx->pVaa->bIdrPeriodFlag) {
    if (pSvcParam->iUsageType == SCREEN_CONTENT_REAL_TIME) {
      pCtx->pVaa->eSceneChangeIdc = (pDlayerParamInternal->bEncCurFrmAsIdrFlag ? LARGE_CHANGED_SCENE :
                                     DetectSceneChange (pDstPic));
      pCtx->pVaa->bSceneChangeFlag = (LARGE_CHANGED_SCENE == pCtx->pVaa->eSceneChangeIdc);
    } else {
      if ((!pDlayerParamInternal->bEncCurFrmAsIdrFlag)
          && ! (pDlayerParamInternal->iCodingIndex & (pSvcParam->uiGopSize - 1))) {
        SPicture* pRefPic = pCtx->pLtr[iDependencyId].bReceivedT0LostFlag ?
                            m_pSpatialPic[iDependencyId][m_uiSpatialLayersInTemporal[iDependencyId] +
                                pCtx->pVaa->uiValidLongTermPicIdx] : m_pLastSpatialPicture[iDependencyId][0];
        //pCtx->pVaa->eSceneChangeIdc = DetectSceneChange (pDstPic, pRefPic);
        pCtx->pVaa->bSceneChangeFlag = GetSceneChangeFlag (DetectSceneChange (pDstPic, pRefPic));
      }
    }
  }

  for (int32_t i = 0; i < pSvcParam->iSpatialLayerNum; i++) {
    pDlayerParamInternal = &pSvcParam->sDependencyLayers[i];
    iTemporalId    = pDlayerParamInternal->uiCodingIdx2TemporalId[pDlayerParamInternal->iCodingIndex &
                     (pSvcParam->uiGopSize - 1)];
    if (iTemporalId != INVALID_TEMPORAL_ID) {
      ++ iSpatialNum;
    }
  }
  pDlayerParamInternal = &pSvcParam->sDependencyLayers[iDependencyId];
  iTemporalId    = pDlayerParamInternal->uiCodingIdx2TemporalId[pDlayerParamInternal->iCodingIndex &
                   (pSvcParam->uiGopSize - 1)];
  int iActualSpatialNum = iSpatialNum - 1;
  if (iTemporalId != INVALID_TEMPORAL_ID) {
    WelsUpdateSpatialIdxMap (pCtx, iActualSpatialNum, pDstPic, iDependencyId);
    -- iActualSpatialNum;
  }

  m_pLastSpatialPicture[iDependencyId][1] = GetCurrentOrigFrame (iDependencyId);
  -- iDependencyId;


  // generate other spacial layer
  // pSrc is
  //    -- padded input pic, if downsample should be applied to generate highest layer, [if] block above
  //    -- highest layer, if no downsampling, [else] block above
  if (pSvcParam->iSpatialLayerNum > 1) {
    while (iDependencyId >= 0) {
      pDlayerParamInternal = &pSvcParam->sDependencyLayers[iDependencyId];
      pDlayerParam = &pSvcParam->sSpatialLayers[iDependencyId];
      SPicture* pSrcPic  = m_pLastSpatialPicture[iClosestDid][1]; // large
      iTargetWidth  = pDlayerParam->iVideoWidth;
      iTargetHeight = pDlayerParam->iVideoHeight;
      iTemporalId = pDlayerParamInternal->uiCodingIdx2TemporalId[pDlayerParamInternal->iCodingIndex &
                    (pSvcParam->uiGopSize - 1)];

      // down sampling performed
      int32_t iSrcWidth                 = pScaledPicture->iScaledWidth[iClosestDid];
      int32_t iSrcHeight                = pScaledPicture->iScaledHeight[iClosestDid];
      pDstPic = GetCurrentOrigFrame (iDependencyId); // small
      iShrinkWidth = pScaledPicture->iScaledWidth[iDependencyId];
      iShrinkHeight = pScaledPicture->iScaledHeight[iDependencyId];
      DownsamplePadding (pSrcPic, pDstPic, iSrcWidth, iSrcHeight, iShrinkWidth, iShrinkHeight, iTargetWidth, iTargetHeight,
                         true);

      if ((iTemporalId != INVALID_TEMPORAL_ID)) {
        WelsUpdateSpatialIdxMap (pCtx, iActualSpatialNum, pDstPic, iDependencyId);
        iActualSpatialNum--;
      }

      m_pLastSpatialPicture[iDependencyId][1] = pDstPic;

      iClosestDid = iDependencyId;
      -- iDependencyId;

    }
  }
  return iSpatialNum;

}


/*!
 * \brief   Whether input picture need be scaled?
 */
bool JudgeNeedOfScaling (SWelsSvcCodingParam* pParam, Scaled_Picture* pScaledPicture) {
  const int32_t kiInputPicWidth  = pParam->SUsedPicRect.iWidth;
  const int32_t kiInputPicHeight = pParam->SUsedPicRect.iHeight;
  const int32_t kiDstPicWidth    = pParam->sDependencyLayers[pParam->iSpatialLayerNum - 1].iActualWidth;
  const int32_t kiDstPicHeight   = pParam->sDependencyLayers[pParam->iSpatialLayerNum - 1].iActualHeight;
  bool bNeedDownsampling = true;

  int32_t iSpatialIdx = pParam->iSpatialLayerNum - 1;

  if (kiDstPicWidth >= kiInputPicWidth && kiDstPicHeight >= kiInputPicHeight) {
    bNeedDownsampling = false;
  }

  for (; iSpatialIdx >= 0; iSpatialIdx --) {
    SSpatialLayerInternal* pCurLayer = &pParam->sDependencyLayers[iSpatialIdx];
    int32_t iCurDstWidth             = pCurLayer->iActualWidth;
    int32_t iCurDstHeight            = pCurLayer->iActualHeight;
    int32_t iInputWidthXDstHeight    = kiInputPicWidth * iCurDstHeight;
    int32_t iInputHeightXDstWidth    = kiInputPicHeight * iCurDstWidth;

    if (iInputWidthXDstHeight > iInputHeightXDstWidth) {
      pScaledPicture->iScaledWidth[iSpatialIdx] = WELS_MAX (iCurDstWidth, 4);
      pScaledPicture->iScaledHeight[iSpatialIdx] = WELS_MAX (iInputHeightXDstWidth / kiInputPicWidth, 4);
    } else {
      pScaledPicture->iScaledWidth[iSpatialIdx] = WELS_MAX (iInputWidthXDstHeight / kiInputPicHeight, 4);
      pScaledPicture->iScaledHeight[iSpatialIdx] = WELS_MAX (iCurDstHeight, 4);
    }
  }

  return bNeedDownsampling;
}

int32_t  WelsInitScaledPic (SWelsSvcCodingParam* pParam,  Scaled_Picture*  pScaledPicture, CMemoryAlign* pMemoryAlign) {
  bool bInputPicNeedScaling = JudgeNeedOfScaling (pParam, pScaledPicture);
  if (bInputPicNeedScaling) {
    pScaledPicture->pScaledInputPicture = AllocPicture (pMemoryAlign, pParam->SUsedPicRect.iWidth,
                                          pParam->SUsedPicRect.iHeight, false, 0);
    if (pScaledPicture->pScaledInputPicture == NULL)
      return -1;

    // Avoid valgrind false positives.
    //
    // X86 SIMD downsampling routines may, for convenience, read slightly beyond
    // the input data and into the alignment padding area beyond each line. This
    // causes valgrind to warn about uninitialized values even if these values
    // only affect lanes of a SIMD vector that are effectively never used.
    //
    // Avoid these false positives by zero-initializing the padding area beyond
    // each line of the source buffer used for downsampling.
    SPicture* pPic = pScaledPicture->pScaledInputPicture;
    ClearEndOfLinePadding (pPic->pData[0], pPic->iLineSize[0], pPic->iWidthInPixel, pPic->iHeightInPixel);
    ClearEndOfLinePadding (pPic->pData[1], pPic->iLineSize[1], pPic->iWidthInPixel >> 1, pPic->iHeightInPixel >> 1);
    ClearEndOfLinePadding (pPic->pData[2], pPic->iLineSize[2], pPic->iWidthInPixel >> 1, pPic->iHeightInPixel >> 1);
  }
  return 0;
}

void  FreeScaledPic (Scaled_Picture*  pScaledPicture, CMemoryAlign* pMemoryAlign) {
  if (pScaledPicture->pScaledInputPicture) {
    FreePicture (pMemoryAlign, &pScaledPicture->pScaledInputPicture);
    pScaledPicture->pScaledInputPicture = NULL;
  }
}

int32_t CWelsPreProcess::InitLastSpatialPictures (sWelsEncCtx* pCtx) {
  SWelsSvcCodingParam* pParam   = pCtx->pSvcParam;
  const int32_t kiDlayerCount   = pParam->iSpatialLayerNum;
  int32_t iDlayerIndex          = 0;
  if (pParam->iUsageType == SCREEN_CONTENT_REAL_TIME) {
    for (; iDlayerIndex < MAX_DEPENDENCY_LAYER; iDlayerIndex++) {
      m_pLastSpatialPicture[iDlayerIndex][0] = m_pLastSpatialPicture[iDlayerIndex][1] = NULL;
    }
  } else {
    for (; iDlayerIndex < kiDlayerCount; iDlayerIndex++) {
      const int32_t kiLayerInTemporal = m_uiSpatialLayersInTemporal[iDlayerIndex];
      m_pLastSpatialPicture[iDlayerIndex][0] = m_pSpatialPic[iDlayerIndex][kiLayerInTemporal - 2];
      m_pLastSpatialPicture[iDlayerIndex][1] = NULL;
    }
    for (; iDlayerIndex < MAX_DEPENDENCY_LAYER; iDlayerIndex++) {
      m_pLastSpatialPicture[iDlayerIndex][0] = m_pLastSpatialPicture[iDlayerIndex][1] = NULL;
    }
  }
  return 0;
}
//*********************************************************************************************************/

int32_t CWelsPreProcess::ColorspaceConvert (SWelsSvcCodingParam* pSvcParam, SPicture* pDstPic,
    const SSourcePicture* kpSrc, const int32_t kiWidth, const int32_t kiHeight) {
  return 1;
  //not support yet
}

void CWelsPreProcess::BilateralDenoising (SPicture* pSrc, const int32_t kiWidth, const int32_t kiHeight) {
  int32_t iMethodIdx = METHOD_DENOISE;
  SPixMap sSrcPixMap;
  memset (&sSrcPixMap, 0, sizeof (sSrcPixMap));
  sSrcPixMap.pPixel[0] = pSrc->pData[0];
  sSrcPixMap.pPixel[1] = pSrc->pData[1];
  sSrcPixMap.pPixel[2] = pSrc->pData[2];
  sSrcPixMap.iSizeInBits = g_kiPixMapSizeInBits;
  sSrcPixMap.sRect.iRectWidth = kiWidth;
  sSrcPixMap.sRect.iRectHeight = kiHeight;
  sSrcPixMap.iStride[0] = pSrc->iLineSize[0];
  sSrcPixMap.iStride[1] = pSrc->iLineSize[1];
  sSrcPixMap.iStride[2] = pSrc->iLineSize[2];
  sSrcPixMap.eFormat = VIDEO_FORMAT_I420;

  m_pInterfaceVp->Process (iMethodIdx, &sSrcPixMap, NULL);
}

ESceneChangeIdc CWelsPreProcessVideo::DetectSceneChange (SPicture* pCurPicture, SPicture* pRefPicture) {
  int32_t iMethodIdx = METHOD_SCENE_CHANGE_DETECTION_VIDEO;
  SSceneChangeResult sSceneChangeDetectResult = { SIMILAR_SCENE };
  SPixMap sSrcPixMap;
  SPixMap sRefPixMap;
  memset (&sSrcPixMap, 0, sizeof (sSrcPixMap));
  memset (&sRefPixMap, 0, sizeof (sRefPixMap));
  sSrcPixMap.pPixel[0] = pCurPicture->pData[0];
  sSrcPixMap.iSizeInBits = g_kiPixMapSizeInBits;
  sSrcPixMap.iStride[0] = pCurPicture->iLineSize[0];
  sSrcPixMap.sRect.iRectWidth = pCurPicture->iWidthInPixel;
  sSrcPixMap.sRect.iRectHeight = pCurPicture->iHeightInPixel;
  sSrcPixMap.eFormat = VIDEO_FORMAT_I420;

  sRefPixMap.pPixel[0] = pRefPicture->pData[0];
  sRefPixMap.iSizeInBits = g_kiPixMapSizeInBits;
  sRefPixMap.iStride[0] = pRefPicture->iLineSize[0];
  sRefPixMap.sRect.iRectWidth = pRefPicture->iWidthInPixel;
  sRefPixMap.sRect.iRectHeight = pRefPicture->iHeightInPixel;
  sRefPixMap.eFormat = VIDEO_FORMAT_I420;

  int32_t iRet = m_pInterfaceVp->Process (iMethodIdx, &sSrcPixMap, &sRefPixMap);
  if (iRet == 0) {
    m_pInterfaceVp->Get (iMethodIdx, (void*)&sSceneChangeDetectResult);
    //bSceneChangeFlag = (sSceneChangeDetectResult.eSceneChangeIdc == LARGE_CHANGED_SCENE) ? true : false;
  }
  return sSceneChangeDetectResult.eSceneChangeIdc;
}

SPicture* CWelsPreProcessVideo::GetCurrentOrigFrame (int32_t iDIdx) {
  return m_pSpatialPic[iDIdx][GetCurPicPosition (iDIdx)];
}

int32_t CWelsPreProcess::DownsamplePadding (SPicture* pSrc, SPicture* pDstPic,  int32_t iSrcWidth, int32_t iSrcHeight,
    int32_t iShrinkWidth, int32_t iShrinkHeight, int32_t iTargetWidth, int32_t iTargetHeight, bool bForceCopy) {
  int32_t iRet = 0;
  SPixMap sSrcPixMap;
  SPixMap sDstPicMap;
  memset (&sSrcPixMap, 0, sizeof (sSrcPixMap));
  memset (&sDstPicMap, 0, sizeof (sDstPicMap));
  sSrcPixMap.pPixel[0]   = pSrc->pData[0];
  sSrcPixMap.pPixel[1]   = pSrc->pData[1];
  sSrcPixMap.pPixel[2]   = pSrc->pData[2];
  sSrcPixMap.iSizeInBits = g_kiPixMapSizeInBits;
  sSrcPixMap.sRect.iRectWidth  = iSrcWidth;
  sSrcPixMap.sRect.iRectHeight = iSrcHeight;
  sSrcPixMap.iStride[0]  = pSrc->iLineSize[0];
  sSrcPixMap.iStride[1]  = pSrc->iLineSize[1];
  sSrcPixMap.iStride[2]  = pSrc->iLineSize[2];
  sSrcPixMap.eFormat     = VIDEO_FORMAT_I420;

  if (iSrcWidth != iShrinkWidth || iSrcHeight != iShrinkHeight || bForceCopy) {
    int32_t iMethodIdx = METHOD_DOWNSAMPLE;
    sDstPicMap.pPixel[0]   = pDstPic->pData[0];
    sDstPicMap.pPixel[1]   = pDstPic->pData[1];
    sDstPicMap.pPixel[2]   = pDstPic->pData[2];
    sDstPicMap.iSizeInBits = g_kiPixMapSizeInBits;
    sDstPicMap.sRect.iRectWidth  = iShrinkWidth;
    sDstPicMap.sRect.iRectHeight = iShrinkHeight;
    sDstPicMap.iStride[0]  = pDstPic->iLineSize[0];
    sDstPicMap.iStride[1]  = pDstPic->iLineSize[1];
    sDstPicMap.iStride[2]  = pDstPic->iLineSize[2];
    sDstPicMap.eFormat     = VIDEO_FORMAT_I420;

    if (iSrcWidth != iShrinkWidth || iSrcHeight != iShrinkHeight) {
      iRet = m_pInterfaceVp->Process (iMethodIdx, &sSrcPixMap, &sDstPicMap);
    } else {
      WelsMoveMemory_c (pDstPic->pData[0], pDstPic->pData[1], pDstPic->pData[2], pDstPic->iLineSize[0], pDstPic->iLineSize[1],
                        pSrc->pData[0], pSrc->pData[1], pSrc->pData[2], pSrc->iLineSize[0], pSrc->iLineSize[1],
                        iSrcWidth, iSrcHeight);
    }
  } else {
    memcpy (&sDstPicMap, &sSrcPixMap, sizeof (sDstPicMap)); // confirmed_safe_unsafe_usage
  }

  // get rid of odd line
  iShrinkWidth -= (iShrinkWidth & 1);
  iShrinkHeight -= (iShrinkHeight & 1);
  Padding ((uint8_t*)sDstPicMap.pPixel[0], (uint8_t*)sDstPicMap.pPixel[1], (uint8_t*)sDstPicMap.pPixel[2],
           sDstPicMap.iStride[0], sDstPicMap.iStride[1], iShrinkWidth, iTargetWidth, iShrinkHeight, iTargetHeight);

  return iRet;
}

//*********************************************************************************************************/
void CWelsPreProcess::VaaCalculation (SVAAFrameInfo* pVaaInfo, SPicture* pCurPicture, SPicture* pRefPicture,
                                      bool bCalculateSQDiff, bool bCalculateVar, bool bCalculateBGD) {
  pVaaInfo->sVaaCalcInfo.pCurY = pCurPicture->pData[0];
  pVaaInfo->sVaaCalcInfo.pRefY = pRefPicture->pData[0];
  {
    int32_t iMethodIdx = METHOD_VAA_STATISTICS;
    SPixMap sCurPixMap;
    SPixMap sRefPixMap;
    memset (&sCurPixMap, 0, sizeof (sCurPixMap));
    memset (&sRefPixMap, 0, sizeof (sRefPixMap));
    SVAACalcParam calc_param = {0};

    sCurPixMap.pPixel[0] = pCurPicture->pData[0];
    sCurPixMap.iSizeInBits = g_kiPixMapSizeInBits;
    sCurPixMap.sRect.iRectWidth = pCurPicture->iWidthInPixel;
    sCurPixMap.sRect.iRectHeight = pCurPicture->iHeightInPixel;
    sCurPixMap.iStride[0] = pCurPicture->iLineSize[0];
    sCurPixMap.eFormat = VIDEO_FORMAT_I420;

    sRefPixMap.pPixel[0] = pRefPicture->pData[0];
    sRefPixMap.iSizeInBits = g_kiPixMapSizeInBits;
    sRefPixMap.sRect.iRectWidth = pRefPicture->iWidthInPixel;
    sRefPixMap.sRect.iRectHeight = pRefPicture->iHeightInPixel;
    sRefPixMap.iStride[0] = pRefPicture->iLineSize[0];
    sRefPixMap.eFormat = VIDEO_FORMAT_I420;

    calc_param.iCalcVar = bCalculateVar;
    calc_param.iCalcBgd = bCalculateBGD;
    calc_param.iCalcSsd = bCalculateSQDiff;
    calc_param.pCalcResult = &pVaaInfo->sVaaCalcInfo;

    m_pInterfaceVp->Set (iMethodIdx, &calc_param);
    m_pInterfaceVp->Process (iMethodIdx, &sCurPixMap, &sRefPixMap);
  }
}

void CWelsPreProcess::BackgroundDetection (SVAAFrameInfo* pVaaInfo, SPicture* pCurPicture, SPicture* pRefPicture,
    bool bDetectFlag) {
  if (bDetectFlag) {
    pVaaInfo->iPicWidth     = pCurPicture->iWidthInPixel;
    pVaaInfo->iPicHeight    = pCurPicture->iHeightInPixel;

    pVaaInfo->iPicStride    = pCurPicture->iLineSize[0];
    pVaaInfo->iPicStrideUV  = pCurPicture->iLineSize[1];
    pVaaInfo->pCurY         = pCurPicture->pData[0];
    pVaaInfo->pRefY         = pRefPicture->pData[0];
    pVaaInfo->pCurU         = pCurPicture->pData[1];
    pVaaInfo->pRefU         = pRefPicture->pData[1];
    pVaaInfo->pCurV         = pCurPicture->pData[2];
    pVaaInfo->pRefV         = pRefPicture->pData[2];

    int32_t iMethodIdx = METHOD_BACKGROUND_DETECTION;
    SPixMap sSrcPixMap;
    SPixMap sRefPixMap;
    memset (&sSrcPixMap, 0, sizeof (sSrcPixMap));
    memset (&sRefPixMap, 0, sizeof (sRefPixMap));
    SBGDInterface BGDParam = {0};

    sSrcPixMap.pPixel[0] = pCurPicture->pData[0];
    sSrcPixMap.pPixel[1] = pCurPicture->pData[1];
    sSrcPixMap.pPixel[2] = pCurPicture->pData[2];
    sSrcPixMap.iSizeInBits = g_kiPixMapSizeInBits;
    sSrcPixMap.iStride[0] = pCurPicture->iLineSize[0];
    sSrcPixMap.iStride[1] = pCurPicture->iLineSize[1];
    sSrcPixMap.iStride[2] = pCurPicture->iLineSize[2];
    sSrcPixMap.sRect.iRectWidth = pCurPicture->iWidthInPixel;
    sSrcPixMap.sRect.iRectHeight = pCurPicture->iHeightInPixel;
    sSrcPixMap.eFormat = VIDEO_FORMAT_I420;

    sRefPixMap.pPixel[0] = pRefPicture->pData[0];
    sRefPixMap.pPixel[1] = pRefPicture->pData[1];
    sRefPixMap.pPixel[2] = pRefPicture->pData[2];
    sRefPixMap.iSizeInBits = g_kiPixMapSizeInBits;
    sRefPixMap.iStride[0] = pRefPicture->iLineSize[0];
    sRefPixMap.iStride[1] = pRefPicture->iLineSize[1];
    sRefPixMap.iStride[2] = pRefPicture->iLineSize[2];
    sRefPixMap.sRect.iRectWidth = pRefPicture->iWidthInPixel;
    sRefPixMap.sRect.iRectHeight = pRefPicture->iHeightInPixel;
    sRefPixMap.eFormat = VIDEO_FORMAT_I420;

    BGDParam.pBackgroundMbFlag = pVaaInfo->pVaaBackgroundMbFlag;
    BGDParam.pCalcRes = & (pVaaInfo->sVaaCalcInfo);
    m_pInterfaceVp->Set (iMethodIdx, (void*)&BGDParam);
    m_pInterfaceVp->Process (iMethodIdx, &sSrcPixMap, &sRefPixMap);
  } else {
    int32_t iPicWidthInMb  = (pCurPicture->iWidthInPixel  + 15) >> 4;
    int32_t iPicHeightInMb = (pCurPicture->iHeightInPixel + 15) >> 4;
    memset (pVaaInfo->pVaaBackgroundMbFlag, 0, iPicWidthInMb * iPicHeightInMb);
  }
}

void CWelsPreProcess::AdaptiveQuantCalculation (SVAAFrameInfo* pVaaInfo, SPicture* pCurPicture, SPicture* pRefPicture) {
  pVaaInfo->sAdaptiveQuantParam.pCalcResult = & (pVaaInfo->sVaaCalcInfo);
  pVaaInfo->sAdaptiveQuantParam.iAverMotionTextureIndexToDeltaQp = 0;

  {
    int32_t iMethodIdx = METHOD_ADAPTIVE_QUANT;
    SPixMap pSrc;
    SPixMap pRef;
    memset (&pSrc, 0, sizeof (pSrc));
    memset (&pRef, 0, sizeof (pRef));
    int32_t iRet = 0;

    pSrc.pPixel[0] = pCurPicture->pData[0];
    pSrc.iSizeInBits = g_kiPixMapSizeInBits;
    pSrc.iStride[0] = pCurPicture->iLineSize[0];
    pSrc.sRect.iRectWidth = pCurPicture->iWidthInPixel;
    pSrc.sRect.iRectHeight = pCurPicture->iHeightInPixel;
    pSrc.eFormat = VIDEO_FORMAT_I420;

    pRef.pPixel[0] = pRefPicture->pData[0];
    pRef.iSizeInBits = g_kiPixMapSizeInBits;
    pRef.iStride[0] = pRefPicture->iLineSize[0];
    pRef.sRect.iRectWidth = pRefPicture->iWidthInPixel;
    pRef.sRect.iRectHeight = pRefPicture->iHeightInPixel;
    pRef.eFormat = VIDEO_FORMAT_I420;

    iRet = m_pInterfaceVp->Set (iMethodIdx, (void*) & (pVaaInfo->sAdaptiveQuantParam));
    iRet = m_pInterfaceVp->Process (iMethodIdx, &pSrc, &pRef);
    if (iRet == 0)
      m_pInterfaceVp->Get (iMethodIdx, (void*) & (pVaaInfo->sAdaptiveQuantParam));
  }
}

void CWelsPreProcess::SetRefMbType (sWelsEncCtx* pCtx, uint32_t** pRefMbTypeArray, int32_t iRefPicType) {
  const uint8_t uiTid       = pCtx->uiTemporalId;
  const uint8_t uiDid       = pCtx->uiDependencyId;
  SRefList* pRefPicLlist    = pCtx->ppRefPicListExt[uiDid];
  SLTRState* pLtr           = &pCtx->pLtr[uiDid];
  uint8_t i = 0;

  if (pCtx->pSvcParam->bEnableLongTermReference && pLtr->bReceivedT0LostFlag && uiTid == 0) {
    for (i = 0; i < pRefPicLlist->uiLongRefCount; i++) {
      SPicture* pRef = pRefPicLlist->pLongRefList[i];
      if (pRef != NULL && pRef->uiRecieveConfirmed == 1/*RECIEVE_SUCCESS*/) {
        *pRefMbTypeArray = pRef->uiRefMbType;
        break;
      }
    }
  } else {
    for (i = 0; i < pRefPicLlist->uiShortRefCount; i++) {
      SPicture* pRef = pRefPicLlist->pShortRefList[i];
      if (pRef != NULL && pRef->bUsedAsRef && pRef->iFramePoc >= 0 && pRef->uiTemporalId <= uiTid) {
        *pRefMbTypeArray = pRef->uiRefMbType;
        break;
      }
    }
  }
}


void CWelsPreProcess::AnalyzePictureComplexity (sWelsEncCtx* pCtx, SPicture* pCurPicture, SPicture* pRefPicture,
    const int32_t kiDependencyId, const bool bCalculateBGD) {
  SWelsSvcCodingParam* pSvcParam = pCtx->pSvcParam;
  int32_t iComplexityAnalysisMode = 0;

  if (pSvcParam->iUsageType == SCREEN_CONTENT_REAL_TIME) {
    SVAAFrameInfoExt* pVaaExt = static_cast<SVAAFrameInfoExt*> (pCtx->pVaa);
    SComplexityAnalysisScreenParam* sComplexityAnalysisParam = &pVaaExt->sComplexityScreenParam;
    SWelsSvcRc* pWelsSvcRc = &pCtx->pWelsSvcRc[kiDependencyId];

    if (pCtx->eSliceType == P_SLICE)
      iComplexityAnalysisMode = GOM_SAD;
    else if (pCtx->eSliceType == I_SLICE)
      iComplexityAnalysisMode = GOM_VAR;
    else
      return;

    memset (pWelsSvcRc->pGomForegroundBlockNum, 0, pWelsSvcRc->iGomSize * sizeof (int32_t));
    memset (pWelsSvcRc->pCurrentFrameGomSad, 0, pWelsSvcRc->iGomSize * sizeof (int32_t));

    sComplexityAnalysisParam->iFrameComplexity = 0;
    sComplexityAnalysisParam->pGomComplexity = pWelsSvcRc->pCurrentFrameGomSad;
    sComplexityAnalysisParam->iGomNumInFrame = pWelsSvcRc->iGomSize;
    sComplexityAnalysisParam->iIdrFlag = (pCtx->eSliceType == I_SLICE);
    sComplexityAnalysisParam->iMbRowInGom = GOM_H_SCC;
    sComplexityAnalysisParam->sScrollResult.bScrollDetectFlag = false;
    sComplexityAnalysisParam->sScrollResult.iScrollMvX = 0;
    sComplexityAnalysisParam->sScrollResult.iScrollMvY = 0;

    const int32_t iMethodIdx = METHOD_COMPLEXITY_ANALYSIS_SCREEN;
    SPixMap sSrcPixMap;
    SPixMap sRefPixMap;
    memset (&sSrcPixMap, 0, sizeof (SPixMap));
    memset (&sRefPixMap, 0, sizeof (SPixMap));
    int32_t iRet = 0;

    sSrcPixMap.pPixel[0] = pCurPicture->pData[0];
    sSrcPixMap.iSizeInBits = g_kiPixMapSizeInBits;
    sSrcPixMap.iStride[0] = pCurPicture->iLineSize[0];
    sSrcPixMap.sRect.iRectWidth = pCurPicture->iWidthInPixel;
    sSrcPixMap.sRect.iRectHeight = pCurPicture->iHeightInPixel;
    sSrcPixMap.eFormat = VIDEO_FORMAT_I420;

    if (pRefPicture != NULL) {
      sRefPixMap.pPixel[0] = pRefPicture->pData[0];
      sRefPixMap.iSizeInBits = g_kiPixMapSizeInBits;
      sRefPixMap.iStride[0] = pRefPicture->iLineSize[0];
      sRefPixMap.sRect.iRectWidth = pRefPicture->iWidthInPixel;
      sRefPixMap.sRect.iRectHeight = pRefPicture->iHeightInPixel;
      sRefPixMap.eFormat = VIDEO_FORMAT_I420;
    }

    iRet = m_pInterfaceVp->Set (iMethodIdx, (void*)sComplexityAnalysisParam);
    iRet = m_pInterfaceVp->Process (iMethodIdx, &sSrcPixMap, &sRefPixMap);
    if (iRet == 0)
      m_pInterfaceVp->Get (iMethodIdx, (void*)sComplexityAnalysisParam);

  } else {
    SVAAFrameInfo* pVaaInfo = pCtx->pVaa;
    SComplexityAnalysisParam* sComplexityAnalysisParam = & (pVaaInfo->sComplexityAnalysisParam);
    SWelsSvcRc* SWelsSvcRc = &pCtx->pWelsSvcRc[kiDependencyId];

    if (pSvcParam->iRCMode == RC_QUALITY_MODE && pCtx->eSliceType == P_SLICE) {
      iComplexityAnalysisMode = FRAME_SAD;
    } else if (((pSvcParam->iRCMode == RC_BITRATE_MODE) || (pSvcParam->iRCMode == RC_TIMESTAMP_MODE))
               && pCtx->eSliceType == P_SLICE) {
      iComplexityAnalysisMode = GOM_SAD;
    } else if (((pSvcParam->iRCMode == RC_BITRATE_MODE) || (pSvcParam->iRCMode == RC_TIMESTAMP_MODE))
               && pCtx->eSliceType == I_SLICE) {
      iComplexityAnalysisMode = GOM_VAR;
    } else {
      return;
    }

    sComplexityAnalysisParam->iComplexityAnalysisMode = iComplexityAnalysisMode;
    sComplexityAnalysisParam->pCalcResult = & (pVaaInfo->sVaaCalcInfo);
    sComplexityAnalysisParam->pBackgroundMbFlag = pVaaInfo->pVaaBackgroundMbFlag;
    if (pRefPicture)
      SetRefMbType (pCtx, & (sComplexityAnalysisParam->uiRefMbType), pRefPicture->iPictureType);
    sComplexityAnalysisParam->iCalcBgd = bCalculateBGD;
    sComplexityAnalysisParam->iFrameComplexity = 0;

    memset (SWelsSvcRc->pGomForegroundBlockNum, 0, SWelsSvcRc->iGomSize * sizeof (int32_t));
    if (iComplexityAnalysisMode != FRAME_SAD)
      memset (SWelsSvcRc->pCurrentFrameGomSad, 0, SWelsSvcRc->iGomSize * sizeof (int32_t));

    sComplexityAnalysisParam->pGomComplexity = SWelsSvcRc->pCurrentFrameGomSad;
    sComplexityAnalysisParam->pGomForegroundBlockNum = SWelsSvcRc->pGomForegroundBlockNum;
    sComplexityAnalysisParam->iMbNumInGom = SWelsSvcRc->iNumberMbGom;

    {
      int32_t iMethodIdx = METHOD_COMPLEXITY_ANALYSIS;
      SPixMap sSrcPixMap;
      SPixMap sRefPixMap;
      memset (&sSrcPixMap, 0, sizeof (SPixMap));
      memset (&sRefPixMap, 0, sizeof (SPixMap));
      int32_t iRet = 0;

      sSrcPixMap.pPixel[0] = pCurPicture->pData[0];
      sSrcPixMap.iSizeInBits = g_kiPixMapSizeInBits;
      sSrcPixMap.iStride[0] = pCurPicture->iLineSize[0];
      sSrcPixMap.sRect.iRectWidth = pCurPicture->iWidthInPixel;
      sSrcPixMap.sRect.iRectHeight = pCurPicture->iHeightInPixel;
      sSrcPixMap.eFormat = VIDEO_FORMAT_I420;

      if (pRefPicture) {
        sRefPixMap.pPixel[0] = pRefPicture->pData[0];
        sRefPixMap.iSizeInBits = g_kiPixMapSizeInBits;
        sRefPixMap.iStride[0] = pRefPicture->iLineSize[0];
        sRefPixMap.sRect.iRectWidth = pRefPicture->iWidthInPixel;
        sRefPixMap.sRect.iRectHeight = pRefPicture->iHeightInPixel;
      }
      sRefPixMap.eFormat = VIDEO_FORMAT_I420;

      iRet = m_pInterfaceVp->Set (iMethodIdx, (void*)sComplexityAnalysisParam);
      iRet = m_pInterfaceVp->Process (iMethodIdx, &sSrcPixMap, &sRefPixMap);
      if (iRet == 0)
        m_pInterfaceVp->Get (iMethodIdx, (void*)sComplexityAnalysisParam);
    }
  }
}


void CWelsPreProcess::InitPixMap (const SPicture* pPicture, SPixMap* pPixMap) {
  pPixMap->pPixel[0] = pPicture->pData[0];
  pPixMap->pPixel[1] = pPicture->pData[1];
  pPixMap->pPixel[2] = pPicture->pData[2];
  pPixMap->iSizeInBits = sizeof (uint8_t);
  pPixMap->iStride[0] = pPicture->iLineSize[0];
  pPixMap->iStride[1] = pPicture->iLineSize[1];
  pPixMap->sRect.iRectWidth = pPicture->iWidthInPixel;
  pPixMap->sRect.iRectHeight = pPicture->iHeightInPixel;

  pPixMap->eFormat = VIDEO_FORMAT_I420;
}

SPicture** CWelsPreProcessScreen::GetReferenceSrcPicList (int32_t iTargetDid) {
  return (&m_pSpatialPic[iTargetDid][1]);
}

void CWelsPreProcessScreen::GetAvailableRefListLosslessScreenRefSelection (SPicture** pRefPicList, uint8_t iCurTid,
    const int32_t iClosestLtrFrameNum,
    SRefInfoParam* pAvailableRefParam, int32_t& iAvailableRefNum, int32_t& iAvailableSceneRefNum) {
  const int32_t iSourcePicNum = m_iAvaliableRefInSpatialPicList;
  if (0 >= iSourcePicNum) {
    iAvailableRefNum = 0;
    iAvailableSceneRefNum = 0;
    return ;
  }
  const bool bCurFrameMarkedAsSceneLtr = m_pEncCtx->bCurFrameMarkedAsSceneLtr;
  SPicture* pRefPic = NULL;
  uint8_t uiRefTid = 0;
  bool bRefRealLtr = false;

  iAvailableRefNum = 1; //zero is left for the closest frame
  iAvailableSceneRefNum = 0;

  //the saving order will be depend on pSrcPicList
  //TODO: use a frame_idx to find the closer ref in time distance, and correctly sort the ref list
  for (int32_t i = iSourcePicNum - 1; i >= 0; --i) {
    pRefPic = pRefPicList[i];
    if (NULL == pRefPic || !pRefPic->bUsedAsRef || !pRefPic->bIsLongRef || (bCurFrameMarkedAsSceneLtr
        && (!pRefPic->bIsSceneLTR))) {
      continue;
    }
    uiRefTid = pRefPic->uiTemporalId;
    bRefRealLtr = pRefPic->bIsSceneLTR;

    if (bRefRealLtr || (0 == iCurTid && 0 == uiRefTid) || (uiRefTid < iCurTid)) {
      int32_t idx = (pRefPic->iLongTermPicNum == iClosestLtrFrameNum) ? (0) : (iAvailableRefNum++);
      pAvailableRefParam[idx].pRefPicture = pRefPic;
      pAvailableRefParam[idx].iSrcListIdx = i + 1; //in SrcList, the idx 0 is reserved for CurPic
      iAvailableSceneRefNum += bRefRealLtr;
    }
  }

  if (pAvailableRefParam[0].pRefPicture == NULL) {
    for (int32_t i = 1; i < iAvailableRefNum ; ++i) {
      pAvailableRefParam[i - 1].pRefPicture = pAvailableRefParam[i].pRefPicture;
      pAvailableRefParam[i - 1].iSrcListIdx = pAvailableRefParam[i].iSrcListIdx;
    }

    pAvailableRefParam[iAvailableRefNum - 1].pRefPicture = NULL;
    pAvailableRefParam[iAvailableRefNum - 1].iSrcListIdx = 0;
    --iAvailableRefNum;
  }
}


void CWelsPreProcessScreen::GetAvailableRefList (SPicture** pSrcPicList, uint8_t iCurTid,
    const int32_t iClosestLtrFrameNum,
    SRefInfoParam* pAvailableRefList, int32_t& iAvailableRefNum, int32_t& iAvailableSceneRefNum) {
  const int32_t iSourcePicNum = m_iAvaliableRefInSpatialPicList;
  if (0 >= iSourcePicNum) {
    iAvailableRefNum = 0;
    iAvailableSceneRefNum = 0;
    return ;
  }
  SPicture* pRefPic = NULL;
  uint8_t uiRefTid = 0;
  iAvailableRefNum = 0;
  iAvailableSceneRefNum = 0;

  //the saving order will be depend on pSrcPicList
  //TODO: use a frame_idx to find the closer ref in time distance, and correctly sort the ref list
  for (int32_t i = iSourcePicNum - 1; i >= 0; --i) {
    pRefPic = pSrcPicList[i];
    if (NULL == pRefPic || !pRefPic->bUsedAsRef) {
      continue;
    }
    uiRefTid = pRefPic->uiTemporalId;

    if (uiRefTid <= iCurTid) {
      pAvailableRefList[iAvailableRefNum].pRefPicture = pRefPic;
      pAvailableRefList[iAvailableRefNum].iSrcListIdx = i + 1; //in SrcList, the idx 0 is reserved for CurPic
      iAvailableRefNum ++;
    }
  }
}


void CWelsPreProcessScreen::InitRefJudgement (SRefJudgement* pRefJudgement) {
  pRefJudgement->iMinFrameComplexity = INT_MAX;
  pRefJudgement->iMinFrameComplexity08 = INT_MAX;
  pRefJudgement->iMinFrameComplexity11 = INT_MAX;

  pRefJudgement->iMinFrameNumGap = INT_MAX;
  pRefJudgement->iMinFrameQp = INT_MAX;
}
bool CWelsPreProcessScreen::JudgeBestRef (SPicture* pRefPic, const SRefJudgement& sRefJudgement,
    const int64_t iFrameComplexity, const bool bIsClosestLtrFrame) {
  return (bIsClosestLtrFrame ? (iFrameComplexity < sRefJudgement.iMinFrameComplexity11) :
          ((iFrameComplexity < sRefJudgement.iMinFrameComplexity08) || ((iFrameComplexity <= sRefJudgement.iMinFrameComplexity11)
              && (pRefPic->iFrameAverageQp < sRefJudgement.iMinFrameQp))));
}

void CWelsPreProcessScreen::SaveBestRefToJudgement (const int32_t iRefPictureAvQP, const int64_t iComplexity,
    SRefJudgement* pRefJudgement) {
  pRefJudgement->iMinFrameQp = iRefPictureAvQP;
  pRefJudgement->iMinFrameComplexity =  iComplexity;
  pRefJudgement->iMinFrameComplexity08 = static_cast<int32_t> (iComplexity * 0.8);
  pRefJudgement->iMinFrameComplexity11 = static_cast<int32_t> (iComplexity * 1.1);
}
void CWelsPreProcessScreen::SaveBestRefToLocal (SRefInfoParam* pRefPicInfo,
    const SSceneChangeResult& sSceneChangeResult,
    SRefInfoParam* pRefSaved) {
  memcpy (pRefSaved, pRefPicInfo, sizeof (SRefInfoParam));
  pRefSaved->pBestBlockStaticIdc = sSceneChangeResult.pStaticBlockIdc;
}

void CWelsPreProcessScreen::SaveBestRefToVaa (SRefInfoParam& sRefSaved, SRefInfoParam* pVaaBestRef) {
  (*pVaaBestRef) = sRefSaved;
}

SPicture* CWelsPreProcessScreen::GetCurrentOrigFrame (int32_t iDIdx) {
  return m_pSpatialPic[iDIdx][0];
}

ESceneChangeIdc CWelsPreProcessScreen::DetectSceneChange (SPicture* pCurPicture, SPicture* pRef) {
  sWelsEncCtx* pCtx = m_pEncCtx;
#define STATIC_SCENE_MOTION_RATIO 0.01f
  SWelsSvcCodingParam* pSvcParam = pCtx->pSvcParam;
  SVAAFrameInfoExt* pVaaExt = static_cast<SVAAFrameInfoExt*> (pCtx->pVaa);
  SSpatialLayerInternal* pParamInternal = &pSvcParam->sDependencyLayers[0];
  if (NULL == pCtx || NULL == pVaaExt || NULL == pCurPicture) {
    return LARGE_CHANGED_SCENE;
  }

  const int32_t iTargetDid = pSvcParam->iSpatialLayerNum - 1;
  if (0 != iTargetDid) {
    return LARGE_CHANGED_SCENE;
  }

  ESceneChangeIdc iVaaFrameSceneChangeIdc = LARGE_CHANGED_SCENE;
  SPicture** pRefPicList = GetReferenceSrcPicList (iTargetDid);
  if (NULL == pRefPicList) {
    return LARGE_CHANGED_SCENE;
  }

  SRefInfoParam sAvailableRefParam[MAX_REF_PIC_COUNT] = { { 0 } };
  int32_t iAvailableRefNum = 0;
  int32_t iAvailableSceneRefNum = 0;

  int32_t iSceneChangeMethodIdx = METHOD_SCENE_CHANGE_DETECTION_SCREEN;
  SSceneChangeResult sSceneChangeResult = {SIMILAR_SCENE, 0, 0, NULL};

  SPixMap sSrcMap = { { 0 } };
  SPixMap sRefMap = { { 0 } };
  SRefJudgement sLtrJudgement;
  SRefJudgement sSceneLtrJudgement;
  SRefInfoParam sLtrSaved = {0};
  SRefInfoParam sSceneLtrSaved = {0};

  int32_t iNumOfLargeChange = 0, iNumOfMediumChangeToLtr = 0;

  bool bIsClosestLtrFrame = false;
  int32_t ret = 1, iScdIdx = 0;

  SPicture* pRefPic = NULL;
  SRefInfoParam* pRefPicInfo = NULL;
  uint8_t*  pCurBlockStaticPointer = NULL;
  SLogContext* pLogCtx = & (pCtx->sLogCtx);
  const int32_t iNegligibleMotionBlocks = (static_cast<int32_t> ((pCurPicture->iWidthInPixel >> 3) *
                                          (pCurPicture->iHeightInPixel >> 3) * STATIC_SCENE_MOTION_RATIO));
  const uint8_t iCurTid = GetTemporalLevel (&pSvcParam->sDependencyLayers[m_pEncCtx->sSpatialIndexMap[0].iDid],
                          pParamInternal->iCodingIndex, pSvcParam->uiGopSize);
  if (iCurTid == INVALID_TEMPORAL_ID) {
    return LARGE_CHANGED_SCENE;
  }
  const int32_t iClosestLtrFrameNum = pCtx->pLtr[iTargetDid].iLastLtrIdx[iCurTid];
  if (pSvcParam->bEnableLongTermReference) {
    GetAvailableRefListLosslessScreenRefSelection (pRefPicList, iCurTid, iClosestLtrFrameNum, &sAvailableRefParam[0],
        iAvailableRefNum,
        iAvailableSceneRefNum);
  } else {
    GetAvailableRefList (pRefPicList, iCurTid, iClosestLtrFrameNum, &sAvailableRefParam[0], iAvailableRefNum,
                         iAvailableSceneRefNum);
  }
  //after this build, pAvailableRefList[idx].iSrcListIdx is the idx of the ref in h->spatial_pic
  if (0 == iAvailableRefNum) {
    WelsLog (pLogCtx, WELS_LOG_ERROR, "SceneChangeDetect() iAvailableRefNum=0 but not I.");
    return LARGE_CHANGED_SCENE;
  }

  InitPixMap (pCurPicture, &sSrcMap);
  InitRefJudgement (&sLtrJudgement);
  InitRefJudgement (&sSceneLtrJudgement);

  for (iScdIdx = 0; iScdIdx < iAvailableRefNum; iScdIdx ++) {
    pCurBlockStaticPointer = pVaaExt->pVaaBlockStaticIdc[iScdIdx];
    sSceneChangeResult.eSceneChangeIdc = SIMILAR_SCENE;
    sSceneChangeResult.pStaticBlockIdc = pCurBlockStaticPointer;
    sSceneChangeResult.sScrollResult.bScrollDetectFlag = false;

    pRefPicInfo = & (sAvailableRefParam[iScdIdx]);
    assert (NULL != pRefPicInfo);
    pRefPic = pRefPicInfo->pRefPicture;
    InitPixMap (pRefPic, &sRefMap);

    bIsClosestLtrFrame = (pRefPic->iLongTermPicNum == iClosestLtrFrameNum);
    if (0 == iScdIdx) {
      int32_t ret = 1;
      SScrollDetectionParam* pScrollDetectInfo = & (pVaaExt->sScrollDetectInfo);
      memset (pScrollDetectInfo, 0, sizeof (SScrollDetectionParam));

      int32_t iMethodIdx = METHOD_SCROLL_DETECTION;

      m_pInterfaceVp->Set (iMethodIdx, (void*) (pScrollDetectInfo));
      ret = m_pInterfaceVp->Process (iMethodIdx, &sSrcMap, &sRefMap);

      if (ret == 0) {
        m_pInterfaceVp->Get (iMethodIdx, (void*) (pScrollDetectInfo));
      }
      sSceneChangeResult.sScrollResult = pVaaExt->sScrollDetectInfo;
    }

    m_pInterfaceVp->Set (iSceneChangeMethodIdx, (void*) (&sSceneChangeResult));
    ret = m_pInterfaceVp->Process (iSceneChangeMethodIdx, &sSrcMap, &sRefMap);

    if (ret == 0) {
      m_pInterfaceVp->Get (iSceneChangeMethodIdx, (void*)&sSceneChangeResult);

      const int64_t iFrameComplexity = sSceneChangeResult.iFrameComplexity;
      const int32_t iSceneDetectIdc = sSceneChangeResult.eSceneChangeIdc;
      const int32_t iMotionBlockNum = sSceneChangeResult.iMotionBlockNum;

      const bool bCurRefIsSceneLtr = pRefPic->bIsSceneLTR;
      const int32_t iRefPicAvQP = pRefPic->iFrameAverageQp;

      //for scene change detection
      iNumOfLargeChange += (static_cast<int32_t> (LARGE_CHANGED_SCENE == iSceneDetectIdc));
      iNumOfMediumChangeToLtr += (static_cast<int32_t> ((bCurRefIsSceneLtr) && (iSceneDetectIdc != SIMILAR_SCENE)));

      //for reference selection
      //this judge can only be saved when iAvailableRefNum==1, which is very limit
      //when LTR is OFF, it can still judge from all available STR
      if (JudgeBestRef (pRefPic, sLtrJudgement, iFrameComplexity, bIsClosestLtrFrame)) {
        SaveBestRefToJudgement (iRefPicAvQP, iFrameComplexity, &sLtrJudgement);
        SaveBestRefToLocal (pRefPicInfo, sSceneChangeResult, &sLtrSaved);
      }
      if (bCurRefIsSceneLtr && JudgeBestRef (pRefPic, sSceneLtrJudgement, iFrameComplexity, bIsClosestLtrFrame)) {
        SaveBestRefToJudgement (iRefPicAvQP, iFrameComplexity, &sSceneLtrJudgement);
        SaveBestRefToLocal (pRefPicInfo, sSceneChangeResult, &sSceneLtrSaved);
      }

      if (iMotionBlockNum <= iNegligibleMotionBlocks) {
        break;
      }
    }
  }

  if (iNumOfLargeChange == iAvailableRefNum) {
    iVaaFrameSceneChangeIdc = LARGE_CHANGED_SCENE;
  } else if ((iNumOfMediumChangeToLtr == iAvailableSceneRefNum) && (0 != iAvailableSceneRefNum)) {
    iVaaFrameSceneChangeIdc = MEDIUM_CHANGED_SCENE;
  } else {
    iVaaFrameSceneChangeIdc = SIMILAR_SCENE;
  }

  WelsLog (pLogCtx, WELS_LOG_DEBUG, "iVaaFrameSceneChangeIdc = %d,codingIdx = %d", iVaaFrameSceneChangeIdc,
           pParamInternal->iCodingIndex);

  SaveBestRefToVaa (sLtrSaved, & (pVaaExt->sVaaStrBestRefCandidate[0]));
  pVaaExt->iVaaBestRefFrameNum = sLtrSaved.pRefPicture->iFrameNum;
  pVaaExt->pVaaBestBlockStaticIdc = sLtrSaved.pBestBlockStaticIdc;

  if (0 < iAvailableSceneRefNum) {
    SaveBestRefToVaa (sSceneLtrSaved, & (pVaaExt->sVaaLtrBestRefCandidate[0]));
  }

  pVaaExt->iNumOfAvailableRef = 1;
  return static_cast<ESceneChangeIdc> (iVaaFrameSceneChangeIdc);
}

int32_t CWelsPreProcess::GetRefFrameInfo (int32_t iRefIdx, bool bCurrentFrameIsSceneLtr, SPicture*& pRefOri) {
  const int32_t iTargetDid = m_pEncCtx->pSvcParam->iSpatialLayerNum - 1;
  SVAAFrameInfoExt* pVaaExt = static_cast<SVAAFrameInfoExt*> (m_pEncCtx->pVaa);
  SRefInfoParam* pBestRefCandidateParam = (bCurrentFrameIsSceneLtr) ? (& (pVaaExt->sVaaLtrBestRefCandidate[iRefIdx])) :
                                          (& (pVaaExt->sVaaStrBestRefCandidate[iRefIdx]));
  pRefOri = m_pSpatialPic[iTargetDid][pBestRefCandidateParam->iSrcListIdx];
  return (m_pSpatialPic[iTargetDid][pBestRefCandidateParam->iSrcListIdx]->iLongTermPicNum);
}
void  CWelsPreProcess::Padding (uint8_t* pSrcY, uint8_t* pSrcU, uint8_t* pSrcV, int32_t iStrideY, int32_t iStrideUV,
                                int32_t iActualWidth, int32_t iPaddingWidth, int32_t iActualHeight, int32_t iPaddingHeight) {
  int32_t i;

  if (iPaddingHeight > iActualHeight) {
    for (i = iActualHeight; i < iPaddingHeight; i++) {
      memset (pSrcY + i * iStrideY, 0, iActualWidth);

      if (! (i & 1)) {
        memset (pSrcU + i / 2 * iStrideUV, 0x80, iActualWidth / 2);
        memset (pSrcV + i / 2 * iStrideUV, 0x80, iActualWidth / 2);
      }
    }
  }

  if (iPaddingWidth > iActualWidth) {
    for (i = 0; i < iPaddingHeight; i++) {
      memset (pSrcY + i * iStrideY + iActualWidth, 0, iPaddingWidth - iActualWidth);
      if (! (i & 1)) {
        memset (pSrcU + i / 2 * iStrideUV + iActualWidth / 2, 0x80, (iPaddingWidth - iActualWidth) / 2);
        memset (pSrcV + i / 2 * iStrideUV + iActualWidth / 2, 0x80, (iPaddingWidth - iActualWidth) / 2);
      }
    }
  }
}


int32_t CWelsPreProcess::UpdateBlockIdcForScreen (uint8_t*  pCurBlockStaticPointer, const SPicture* kpRefPic,
    const SPicture* kpSrcPic) {
  int32_t iSceneChangeMethodIdx = METHOD_SCENE_CHANGE_DETECTION_SCREEN;
  SSceneChangeResult sSceneChangeResult = {SIMILAR_SCENE, 0, 0, NULL};
  sSceneChangeResult.pStaticBlockIdc = pCurBlockStaticPointer;
  sSceneChangeResult.sScrollResult.bScrollDetectFlag = false;

  SPixMap sSrcMap = { { 0 } };
  SPixMap sRefMap = { { 0 } };
  InitPixMap (kpSrcPic, &sSrcMap);
  InitPixMap (kpRefPic, &sRefMap);

  m_pInterfaceVp->Set (iSceneChangeMethodIdx, (void*) (&sSceneChangeResult));
  int32_t iRet = m_pInterfaceVp->Process (iSceneChangeMethodIdx, &sSrcMap, &sRefMap);
  if (iRet == 0) {
    m_pInterfaceVp->Get (iSceneChangeMethodIdx, (void*)&sSceneChangeResult);
    return 0;
  }
  return iRet;
}

/*!
* \brief    exchange two picture pData planes
* \param    ppPic1      picture pointer to picture 1
* \param    ppPic2      picture pointer to picture 2
* \return   none
*/
void CWelsPreProcess::WelsExchangeSpatialPictures (SPicture** ppPic1, SPicture** ppPic2) {
  SPicture* tmp = *ppPic1;

  assert (*ppPic1 != *ppPic2);

  *ppPic1 = *ppPic2;
  *ppPic2 = tmp;
}

void CWelsPreProcess::UpdateSrcListLosslessScreenRefSelectionWithLtr (SPicture* pCurPicture, const int32_t kiCurDid,
    const int32_t kuiMarkLongTermPicIdx, SPicture** pLongRefList) {
  SPicture** pLongRefSrcList = &m_pSpatialPic[kiCurDid][0];
  for (int32_t i = 0; i < MAX_REF_PIC_COUNT; ++i) {
    if (NULL == pLongRefSrcList[i + 1] || (NULL != pLongRefList[i] && pLongRefList[i]->bUsedAsRef
                                           && pLongRefList[i]->bIsLongRef)) {
      continue;
    } else {
      pLongRefSrcList[i + 1]->SetUnref();
    }
  }
  WelsExchangeSpatialPictures (&m_pSpatialPic[kiCurDid][0],
                               &m_pSpatialPic[kiCurDid][1 + kuiMarkLongTermPicIdx]);
  m_iAvaliableRefInSpatialPicList = MAX_REF_PIC_COUNT;
  (GetCurrentOrigFrame (kiCurDid))->SetUnref();
}
void CWelsPreProcess::UpdateSrcList (SPicture* pCurPicture, const int32_t kiCurDid, SPicture** pShortRefList,
                                     const uint32_t kuiShortRefCount) {
  SPicture** pRefSrcList = &m_pSpatialPic[kiCurDid][0];

  //pRefSrcList[0] is for current frame
  if (pCurPicture->bUsedAsRef || pCurPicture->bIsLongRef) {
    if (pCurPicture->iPictureType == P_SLICE && pCurPicture->uiTemporalId != 0) {
      for (int iRefIdx = kuiShortRefCount - 1; iRefIdx >= 0; --iRefIdx) {
        WelsExchangeSpatialPictures (&pRefSrcList[iRefIdx + 1],
                                     &pRefSrcList[iRefIdx]);
      }
      m_iAvaliableRefInSpatialPicList = kuiShortRefCount;
    } else {
      WelsExchangeSpatialPictures (&pRefSrcList[0], &pRefSrcList[1]);
      for (int32_t i = MAX_SHORT_REF_COUNT - 1; i > 0  ; --i) {
        if (pRefSrcList[i + 1] != NULL) {
          pRefSrcList[i + 1]->SetUnref();
        }
      }
      m_iAvaliableRefInSpatialPicList = 1;
    }
  }
  (GetCurrentOrigFrame (kiCurDid))->SetUnref();
}

//TODO: may opti later
//TODO: not use this func?
void* WelsMemcpy (void* dst, const void* kpSrc, uint32_t uiSize) {
  return ::memcpy (dst, kpSrc, uiSize);
}
void* WelsMemset (void* p, int32_t val, uint32_t uiSize) {
  return ::memset (p, val, uiSize);
}

//i420_to_i420_c
void  WelsMoveMemory_c (uint8_t* pDstY, uint8_t* pDstU, uint8_t* pDstV,  int32_t iDstStrideY, int32_t iDstStrideUV,
                        uint8_t* pSrcY, uint8_t* pSrcU, uint8_t* pSrcV, int32_t iSrcStrideY, int32_t iSrcStrideUV, int32_t iWidth,
                        int32_t iHeight) {
  int32_t   iWidth2 = iWidth >> 1;
  int32_t   iHeight2 = iHeight >> 1;
  int32_t   j;

  for (j = iHeight; j; j--) {
    WelsMemcpy (pDstY, pSrcY, iWidth);
    pDstY += iDstStrideY;
    pSrcY += iSrcStrideY;
  }

  for (j = iHeight2; j; j--) {
    WelsMemcpy (pDstU, pSrcU, iWidth2);
    WelsMemcpy (pDstV, pSrcV, iWidth2);
    pDstU += iDstStrideUV;
    pDstV += iDstStrideUV;
    pSrcU += iSrcStrideUV;
    pSrcV += iSrcStrideUV;
  }
}

void  CWelsPreProcess::WelsMoveMemoryWrapper (SWelsSvcCodingParam* pSvcParam, SPicture* pDstPic,
    const SSourcePicture* kpSrc,
    const int32_t kiTargetWidth, const int32_t kiTargetHeight) {
  if (VIDEO_FORMAT_I420 != (kpSrc->iColorFormat & (~VIDEO_FORMAT_VFlip)))
    return;

  int32_t  iSrcWidth       = kpSrc->iPicWidth;
  int32_t  iSrcHeight      = kpSrc->iPicHeight;

  if (iSrcHeight > kiTargetHeight) iSrcHeight = kiTargetHeight;
  if (iSrcWidth > kiTargetWidth)   iSrcWidth  = kiTargetWidth;

  // copy from fr26 to fix the odd uiSize failed issue
  if (iSrcWidth & 0x1)  -- iSrcWidth;
  if (iSrcHeight & 0x1) -- iSrcHeight;

  const int32_t kiSrcTopOffsetY = pSvcParam->SUsedPicRect.iTop;
  const int32_t kiSrcTopOffsetUV = (kiSrcTopOffsetY >> 1);
  const int32_t kiSrcLeftOffsetY = pSvcParam->SUsedPicRect.iLeft;
  const int32_t kiSrcLeftOffsetUV = (kiSrcLeftOffsetY >> 1);
  int32_t  iSrcOffset[3]       = {0, 0, 0};
  iSrcOffset[0] = kpSrc->iStride[0] * kiSrcTopOffsetY + kiSrcLeftOffsetY;
  iSrcOffset[1] = kpSrc->iStride[1] * kiSrcTopOffsetUV + kiSrcLeftOffsetUV ;
  iSrcOffset[2] = kpSrc->iStride[2] * kiSrcTopOffsetUV + kiSrcLeftOffsetUV;

  uint8_t* pSrcY = kpSrc->pData[0] + iSrcOffset[0];
  uint8_t* pSrcU = kpSrc->pData[1] + iSrcOffset[1];
  uint8_t* pSrcV = kpSrc->pData[2] + iSrcOffset[2];
  const int32_t kiSrcStrideY = kpSrc->iStride[0];
  const int32_t kiSrcStrideUV = kpSrc->iStride[1];

  uint8_t* pDstY = pDstPic->pData[0];
  uint8_t* pDstU = pDstPic->pData[1];
  uint8_t* pDstV = pDstPic->pData[2];
  const int32_t kiDstStrideY = pDstPic->iLineSize[0];
  const int32_t kiDstStrideUV = pDstPic->iLineSize[1];

  if (pSrcY) {
    if (iSrcWidth <= 0 || iSrcHeight <= 0 || (iSrcWidth * iSrcHeight > (MAX_MBS_PER_FRAME << 8)))
      return;
    if (kiSrcTopOffsetY >= iSrcHeight || kiSrcLeftOffsetY >= iSrcWidth || iSrcWidth > kiSrcStrideY)
      return;
  }
  if (pDstY) {
    if (kiTargetWidth <= 0 || kiTargetHeight <= 0 || (kiTargetWidth * kiTargetHeight > (MAX_MBS_PER_FRAME << 8)))
      return;
    if (kiTargetWidth > kiDstStrideY)
      return;
  }

  if (pSrcY == NULL || pSrcU == NULL || pSrcV == NULL || pDstY == NULL || pDstU == NULL || pDstV == NULL
      || (iSrcWidth & 1) || (iSrcHeight & 1)) {
  } else {
    //i420_to_i420_c
    WelsMoveMemory_c (pDstY,  pDstU,  pDstV,  kiDstStrideY, kiDstStrideUV,
                      pSrcY,  pSrcU,  pSrcV, kiSrcStrideY, kiSrcStrideUV, iSrcWidth, iSrcHeight);

    //in VP Process
    if (kiTargetWidth > iSrcWidth || kiTargetHeight > iSrcHeight) {
      Padding (pDstY, pDstU, pDstV, kiDstStrideY, kiDstStrideUV, iSrcWidth, kiTargetWidth, iSrcHeight, kiTargetHeight);
    }
  }

}

bool CWelsPreProcess::GetSceneChangeFlag (ESceneChangeIdc eSceneChangeIdc) {
  return ((eSceneChangeIdc == LARGE_CHANGED_SCENE) ? true : false);
}


//*********************************************************************************************************/
} // namespace WelsEnc