static Ipp32s
sbrencDiffEst(Ipp32f* bufT, Ipp32f* bufDiff, Ipp32s* indxMapTab, Ipp32s* pFreqTab, Ipp32s nBand)
{
Ipp32s m, k, idx, kStart, kEnd;
Ipp32f maxOrigT, maxSbrT;
for(m = 0; m < nBand; m++){
kStart = pFreqTab[m];
kEnd = pFreqTab[m+1];
maxOrigT = maxSbrT = 0.0f;
for(k = kStart; k < kEnd; k++){
maxOrigT = ( bufT[k] > maxOrigT ) ? bufT[k] : maxOrigT;
idx = indxMapTab[k];
if ( idx != EMPTY_MAPPING ){
maxSbrT = ( bufT[ idx ] > maxSbrT ) ? bufT[ idx ] : maxSbrT;
}
}
maxSbrT = IPP_MAX( 1.0f, maxSbrT );
bufDiff[m] = maxOrigT;
if ( maxSbrT > 1.0f ){
bufDiff[m] /= maxSbrT;
}
}
return 0;//OK
}
static inline int ippiSuggestThreadsNum(size_t width, size_t height, size_t elemSize, double multiplier)
{
int threads = cv::getNumThreads();
if(threads > 1 && height >= 64)
{
size_t opMemory = (int)(width*height*elemSize*multiplier);
int l2cache = 0;
#if IPP_VERSION_X100 >= 201700
ippGetL2CacheSize(&l2cache);
#endif
if(!l2cache)
l2cache = 1 << 18;
return IPP_MAX(1, (IPP_MIN((int)(opMemory/l2cache), threads)));
}
return 1;
}
static Ipp32s
sbrencDetectionSinEst(Ipp32f* bufT,
Ipp32f* bufDiff,
Ipp32s* detVec,
Ipp32s* pFreqTab,
Ipp32s nBand,
Ipp32f* bufSfmOrig,
Ipp32f* bufSfmSBR,
sSBRGuideData guideState,
sSBRGuideData guideNewState)
{
Ipp32f tmpThres = 0.f, origThres = 0.f;
Ipp32s criterion1 = 0, criterion2 = 0, criterion3 = 0;
Ipp32s iStart = 0, iEnd = 0;
Ipp32s band = 0;
Ipp32s i = 0;
/* ******************************
* detection algorithm: step 1
* ****************************** */
for(band = 0; band < nBand; band++){
if (guideState.bufGuideDiff[band]) {
tmpThres = IPP_MAX(DECAY_GUIDE_DIFF*guideState.bufGuideDiff[band],THR_DIFF_GUIDE);
} else {
tmpThres = THR_DIFF;
}
tmpThres = IPP_MIN(tmpThres, THR_DIFF);
if(bufDiff[band] > tmpThres){
detVec[band] = 1;
guideNewState.bufGuideDiff[band] = bufDiff[band];
} else {
if(guideState.bufGuideDiff[band]){
guideState.bufGuideOrig[band] = THR_TONE_GUIDE;
}
}
}
/* ******************************
* detection algorithm: step 2
* ****************************** */
for(band = 0; band < nBand; band++){
iStart = pFreqTab[band];
iEnd = pFreqTab[band+1];
origThres = IPP_MAX(guideState.bufGuideOrig[band] * DECAY_GUIDE_ORIG, THR_TONE_GUIDE );
origThres = IPP_MIN(origThres, THR_TONE);
if(guideState.bufGuideOrig[band]){
for(i = iStart; i < iEnd; i++){
if(bufT[i] > origThres){
detVec[band] = 1;
guideNewState.bufGuideOrig[band] = bufT[i];
}
}
}
}
/* ******************************
* detection algorithm: step 3
* ****************************** */
origThres = THR_TONE;
for(band = 0; band < nBand; band++){
iStart = pFreqTab[band];
iEnd = pFreqTab[band+1];
if(iEnd -iStart > 1){
for(i = iStart; i < iEnd; i++){
/* get criterion */
criterion1 = (bufT[i] > origThres) ? 1 : 0;
criterion2 = (bufSfmSBR[band] > THR_SFM_SBR ) ? 1 : 0;
criterion3 = (bufSfmOrig[band] < THR_SFM_ORIG) ? 1 : 0;
if(criterion1 && criterion2 && criterion3){
detVec[band] = 1;
guideNewState.bufGuideOrig[band] = bufT[i];
}
}
} else {
if(band < nBand -1){
//iStart = pFreqTab[band];
criterion1 = (bufT[iStart] > THR_TONE ) ? 1 : 0;
if(band){
criterion2 = (bufDiff[+1] < INV_THR_TONE ) ? 1 : 0;
criterion3 = (bufDiff[band-1] < INV_THR_TONE ) ? 1 : 0;
if(criterion1 && ( criterion2 || criterion3) ){
detVec[band] = 1;
guideNewState.bufGuideOrig[band] = bufT[iStart];
}
} else {
criterion2 = (bufDiff[band+1] < INV_THR_TONE) ? 1 : 0;
if(criterion1 && criterion2){
detVec[band] = 1;
guideNewState.bufGuideOrig[band] = bufT[iStart];
}
}
}
}
}
return 0;//OK
}
IppStatus ownPredictCoef_SBR_R_32f_D2L(Ipp32f **pSrc, Ipp32f *pAlpha0,
Ipp32f *pAlpha1, Ipp32f *pReflectCoef,
Ipp32s k0, Ipp32s len) {
Ipp32f fi[3][3];
const Ipp32s TIME_HF_ADJ = 2;
Ipp32s i, j, k, n;
const Ipp32f rel = 1.f / (1.f + 1e-6f);
Ipp32f d;
Ipp32f** ppX = pSrc + TIME_HF_ADJ;
for (k = 0; k < k0; k++) {
fi[0][0] = fi[0][1] = fi[0][2] = fi[1][0] = fi[1][1] = fi[1][2] = fi[2][0] =
fi[2][1] = fi[2][2] = 0.f;
/*
* auto correlation
*/
for (n = 0; n < len; n++) {
i = 0;
j = 1;
fi[0][1] += ppX[n - i][k] * ppX[n - j][k];
i = 0;
j = 2;
fi[0][2] += ppX[n - i][k] * ppX[n - j][k];
i = 1;
j = 1;
fi[1][1] += ppX[n - i][k] * ppX[n - j][k];
i = 1;
j = 2;
fi[1][2] += ppX[n - i][k] * ppX[n - j][k];
i = 2;
j = 2;
fi[2][2] += ppX[n - i][k] * ppX[n - j][k];
}
d = fi[1][1] * fi[2][2] - rel * fi[1][2] * fi[1][2];
/*
* pAlpha1
*/
if ((Ipp64f)d * d > 0.f) { /* if (d != 0) */
pAlpha1[k] = (fi[0][1] * fi[1][2] - fi[0][2] * fi[1][1]) * (1.f / d);
} else {
pAlpha1[k] = 0.f;
}
/*
* pAlpha0
*/
if (fi[1][1] > 0.f) { /* if (fi[1][1] != 0) */
pAlpha0[k] = -(fi[0][1] + pAlpha1[k] * fi[1][2]) * (1.f / fi[1][1]);
} else {
pAlpha0[k] = 0.f;
}
if (((pAlpha1[k] * pAlpha1[k]) >= 16.f) ||
((pAlpha0[k] * pAlpha0[k]) >= 16.f)) {
pAlpha1[k] = pAlpha0[k] = 0.f;
}
if (fi[1][1] == 0.0f) {
pReflectCoef[k] = 0.0f;
} else {
pReflectCoef[k] = IPP_MIN(IPP_MAX(-fi[0][1] / fi[1][1], -1), 1);
}
}
return ippStsNoErr;
}
bool H264Slice::Reset(void *pSource, size_t nSourceSize, Ipp32s iConsumerNumber)
{
Ipp32s iMBInFrame;
Ipp32s iFieldIndex;
m_BitStream.Reset((Ipp8u *) pSource, (Ipp32u) nSourceSize);
// decode slice header
if (nSourceSize && false == DecodeSliceHeader())
return false;
m_iMBWidth = GetSeqParam()->frame_width_in_mbs;
m_iMBHeight = GetSeqParam()->frame_height_in_mbs;
iMBInFrame = (m_iMBWidth * m_iMBHeight) / ((m_SliceHeader.field_pic_flag) ? (2) : (1));
iFieldIndex = (m_SliceHeader.field_pic_flag && m_SliceHeader.bottom_field_flag) ? (1) : (0);
// set slice variables
m_iFirstMB = m_SliceHeader.first_mb_in_slice;
m_iMaxMB = iMBInFrame;
m_iFirstMBFld = m_SliceHeader.first_mb_in_slice + iMBInFrame * iFieldIndex;
m_iAvailableMB = iMBInFrame;
if (m_iFirstMB >= m_iAvailableMB)
return false;
// reset all internal variables
m_iCurMBToDec = m_iFirstMB;
m_iCurMBToRec = m_iFirstMB;
m_iCurMBToDeb = m_iFirstMB;
m_bInProcess = false;
m_bDecVacant = 1;
m_bRecVacant = 1;
m_bDebVacant = 1;
m_bFirstDebThreadedCall = true;
m_bError = false;
m_MVsDistortion = 0;
// reallocate internal buffer
if (false == IsSliceGroups() && iConsumerNumber > 1)
{
Ipp32s iMBRowSize = GetMBRowWidth();
Ipp32s iMBRowBuffers;
Ipp32s bit_depth_luma, bit_depth_chroma;
if (m_SliceHeader.is_auxiliary)
{
bit_depth_luma = GetSeqParamEx()->bit_depth_aux;
bit_depth_chroma = 8;
} else {
bit_depth_luma = GetSeqParam()->bit_depth_luma;
bit_depth_chroma = GetSeqParam()->bit_depth_chroma;
}
Ipp32s isU16Mode = (bit_depth_luma > 8 || bit_depth_chroma > 8) ? 2 : 1;
// decide number of buffers
iMBRowBuffers = IPP_MAX(MINIMUM_NUMBER_OF_ROWS, MB_BUFFER_SIZE / iMBRowSize);
iMBRowBuffers = IPP_MIN(MAXIMUM_NUMBER_OF_ROWS, iMBRowBuffers);
m_CoeffsBuffers.Init(iMBRowBuffers, (Ipp32s)sizeof(Ipp16s) * isU16Mode * (iMBRowSize * COEFFICIENTS_BUFFER_SIZE + DEFAULT_ALIGN_VALUE));
}
m_CoeffsBuffers.Reset();
// reset through-decoding variables
m_nMBSkipCount = 0;
m_nQuantPrev = m_pPicParamSet->pic_init_qp +
m_SliceHeader.slice_qp_delta;
m_prev_dquant = 0;
m_field_index = iFieldIndex;
if (IsSliceGroups())
m_bNeedToCheckMBSliceEdges = true;
else
m_bNeedToCheckMBSliceEdges = (0 == m_SliceHeader.first_mb_in_slice) ? (false) : (true);
// set conditional flags
m_bDecoded = false;
m_bPrevDeblocked = false;
m_bDeblocked = (m_SliceHeader.disable_deblocking_filter_idc == DEBLOCK_FILTER_OFF);
if (m_bDeblocked)
{
m_bDebVacant = 0;
m_iCurMBToDeb = m_iMaxMB;
}
// frame is not associated yet
m_pCurrentFrame = NULL;
return true;
} // bool H264Slice::Reset(void *pSource, size_t nSourceSize, Ipp32s iNumber)
