Lines Matching refs:inst
164 // if (gain <= inst->denoiseBound) {
165 // factor2 = 1.0 - 0.3 * (blim - inst->denoiseBound);
238 // sum of log2(i) from table index to inst->anaLen2 in Q5
252 // sum of log2(i)^2 from table index to inst->anaLen2 in Q2
303 static void UpdateNoiseEstimate(NoiseSuppressionFixedC* inst, int offset) {
311 tmp16 = WebRtcSpl_MaxValueW16(inst->noiseEstLogQuantile + offset,
312 inst->magnLen);
314 inst->qNoise = 14 - (int) WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(
316 for (i = 0; i < inst->magnLen; i++) {
317 // inst->quantile[i]=exp(inst->lquantile[offset+i]);
319 tmp32no2 = kExp2Const * inst->noiseEstLogQuantile[offset + i];
323 tmp16 += (int16_t) inst->qNoise; //shift to get result in Q(qNoise)
329 inst->noiseEstQuantile[i] = WebRtcSpl_SatW32ToW16(tmp32no1);
334 static void NoiseEstimationC(NoiseSuppressionFixedC* inst,
346 tabind = inst->stages - inst->normData;
359 for (i = 0; i < inst->magnLen; i++) {
379 offset = s * inst->magnLen;
382 counter = inst->noiseEstCounter[s];
388 for (i = 0; i < inst->magnLen; i++) {
390 if (inst->noiseEstDensity[offset + i] > 512) {
392 int factor = WebRtcSpl_NormW16(inst->noiseEstDensity[offset + i]);
396 if (inst->blockIndex < END_STARTUP_LONG) {
405 if (lmagn[i] > inst->noiseEstLogQuantile[offset + i]) {
406 // +=QUANTILE*delta/(inst->counter[s]+1) QUANTILE=0.25, =1 in Q2
407 // CounterDiv=1/(inst->counter[s]+1) in Q15
409 inst->noiseEstLogQuantile[offset + i] += tmp16 / 4;
415 inst->noiseEstLogQuantile[offset + i] -= tmp16no2;
416 if (inst->noiseEstLogQuantile[offset + i] < logval) {
419 inst->noiseEstLogQuantile[offset + i] = logval;
424 if (WEBRTC_SPL_ABS_W16(lmagn[i] - inst->noiseEstLogQuantile[offset + i])
427 inst->noiseEstDensity[offset + i], countProd, 15);
430 inst->noiseEstDensity[offset + i] = tmp16no1 + tmp16no2;
435 inst->noiseEstCounter[s] = 0;
436 if (inst->blockIndex >= END_STARTUP_LONG) {
437 UpdateNoiseEstimate(inst, offset);
440 inst->noiseEstCounter[s]++;
445 if (inst->blockIndex < END_STARTUP_LONG) {
446 UpdateNoiseEstimate(inst, offset);
449 for (i = 0; i < inst->magnLen; i++) {
450 noise[i] = (uint32_t)(inst->noiseEstQuantile[i]); // Q(qNoise)
452 (*q_noise) = (int16_t)inst->qNoise;
456 static void PrepareSpectrumC(NoiseSuppressionFixedC* inst, int16_t* freq_buf) {
459 for (i = 0; i < inst->magnLen; i++) {
460 inst->real[i] = (int16_t)((inst->real[i] *
461 (int16_t)(inst->noiseSupFilter[i])) >> 14); // Q(normData-stages)
462 inst->imag[i] = (int16_t)((inst->imag[i] *
463 (int16_t)(inst->noiseSupFilter[i])) >> 14); // Q(normData-stages)
466 freq_buf[0] = inst->real[0];
467 freq_buf[1] = -inst->imag[0];
468 for (i = 1, j = 2; i < inst->anaLen2; i += 1, j += 2) {
469 freq_buf[j] = inst->real[i];
470 freq_buf[j + 1] = -inst->imag[i];
472 freq_buf[inst->anaLen] = inst->real[inst->anaLen2];
473 freq_buf[inst->anaLen + 1] = -inst->imag[inst->anaLen2];
477 static void DenormalizeC(NoiseSuppressionFixedC* inst,
482 for (i = 0; i < inst->anaLen; i += 1) {
484 factor - inst->normData);
485 inst->real[i] = WebRtcSpl_SatW32ToW16(tmp32); // Q0
491 static void SynthesisUpdateC(NoiseSuppressionFixedC* inst,
500 for (i = 0; i < inst->anaLen; i++) {
502 inst->window[i], inst->real[i], 14); // Q0, window in Q14
506 inst->synthesisBuffer[i] = WebRtcSpl_AddSatW16(inst->synthesisBuffer[i],
511 for (i = 0; i < inst->blockLen10ms; i++) {
512 out_frame[i] = inst->synthesisBuffer[i]; // Q0
516 memcpy(inst->synthesisBuffer, inst->synthesisBuffer + inst->blockLen10ms,
517 (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->synthesisBuffer));
518 WebRtcSpl_ZerosArrayW16(inst->synthesisBuffer
519 + inst->anaLen - inst->blockLen10ms, inst->blockLen10ms);
523 static void AnalysisUpdateC(NoiseSuppressionFixedC* inst,
529 memcpy(inst->analysisBuffer, inst->analysisBuffer + inst->blockLen10ms,
530 (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->analysisBuffer));
531 memcpy(inst->analysisBuffer + inst->anaLen - inst->blockLen10ms, new_speech,
532 inst->blockLen10ms * sizeof(*inst->analysisBuffer));
535 for (i = 0; i < inst->anaLen; i++) {
537 inst->window[i], inst->analysisBuffer[i], 14); // Q0
542 static void NormalizeRealBufferC(NoiseSuppressionFixedC* inst,
546 assert(inst->normData >= 0);
547 for (i = 0; i < inst->anaLen; ++i) {
548 out[i] = in[i] << inst->normData; // Q(normData)
583 void WebRtcNsx_CalcParametricNoiseEstimate(NoiseSuppressionFixedC* inst,
604 tmp32no1 += (inst->minNorm - inst->stages) << 11;
623 *noise_estimate = (*noise_estimate_avg) * (uint32_t)(inst->blockIndex + 1);
628 int32_t WebRtcNsx_InitCore(NoiseSuppressionFixedC* inst, uint32_t fs) {
632 if (inst == NULL) {
639 inst->fs = fs;
645 inst->blockLen10ms = 80;
646 inst->anaLen = 128;
647 inst->stages = 7;
648 inst->window = kBlocks80w128x;
649 inst->thresholdLogLrt = 131072; //default threshold for LRT feature
650 inst->maxLrt = 0x0040000;
651 inst->minLrt = 52429;
653 inst->blockLen10ms = 160;
654 inst->anaLen = 256;
655 inst->stages = 8;
656 inst->window = kBlocks160w256x;
657 inst->thresholdLogLrt = 212644; //default threshold for LRT feature
658 inst->maxLrt = 0x0080000;
659 inst->minLrt = 104858;
661 inst->anaLen2 = inst->anaLen / 2;
662 inst->magnLen = inst->anaLen2 + 1;
664 if (inst->real_fft != NULL) {
665 WebRtcSpl_FreeRealFFT(inst->real_fft);
667 inst->real_fft = WebRtcSpl_CreateRealFFT(inst->stages);
668 if (inst->real_fft == NULL) {
672 WebRtcSpl_ZerosArrayW16(inst->analysisBuffer, ANAL_BLOCKL_MAX);
673 WebRtcSpl_ZerosArrayW16(inst->synthesisBuffer, ANAL_BLOCKL_MAX);
676 WebRtcSpl_ZerosArrayW16(inst->dataBufHBFX[0],
679 WebRtcSpl_ZerosArrayW16(inst->noiseEstQuantile, HALF_ANAL_BLOCKL);
681 inst->noiseEstLogQuantile[i] = 2048; // Q8
682 inst->noiseEstDensity[i] = 153; // Q9
685 inst->noiseEstCounter[i] = (int16_t)(END_STARTUP_LONG * (i + 1)) / SIMULT;
689 WebRtcSpl_MemSetW16((int16_t*)inst->noiseSupFilter, 16384, HALF_ANAL_BLOCKL);
692 inst->aggrMode = 0;
695 inst->priorNonSpeechProb = 8192; // Q14(0.5) prior probability for speech/noise
697 inst->prevMagnU16[i] = 0;
698 inst->prevNoiseU32[i] = 0; //previous noise-spectrum
699 inst->logLrtTimeAvgW32[i] = 0; //smooth LR ratio
700 inst->avgMagnPause[i] = 0; //conservative noise spectrum estimate
701 inst->initMagnEst[i] = 0; //initial average magnitude spectrum
705 inst->thresholdSpecDiff = 50; //threshold for difference feature: determined on-line
706 inst->thresholdSpecFlat = 20480; //threshold for flatness: determined on-line
707 inst->featureLogLrt = inst->thresholdLogLrt; //average LRT factor (= threshold)
708 inst->featureSpecFlat = inst->thresholdSpecFlat; //spectral flatness (= threshold)
709 inst->featureSpecDiff = inst->thresholdSpecDiff; //spectral difference (= threshold)
710 inst->weightLogLrt = 6; //default weighting par for LRT feature
711 inst->weightSpecFlat = 0; //default weighting par for spectral flatness feature
712 inst->weightSpecDiff = 0; //default weighting par for spectral difference feature
714 inst->curAvgMagnEnergy = 0; //window time-average of input magnitude spectrum
715 inst->timeAvgMagnEnergy = 0; //normalization for spectral difference
716 inst->timeAvgMagnEnergyTmp = 0; //normalization for spectral difference
719 WebRtcSpl_ZerosArrayW16(inst->histLrt, HIST_PAR_EST);
720 WebRtcSpl_ZerosArrayW16(inst->histSpecDiff, HIST_PAR_EST);
721 WebRtcSpl_ZerosArrayW16(inst->histSpecFlat, HIST_PAR_EST);
723 inst->blockIndex = -1; //frame counter
725 //inst->modelUpdate = 500; //window for update
726 inst->modelUpdate = (1 << STAT_UPDATES); //window for update
727 inst->cntThresUpdate = 0; //counter feature thresholds updates
729 inst->sumMagn = 0;
730 inst->magnEnergy = 0;
731 inst->prevQMagn = 0;
732 inst->qNoise = 0;
733 inst->prevQNoise = 0;
735 inst->energyIn = 0;
736 inst->scaleEnergyIn = 0;
738 inst->whiteNoiseLevel = 0;
739 inst->pinkNoiseNumerator = 0;
740 inst->pinkNoiseExp = 0;
741 inst->minNorm = 15; // Start with full scale
742 inst->zeroInputSignal = 0;
745 WebRtcNsx_set_policy_core(inst, 0);
748 inst->infile = fopen("indebug.pcm", "wb");
749 inst->outfile = fopen("outdebug.pcm", "wb");
750 inst->file1 = fopen("file1.pcm", "wb");
751 inst->file2 = fopen("file2.pcm", "wb");
752 inst->file3 = fopen("file3.pcm", "wb");
753 inst->file4 = fopen("file4.pcm", "wb");
754 inst->file5 = fopen("file5.pcm", "wb");
778 inst->initFlag = 1;
783 int WebRtcNsx_set_policy_core(NoiseSuppressionFixedC* inst, int mode) {
789 inst->aggrMode = mode;
791 inst->overdrive = 256; // Q8(1.0)
792 inst->denoiseBound = 8192; // Q14(0.5)
793 inst->gainMap = 0; // No gain compensation
795 inst->overdrive = 256; // Q8(1.0)
796 inst->denoiseBound = 4096; // Q14(0.25)
797 inst->factor2Table = kFactor2Aggressiveness1;
798 inst->gainMap = 1;
800 inst->overdrive = 282; // ~= Q8(1.1)
801 inst->denoiseBound = 2048; // Q14(0.125)
802 inst->factor2Table = kFactor2Aggressiveness2;
803 inst->gainMap = 1;
805 inst->overdrive = 320; // Q8(1.25)
806 inst->denoiseBound = 1475; // ~= Q14(0.09)
807 inst->factor2Table = kFactor2Aggressiveness3;
808 inst->gainMap = 1;
817 // threshold and weights are returned in: inst->priorModelPars
818 void WebRtcNsx_FeatureParameterExtraction(NoiseSuppressionFixedC* inst,
843 histIndex = (uint32_t)(inst->featureLogLrt);
845 inst->histLrt[histIndex]++;
848 // (inst->featureSpecFlat*20)>>10 = (inst->featureSpecFlat*5)>>8
849 histIndex = (inst->featureSpecFlat * 5) >> 8;
851 inst->histSpecFlat[histIndex]++;
855 if (inst->timeAvgMagnEnergy > 0) {
859 histIndex = ((inst->featureSpecDiff * 5) >> inst->stages) /
860 inst->timeAvgMagnEnergy;
863 inst->histSpecDiff[histIndex]++;
871 // compute the average over inst->featureExtractionParams.rangeAvgHistLrt
877 tmp32 = inst->histLrt[i] * j;
879 numHistLrt += inst->histLrt[i];
885 tmp32 = inst->histLrt[i] * j;
897 inst->thresholdLogLrt = inst->maxLrt;
899 tmp32 = (int32_t)((tmpU32 << (9 + inst->stages)) / numHistLrt /
902 inst->thresholdLogLrt = WEBRTC_SPL_SAT(inst->maxLrt,
904 inst->minLrt);
922 if (inst->histSpecFlat[i] > maxPeak1) {
928 maxPeak1 = inst->histSpecFlat[i];
929 weightPeak1SpecFlat = inst->histSpecFlat[i];
931 } else if (inst->histSpecFlat[i] > maxPeak2) {
933 maxPeak2 = inst->histSpecFlat[i];
934 weightPeak2SpecFlat = inst->histSpecFlat[i];
953 inst->thresholdSpecFlat = WEBRTC_SPL_SAT(MAX_FLAT_Q10, FACTOR_2_FLAT_Q10
968 if (inst->histSpecDiff[i] > maxPeak1) {
974 maxPeak1 = inst->histSpecDiff[i];
975 weightPeak1SpecDiff = inst->histSpecDiff[i];
977 } else if (inst->histSpecDiff[i] > maxPeak2) {
979 maxPeak2 = inst->histSpecDiff[i];
980 weightPeak2SpecDiff = inst->histSpecDiff[i];
992 inst->thresholdSpecDiff = WEBRTC_SPL_SAT(MAX_DIFF, FACTOR_1_LRT_DIFF
1002 // inst->priorModelPars[4] is weight for LRT: always selected
1004 inst->weightLogLrt = featureSum;
1005 inst->weightSpecFlat = useFeatureSpecFlat * featureSum;
1006 inst->weightSpecDiff = useFeatureSpecDiff * featureSum;
1009 WebRtcSpl_ZerosArrayW16(inst->histLrt, HIST_PAR_EST);
1010 WebRtcSpl_ZerosArrayW16(inst->histSpecDiff, HIST_PAR_EST);
1011 WebRtcSpl_ZerosArrayW16(inst->histSpecFlat, HIST_PAR_EST);
1018 // spectral flatness is returned in inst->featureSpecFlat
1019 void WebRtcNsx_ComputeSpectralFlatness(NoiseSuppressionFixedC* inst,
1033 avgSpectralFlatnessDen = inst->sumMagn - (uint32_t)magn[0]; // Q(normData-stages)
1039 for (i = 1; i < inst->magnLen; i++) {
1052 tmpU32 = WEBRTC_SPL_UMUL_32_16(inst->featureSpecFlat, SPECT_FLAT_TAVG_Q14); // Q24
1053 inst->featureSpecFlat -= tmpU32 >> 14; // Q10
1064 logCurSpectralFlatness += ((int32_t)(inst->stages - 1) << (inst->stages + 7)); // Q(8+stages-1)
1065 logCurSpectralFlatness -= (tmp32 << (inst->stages - 1));
1066 logCurSpectralFlatness <<= (10 - inst->stages); // Q17
1077 tmp32 = currentSpectralFlatness - (int32_t)inst->featureSpecFlat; // Q10
1079 inst->featureSpecFlat += tmp32 >> 14; // Q10
1086 // the reference/template spectrum is inst->magn_avg_pause[i]
1087 // returns (normalized) spectral difference in inst->featureSpecDiff
1088 void WebRtcNsx_ComputeSpectralDifference(NoiseSuppressionFixedC* inst,
1107 minPause = inst->avgMagnPause[0]; // Q(prevQMagn)
1109 for (i = 0; i < inst->magnLen; i++) {
1111 avgPauseFX += inst->avgMagnPause[i]; // in Q(prevQMagn)
1112 maxPause = WEBRTC_SPL_MAX(maxPause, inst->avgMagnPause[i]);
1113 minPause = WEBRTC_SPL_MIN(minPause, inst->avgMagnPause[i]);
1115 // normalize by replacing div of "inst->magnLen" with "inst->stages-1" shifts
1116 avgPauseFX >>= inst->stages - 1;
1117 avgMagnFX = inst->sumMagn >> (inst->stages - 1);
1121 nShifts = WEBRTC_SPL_MAX(0, 10 + inst->stages - WebRtcSpl_NormW32(tmp32no1));
1126 for (i = 0; i < inst->magnLen; i++) {
1129 tmp32no2 = inst->avgMagnPause[i] - avgPauseFX;
1137 inst->curAvgMagnEnergy +=
1138 inst->magnEnergy >> (2 * inst->normData + inst->stages - 1);
1169 tmpU32no1 = avgDiffNormMagnUFX >> (2 * inst->normData);
1170 if (inst->featureSpecDiff > tmpU32no1) {
1171 tmpU32no2 = WEBRTC_SPL_UMUL_32_16(inst->featureSpecDiff - tmpU32no1,
1173 inst->featureSpecDiff -= tmpU32no2 >> 8; // Q(-2*stages)
1175 tmpU32no2 = WEBRTC_SPL_UMUL_32_16(tmpU32no1 - inst->featureSpecDiff,
1177 inst->featureSpecDiff += tmpU32no2 >> 8; // Q(-2*stages)
1182 void WebRtcNsx_DataAnalysis(NoiseSuppressionFixedC* inst,
1216 WebRtcNsx_AnalysisUpdate(inst, winData, speechFrame);
1219 inst->energyIn =
1220 WebRtcSpl_Energy(winData, inst->anaLen, &inst->scaleEnergyIn);
1223 inst->zeroInputSignal = 0;
1225 maxWinData = WebRtcSpl_MaxAbsValueW16(winData, inst->anaLen);
1226 inst->normData = WebRtcSpl_NormW16(maxWinData);
1229 inst->zeroInputSignal = 1;
1234 net_norm = inst->stages - inst->normData;
1236 right_shifts_in_magnU16 = inst->normData - inst->minNorm;
1238 inst->minNorm -= right_shifts_in_initMagnEst;
1242 WebRtcNsx_NormalizeRealBuffer(inst, winData, realImag);
1245 WebRtcSpl_RealForwardFFT(inst->real_fft, realImag, winData);
1247 inst->imag[0] = 0; // Q(normData-stages)
1248 inst->imag[inst->anaLen2] = 0;
1249 inst->real[0] = winData[0]; // Q(normData-stages)
1250 inst->real[inst->anaLen2] = winData[inst->anaLen];
1252 inst->magnEnergy = (uint32_t)(inst->real[0] * inst->real[0]);
1253 inst->magnEnergy += (uint32_t)(inst->real[inst->anaLen2] *
1254 inst->real[inst->anaLen2]);
1255 magnU16[0] = (uint16_t)WEBRTC_SPL_ABS_W16(inst->real[0]); // Q(normData-stages)
1256 magnU16[inst->anaLen2] = (uint16_t)WEBRTC_SPL_ABS_W16(inst->real[inst->anaLen2]);
1257 inst->sumMagn = (uint32_t)magnU16[0]; // Q(normData-stages)
1258 inst->sumMagn += (uint32_t)magnU16[inst->anaLen2];
1260 if (inst->blockIndex >= END_STARTUP_SHORT) {
1261 for (i = 1, j = 2; i < inst->anaLen2; i += 1, j += 2) {
1262 inst->real[i] = winData[j];
1263 inst->imag[i] = -winData[j + 1];
1268 inst->magnEnergy += tmpU32no1; // Q(2*(normData-stages))
1271 inst->sumMagn += (uint32_t)magnU16[i]; // Q(normData-stages)
1279 inst->initMagnEst[0] >>= right_shifts_in_initMagnEst;
1280 inst->initMagnEst[inst->anaLen2] >>= right_shifts_in_initMagnEst;
1283 inst->initMagnEst[0] += magnU16[0] >> right_shifts_in_magnU16;
1284 inst->initMagnEst[inst->anaLen2] +=
1285 magnU16[inst->anaLen2] >> right_shifts_in_magnU16;
1288 if (magnU16[inst->anaLen2]) {
1289 // Calculate log2(magnU16[inst->anaLen2])
1290 zeros = WebRtcSpl_NormU32((uint32_t)magnU16[inst->anaLen2]);
1291 frac = (int16_t)((((uint32_t)magnU16[inst->anaLen2] << zeros) &
1300 sum_log_i_log_magn = (kLogIndex[inst->anaLen2] * log2) >> 3;
1302 for (i = 1, j = 2; i < inst->anaLen2; i += 1, j += 2) {
1303 inst->real[i] = winData[j];
1304 inst->imag[i] = -winData[j + 1];
1309 inst->magnEnergy += tmpU32no1; // Q(2*(normData-stages))
1312 inst->sumMagn += (uint32_t)magnU16[i]; // Q(normData-stages)
1315 inst->initMagnEst[i] >>= right_shifts_in_initMagnEst;
1318 inst->initMagnEst[i] += magnU16[i] >> right_shifts_in_magnU16;
1345 inst->whiteNoiseLevel >>= right_shifts_in_initMagnEst;
1348 tmpU32no1 = WEBRTC_SPL_UMUL_32_16(inst->sumMagn, inst->overdrive);
1349 tmpU32no1 >>= inst->stages + 8;
1356 inst->whiteNoiseLevel += tmpU32no1; // Q(minNorm-stages)
1366 if (inst->fs == 8000) {
1372 tmp_1_w32 -= ((inst->magnLen - kStartBand) * kSumSquareLogIndex[65]) >> 2;
1404 inst->pinkNoiseNumerator += tmp_2_w32; // Q11
1409 tmp_1_w32 *= inst->magnLen - kStartBand;
1415 inst->pinkNoiseExp += WEBRTC_SPL_SAT(16384, tmp_1_w32, 0); // Q14
1420 void WebRtcNsx_DataSynthesis(NoiseSuppressionFixedC* inst, short* outFrame) {
1438 if (inst->zeroInputSignal) {
1441 for (i = 0; i < inst->blockLen10ms; i++) {
1442 outFrame[i] = inst->synthesisBuffer[i]; // Q0
1445 memcpy(inst->synthesisBuffer, inst->synthesisBuffer + inst->blockLen10ms,
1446 (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->synthesisBuffer));
1447 WebRtcSpl_ZerosArrayW16(inst->synthesisBuffer + inst->anaLen - inst->blockLen10ms,
1448 inst->blockLen10ms);
1453 WebRtcNsx_PrepareSpectrum(inst, realImag);
1456 outCIFFT = WebRtcSpl_RealInverseFFT(inst->real_fft, realImag, rfft_out);
1458 WebRtcNsx_Denormalize(inst, rfft_out, outCIFFT);
1462 if (inst->gainMap == 1 &&
1463 inst->blockIndex > END_STARTUP_LONG &&
1464 inst->energyIn > 0) {
1466 energyOut = WebRtcSpl_Energy(inst->real, inst->anaLen, &scaleEnergyOut);
1469 - inst->scaleEnergyIn);
1474 inst->energyIn >>= 8 + scaleEnergyOut - inst->scaleEnergyIn;
1477 assert(inst->energyIn > 0);
1478 energyRatio = (energyOut + inst->energyIn / 2) / inst->energyIn; // Q8
1485 gainFactor2 = inst->factor2Table[energyRatio]; // Q8
1489 // factor = inst->priorSpeechProb*factor1 + (1.0-inst->priorSpeechProb)*factor2; // original code
1490 tmp16no1 = (int16_t)(((16384 - inst->priorNonSpeechProb) * gainFactor1) >>
1492 tmp16no2 = (int16_t)((inst->priorNonSpeechProb * gainFactor2) >> 14);
1497 WebRtcNsx_SynthesisUpdate(inst, outFrame, gainFactor);
1500 void WebRtcNsx_ProcessCore(NoiseSuppressionFixedC* inst,
1542 assert(inst->anaLen > 0);
1543 assert(inst->anaLen2 > 0);
1544 assert(inst->anaLen % 16 == 0);
1545 assert(inst->anaLen2 % 8 == 0);
1546 assert(inst->blockLen10ms > 0);
1547 assert(inst->blockLen10ms % 16 == 0);
1548 assert(inst->magnLen == inst->anaLen2 + 1);
1552 inst->blockLen10ms, inst->infile) != inst->blockLen10ms) {
1558 assert(inst->initFlag == 1);
1571 WebRtcNsx_DataAnalysis(inst, (short*)speechFrame[0], magnU16);
1573 if (inst->zeroInputSignal) {
1574 WebRtcNsx_DataSynthesis(inst, outFrame[0]);
1580 int block_shift = inst->anaLen - inst->blockLen10ms;
1581 memcpy(inst->dataBufHBFX[i], inst->dataBufHBFX[i] + inst->blockLen10ms,
1582 block_shift * sizeof(*inst->dataBufHBFX[i]));
1583 memcpy(inst->dataBufHBFX[i] + block_shift, speechFrameHB[i],
1584 inst->blockLen10ms * sizeof(*inst->dataBufHBFX[i]));
1585 for (j = 0; j < inst->blockLen10ms; j++) {
1586 outFrameHB[i][j] = inst->dataBufHBFX[i][j]; // Q0
1594 inst->blockIndex++;
1598 qMagn = inst->normData - inst->stages;
1601 WebRtcNsx_ComputeSpectralFlatness(inst, magnU16);
1604 WebRtcNsx_NoiseEstimation(inst, magnU16, noiseU32, &qNoise);
1607 for (i = 0; i < inst->magnLen; i++) {
1608 prevNoiseU16[i] = (uint16_t)(inst->prevNoiseU32[i] >> 11); // Q(prevQNoise)
1611 if (inst->blockIndex < END_STARTUP_SHORT) {
1613 q_domain_to_use = WEBRTC_SPL_MIN((int)qNoise, inst->minNorm - inst->stages);
1617 if (inst->pinkNoiseExp) {
1618 pink_noise_exp_avg = (int16_t)WebRtcSpl_DivW32W16(inst->pinkNoiseExp,
1619 (int16_t)(inst->blockIndex + 1)); // Q14
1620 pink_noise_num_avg = WebRtcSpl_DivW32W16(inst->pinkNoiseNumerator,
1621 (int16_t)(inst->blockIndex + 1)); // Q11
1622 WebRtcNsx_CalcParametricNoiseEstimate(inst,
1630 noise_estimate = inst->whiteNoiseLevel; // Q(minNorm-stages)
1631 noise_estimate_avg = noise_estimate / (inst->blockIndex + 1); // Q(minNorm-stages)
1633 for (i = 0; i < inst->magnLen; i++) {
1635 if ((inst->pinkNoiseExp) && (i >= kStartBand)) {
1640 WebRtcNsx_CalcParametricNoiseEstimate(inst,
1648 noiseSupFilterTmp[i] = inst->denoiseBound;
1649 if (inst->initMagnEst[i]) {
1652 tmpU32no1 = WEBRTC_SPL_UMUL_32_16(noise_estimate, inst->overdrive);
1653 numerator = inst->initMagnEst[i] << 8;
1667 tmpU32no1 = inst->initMagnEst[i] >> (6 - nShifts);
1675 (uint32_t)(inst->denoiseBound)); // Q14
1689 (inst->minNorm - inst->stages - q_domain_to_use);
1698 tmpU32no1 *= inst->blockIndex;
1699 tmpU32no2 *= (END_STARTUP_SHORT - inst->blockIndex);
1710 if (inst->blockIndex < END_STARTUP_LONG) {
1712 inst->timeAvgMagnEnergyTmp +=
1713 inst->magnEnergy >> (2 * inst->normData + inst->stages - 1);
1714 inst->timeAvgMagnEnergy = WebRtcSpl_DivU32U16(inst->timeAvgMagnEnergyTmp,
1715 inst->blockIndex + 1);
1724 nShifts = 5 - inst->prevQMagn + inst->prevQNoise;
1725 for (i = 0; i < inst->magnLen; i++) {
1736 // prevNearSnr[i] = inst->prevMagnU16[i] / (inst->noisePrev[i] + 0.0001) * (inst->smooth[i]);
1764 nearMagnEst = inst->prevMagnU16[i] * inst->noiseSupFilter[i];
1766 tmpU32no2 = inst->prevNoiseU32[i] >> nShifts; // Q(prevQMagn+6)
1788 WebRtcNsx_ComputeSpectralDifference(inst, magnU16);
1790 //parameters are extracted once every window time (=inst->modelUpdate)
1792 inst->cntThresUpdate++;
1793 flag = (int)(inst->cntThresUpdate == inst->modelUpdate);
1795 WebRtcNsx_FeatureParameterExtraction(inst, flag);
1798 inst->cntThresUpdate = 0; // Reset counter
1803 inst->curAvgMagnEnergy >>= STAT_UPDATES;
1805 tmpU32no1 = (inst->curAvgMagnEnergy + inst->timeAvgMagnEnergy + 1) >> 1; //Q(-2*stages)
1807 if ((tmpU32no1 != inst->timeAvgMagnEnergy) && (inst->featureSpecDiff) &&
1808 (inst->timeAvgMagnEnergy > 0)) {
1815 tmpU32no2 = inst->featureSpecDiff;
1821 tmpU32no3 /= inst->timeAvgMagnEnergy;
1823 inst->featureSpecDiff = 0x007FFFFF;
1825 inst->featureSpecDiff = WEBRTC_SPL_MIN(0x007FFFFF,
1830 inst->timeAvgMagnEnergy = tmpU32no1; // Q(-2*stages)
1831 inst->curAvgMagnEnergy = 0;
1835 WebRtcNsx_SpeechNoiseProb(inst, nonSpeechProbFinal, priorLocSnr, postLocSnr);
1841 postShifts = inst->prevQNoise - qMagn;
1842 nShifts = inst->prevQMagn - qMagn;
1843 for (i = 0; i < inst->magnLen; i++) {
1860 noiseUpdateU32 = inst->prevNoiseU32[i]; // Q(prevQNoise+11)
1905 tmpU32no1 = inst->prevNoiseU32[i] + tmpU32no2; // Q(prevQNoise+11)
1907 tmpU32no1 = inst->prevNoiseU32[i] - tmpU32no2; // Q(prevQNoise+11)
1921 // inst->avgMagnPause[i] = inst->avgMagnPause[i] + (1.0 - gamma_pause)*(magn[i] - inst->avgMagnPause[i]);
1924 tmp32no2 = WEBRTC_SPL_SHIFT_W32(inst->avgMagnPause[i], -nShifts);
1932 tmp32no1 = ((int32_t)magnU16[i] << nShifts) - inst->avgMagnPause[i];
1938 inst->avgMagnPause[i] = tmp32no2;
1942 qNoise = inst->prevQNoise + norm32no1 - 5;
1946 nShifts = inst->prevQNoise + 11 - qMagn;
1947 for (i = 0; i < inst->magnLen; i++) {
1959 // tmpFloat1 = inst->overdrive + snrPrior;
1996 tmpU32no1 = inst->overdrive + ((priorSnr + 8192) >> 14); // Q8
1997 assert(inst->overdrive > 0);
1999 inst->noiseSupFilter[i] = WEBRTC_SPL_SAT(16384, tmpU16no1, inst->denoiseBound); // 16384 = Q14(1.0) // Q14
2002 if (inst->blockIndex < END_STARTUP_SHORT) {
2004 tmpU32no1 = inst->noiseSupFilter[i] * inst->blockIndex;
2006 (END_STARTUP_SHORT - inst->blockIndex);
2008 inst->noiseSupFilter[i] = (uint16_t)WebRtcSpl_DivU32U16(tmpU32no1,
2015 inst->prevQNoise = qNoise;
2016 inst->prevQMagn = qMagn;
2018 for (i = 0; i < inst->magnLen; i++) {
2019 inst->prevNoiseU32[i] = noiseU32[i] << (norm32no1 - 5); // Q(qNoise+11)
2020 inst->prevMagnU16[i] = magnU16[i]; // Q(qMagn)
2023 for (i = 0; i < inst->magnLen; i++) {
2024 inst->prevNoiseU32[i] = noiseU32[i] >> (5 - norm32no1); // Q(qNoise+11)
2025 inst->prevMagnU16[i] = magnU16[i]; // Q(qMagn)
2029 WebRtcNsx_DataSynthesis(inst, outFrame[0]);
2032 inst->blockLen10ms, inst->outfile) != inst->blockLen10ms) {
2043 memcpy(inst->dataBufHBFX[i], inst->dataBufHBFX[i] + inst->blockLen10ms,
2044 (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->dataBufHBFX[i]));
2045 memcpy(inst->dataBufHBFX[i] + inst->anaLen - inst->blockLen10ms,
2046 speechFrameHB[i], inst->blockLen10ms * sizeof(*inst->dataBufHBFX[i]));
2056 for (i = inst->anaLen2 - (inst->anaLen2 >> 2); i < inst->anaLen2; i++) {
2058 tmpU32no1 += (uint32_t)(inst->noiseSupFilter[i]); // Q14
2060 assert(inst->stages >= 7);
2061 avgProbSpeechHB = (4096 - (tmpU16no1 >> (inst->stages - 7))); // Q12
2062 avgFilterGainHB = (int16_t)(tmpU32no1 >> (inst->stages - 3)); // Q14
2101 = WEBRTC_SPL_SAT(16384, gainTimeDomainHB, (int16_t)(inst->denoiseBound)); // 16384 = Q14(1.0)
2106 for (j = 0; j < inst->blockLen10ms; j++) {
2108 inst->dataBufHBFX[i][j]) >> 14); // Q0