ae60f1bee9
Fix several -Werror=unused-variable and -Werror=unused-but-set-variable and removed dead code found with this warnings
272 lines
9.3 KiB
C++
272 lines
9.3 KiB
C++
/*!
|
|
* \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 "ComplexityAnalysis.h"
|
|
|
|
WELSVP_NAMESPACE_BEGIN
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CComplexityAnalysis::CComplexityAnalysis (int32_t iCpuFlag) {
|
|
m_eMethod = METHOD_COMPLEXITY_ANALYSIS;
|
|
m_pfGomSad = NULL;
|
|
WelsMemset (&m_sComplexityAnalysisParam, 0, sizeof (m_sComplexityAnalysisParam));
|
|
}
|
|
|
|
CComplexityAnalysis::~CComplexityAnalysis() {
|
|
}
|
|
|
|
EResult CComplexityAnalysis::Process (int32_t iType, SPixMap* pSrcPixMap, SPixMap* pRefPixMap) {
|
|
EResult eReturn = RET_SUCCESS;
|
|
|
|
switch (m_sComplexityAnalysisParam.iComplexityAnalysisMode) {
|
|
case FRAME_SAD:
|
|
AnalyzeFrameComplexityViaSad (pSrcPixMap, pRefPixMap);
|
|
break;
|
|
case GOM_SAD:
|
|
AnalyzeGomComplexityViaSad (pSrcPixMap, pRefPixMap);
|
|
break;
|
|
case GOM_VAR:
|
|
AnalyzeGomComplexityViaVar (pSrcPixMap, pRefPixMap);
|
|
break;
|
|
default:
|
|
eReturn = RET_INVALIDPARAM;
|
|
break;
|
|
}
|
|
|
|
return eReturn;
|
|
}
|
|
|
|
|
|
EResult CComplexityAnalysis::Set (int32_t iType, void* pParam) {
|
|
if (pParam == NULL) {
|
|
return RET_INVALIDPARAM;
|
|
}
|
|
|
|
m_sComplexityAnalysisParam = * (SComplexityAnalysisParam*)pParam;
|
|
|
|
return RET_SUCCESS;
|
|
}
|
|
|
|
EResult CComplexityAnalysis::Get (int32_t iType, void* pParam) {
|
|
if (pParam == NULL) {
|
|
return RET_INVALIDPARAM;
|
|
}
|
|
|
|
SComplexityAnalysisParam* sComplexityAnalysisParam = (SComplexityAnalysisParam*)pParam;
|
|
|
|
sComplexityAnalysisParam->iFrameComplexity = m_sComplexityAnalysisParam.iFrameComplexity;
|
|
|
|
return RET_SUCCESS;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CComplexityAnalysis::AnalyzeFrameComplexityViaSad (SPixMap* pSrcPixMap, SPixMap* pRefPixMap) {
|
|
SVAACalcResult* pVaaCalcResults = NULL;
|
|
pVaaCalcResults = m_sComplexityAnalysisParam.pCalcResult;
|
|
|
|
m_sComplexityAnalysisParam.iFrameComplexity = pVaaCalcResults->iFrameSad;
|
|
|
|
if (m_sComplexityAnalysisParam.iCalcBgd) { //BGD control
|
|
m_sComplexityAnalysisParam.iFrameComplexity = (int32_t)GetFrameSadExcludeBackground (pSrcPixMap, pRefPixMap);
|
|
}
|
|
}
|
|
|
|
int32_t CComplexityAnalysis::GetFrameSadExcludeBackground (SPixMap* pSrcPixMap, SPixMap* pRefPixMap) {
|
|
int32_t iWidth = pSrcPixMap->sRect.iRectWidth;
|
|
int32_t iHeight = pSrcPixMap->sRect.iRectHeight;
|
|
int32_t iMbWidth = iWidth >> 4;
|
|
int32_t iMbHeight = iHeight >> 4;
|
|
int32_t iMbNum = iMbWidth * iMbHeight;
|
|
|
|
int32_t iMbNumInGom = m_sComplexityAnalysisParam.iMbNumInGom;
|
|
int32_t iGomMbNum = (iMbNum + iMbNumInGom - 1) / iMbNumInGom;
|
|
int32_t iGomMbStartIndex = 0, iGomMbEndIndex = 0;
|
|
|
|
uint8_t* pBackgroundMbFlag = (uint8_t*)m_sComplexityAnalysisParam.pBackgroundMbFlag;
|
|
uint32_t* uiRefMbType = (uint32_t*)m_sComplexityAnalysisParam.uiRefMbType;
|
|
SVAACalcResult* pVaaCalcResults = m_sComplexityAnalysisParam.pCalcResult;
|
|
int32_t* pGomForegroundBlockNum = m_sComplexityAnalysisParam.pGomForegroundBlockNum;
|
|
|
|
uint32_t uiFrameSad = 0;
|
|
for (int32_t j = 0; j < iGomMbNum; j ++) {
|
|
iGomMbStartIndex = j * iMbNumInGom;
|
|
iGomMbEndIndex = WELS_MIN ((j + 1) * iMbNumInGom, iMbNum);
|
|
|
|
for (int32_t i = iGomMbStartIndex; i < iGomMbEndIndex; i ++) {
|
|
if (pBackgroundMbFlag[i] == 0 || IS_INTRA (uiRefMbType[i])) {
|
|
pGomForegroundBlockNum[j]++;
|
|
uiFrameSad += pVaaCalcResults->pSad8x8[i][0];
|
|
uiFrameSad += pVaaCalcResults->pSad8x8[i][1];
|
|
uiFrameSad += pVaaCalcResults->pSad8x8[i][2];
|
|
uiFrameSad += pVaaCalcResults->pSad8x8[i][3];
|
|
}
|
|
}
|
|
}
|
|
|
|
return (uiFrameSad);
|
|
}
|
|
|
|
|
|
void InitGomSadFunc (PGOMSadFunc& pfGomSad, uint8_t iCalcBgd) {
|
|
pfGomSad = GomSampleSad;
|
|
|
|
if (iCalcBgd) {
|
|
pfGomSad = GomSampleSadExceptBackground;
|
|
}
|
|
}
|
|
|
|
void GomSampleSad (uint32_t* pGomSad, int32_t* pGomForegroundBlockNum, int32_t* pSad8x8, uint8_t pBackgroundMbFlag) {
|
|
(*pGomForegroundBlockNum) ++;
|
|
*pGomSad += pSad8x8[0];
|
|
*pGomSad += pSad8x8[1];
|
|
*pGomSad += pSad8x8[2];
|
|
*pGomSad += pSad8x8[3];
|
|
}
|
|
|
|
void GomSampleSadExceptBackground (uint32_t* pGomSad, int32_t* pGomForegroundBlockNum, int32_t* pSad8x8,
|
|
uint8_t pBackgroundMbFlag) {
|
|
if (pBackgroundMbFlag == 0) {
|
|
(*pGomForegroundBlockNum) ++;
|
|
*pGomSad += pSad8x8[0];
|
|
*pGomSad += pSad8x8[1];
|
|
*pGomSad += pSad8x8[2];
|
|
*pGomSad += pSad8x8[3];
|
|
}
|
|
}
|
|
|
|
void CComplexityAnalysis::AnalyzeGomComplexityViaSad (SPixMap* pSrcPixMap, SPixMap* pRefPixMap) {
|
|
int32_t iWidth = pSrcPixMap->sRect.iRectWidth;
|
|
int32_t iHeight = pSrcPixMap->sRect.iRectHeight;
|
|
int32_t iMbWidth = iWidth >> 4;
|
|
int32_t iMbHeight = iHeight >> 4;
|
|
int32_t iMbNum = iMbWidth * iMbHeight;
|
|
|
|
int32_t iMbNumInGom = m_sComplexityAnalysisParam.iMbNumInGom;
|
|
int32_t iGomMbNum = (iMbNum + iMbNumInGom - 1) / iMbNumInGom;
|
|
|
|
int32_t iGomMbStartIndex = 0, iGomMbEndIndex = 0, iGomMbRowNum = 0;
|
|
int32_t iMbStartIndex = 0, iMbEndIndex = 0;
|
|
|
|
uint8_t* pBackgroundMbFlag = (uint8_t*)m_sComplexityAnalysisParam.pBackgroundMbFlag;
|
|
uint32_t* uiRefMbType = (uint32_t*)m_sComplexityAnalysisParam.uiRefMbType;
|
|
SVAACalcResult* pVaaCalcResults = m_sComplexityAnalysisParam.pCalcResult;
|
|
int32_t* pGomForegroundBlockNum = (int32_t*)m_sComplexityAnalysisParam.pGomForegroundBlockNum;
|
|
int32_t* pGomComplexity = (int32_t*)m_sComplexityAnalysisParam.pGomComplexity;
|
|
|
|
|
|
uint32_t uiGomSad = 0, uiFrameSad = 0;
|
|
|
|
InitGomSadFunc (m_pfGomSad, m_sComplexityAnalysisParam.iCalcBgd);
|
|
|
|
for (int32_t j = 0; j < iGomMbNum; j ++) {
|
|
uiGomSad = 0;
|
|
|
|
iGomMbStartIndex = j * iMbNumInGom;
|
|
iGomMbEndIndex = WELS_MIN ((j + 1) * iMbNumInGom, iMbNum);
|
|
iGomMbRowNum = (iGomMbEndIndex + iMbWidth - 1) / iMbWidth - iGomMbStartIndex / iMbWidth;
|
|
|
|
iMbStartIndex = iGomMbStartIndex;
|
|
iMbEndIndex = WELS_MIN ((iMbStartIndex / iMbWidth + 1) * iMbWidth, iGomMbEndIndex);
|
|
|
|
do {
|
|
for (int32_t i = iMbStartIndex; i < iMbEndIndex; i ++) {
|
|
m_pfGomSad (&uiGomSad, pGomForegroundBlockNum + j, pVaaCalcResults->pSad8x8[i], pBackgroundMbFlag[i]
|
|
&& !IS_INTRA (uiRefMbType[i]));
|
|
}
|
|
|
|
iMbStartIndex = iMbEndIndex;
|
|
iMbEndIndex = WELS_MIN (iMbEndIndex + iMbWidth , iGomMbEndIndex);
|
|
|
|
} while (--iGomMbRowNum);
|
|
|
|
pGomComplexity[j] = uiGomSad;
|
|
uiFrameSad += pGomComplexity[j];
|
|
}
|
|
|
|
m_sComplexityAnalysisParam.iFrameComplexity = uiFrameSad;
|
|
}
|
|
|
|
|
|
void CComplexityAnalysis::AnalyzeGomComplexityViaVar (SPixMap* pSrcPixMap, SPixMap* pRefPixMap) {
|
|
int32_t iWidth = pSrcPixMap->sRect.iRectWidth;
|
|
int32_t iHeight = pSrcPixMap->sRect.iRectHeight;
|
|
int32_t iMbWidth = iWidth >> 4;
|
|
int32_t iMbHeight = iHeight >> 4;
|
|
int32_t iMbNum = iMbWidth * iMbHeight;
|
|
|
|
int32_t iMbNumInGom = m_sComplexityAnalysisParam.iMbNumInGom;
|
|
int32_t iGomMbNum = (iMbNum + iMbNumInGom - 1) / iMbNumInGom;
|
|
int32_t iGomSampleNum = 0;
|
|
|
|
int32_t iGomMbStartIndex = 0, iGomMbEndIndex = 0, iGomMbRowNum = 0;
|
|
int32_t iMbStartIndex = 0, iMbEndIndex = 0;
|
|
|
|
SVAACalcResult* pVaaCalcResults = m_sComplexityAnalysisParam.pCalcResult;
|
|
int32_t* pGomComplexity = (int32_t*)m_sComplexityAnalysisParam.pGomComplexity;
|
|
|
|
|
|
uint32_t uiSampleSum = 0, uiSquareSum = 0;
|
|
|
|
for (int32_t j = 0; j < iGomMbNum; j ++) {
|
|
uiSampleSum = 0;
|
|
uiSquareSum = 0;
|
|
|
|
iGomMbStartIndex = j * iMbNumInGom;
|
|
iGomMbEndIndex = WELS_MIN ((j + 1) * iMbNumInGom, iMbNum);
|
|
iGomMbRowNum = (iGomMbEndIndex + iMbWidth - 1) / iMbWidth - iGomMbStartIndex / iMbWidth;
|
|
|
|
iMbStartIndex = iGomMbStartIndex;
|
|
iMbEndIndex = WELS_MIN ((iMbStartIndex / iMbWidth + 1) * iMbWidth, iGomMbEndIndex);
|
|
|
|
iGomSampleNum = (iMbEndIndex - iMbStartIndex) * MB_WIDTH_LUMA * MB_WIDTH_LUMA;
|
|
|
|
do {
|
|
for (int32_t i = iMbStartIndex; i < iMbEndIndex; i ++) {
|
|
uiSampleSum += pVaaCalcResults->pSum16x16[i];
|
|
uiSquareSum += pVaaCalcResults->pSumOfSquare16x16[i];
|
|
}
|
|
|
|
iMbStartIndex = iMbEndIndex;
|
|
iMbEndIndex = WELS_MIN (iMbEndIndex + iMbWidth, iGomMbEndIndex);
|
|
|
|
} while (--iGomMbRowNum);
|
|
|
|
pGomComplexity[j] = uiSquareSum - (uiSampleSum * uiSampleSum / iGomSampleNum);
|
|
}
|
|
}
|
|
|
|
|
|
WELSVP_NAMESPACE_END
|