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)