diff options
Diffstat (limited to 'libSBRenc/src/tran_det.cpp')
| -rw-r--r-- | libSBRenc/src/tran_det.cpp | 487 |
1 files changed, 431 insertions, 56 deletions
diff --git a/libSBRenc/src/tran_det.cpp b/libSBRenc/src/tran_det.cpp index 6c62b4c..33ea60e 100644 --- a/libSBRenc/src/tran_det.cpp +++ b/libSBRenc/src/tran_det.cpp @@ -89,7 +89,7 @@ amm-info@iis.fraunhofer.de #include "genericStds.h" -#define NORM_QMF_ENERGY 5.684341886080801486968994140625e-14 /* 2^-44 */ +#define NORM_QMF_ENERGY 9.31322574615479E-10 /* 2^-30 */ /* static FIXP_DBL ABS_THRES = fixMax( FL2FXCONST_DBL(1.28e5 * NORM_QMF_ENERGY), (FIXP_DBL)1) Minimum threshold for detecting changes */ #define ABS_THRES ((FIXP_DBL)16) @@ -106,22 +106,30 @@ amm-info@iis.fraunhofer.de \return calculated value *******************************************************************************/ +#define NRG_SHIFT 3 /* for energy summation */ + static FIXP_DBL spectralChange(FIXP_DBL Energies[NUMBER_TIME_SLOTS_2304][MAX_FREQ_COEFFS], INT *scaleEnergies, FIXP_DBL EnergyTotal, INT nSfb, INT start, INT border, - INT stop) + INT YBufferWriteOffset, + INT stop, + INT *result_e) { INT i,j; INT len1,len2; - FIXP_DBL delta,tmp0,tmp1,tmp2; - FIXP_DBL accu1,accu2,delta_sum,result; + SCHAR energies_e_diff[NUMBER_TIME_SLOTS_2304], energies_e, energyTotal_e=19, energies_e_add; + SCHAR prevEnergies_e_diff, newEnergies_e_diff; + FIXP_DBL tmp0,tmp1; + FIXP_DBL accu1,accu2,accu1_init,accu2_init; + FIXP_DBL delta, delta_sum; + INT accu_e, tmp_e; - FDK_ASSERT(scaleEnergies[0] >= 0); + delta_sum = FL2FXCONST_DBL(0.0f); + *result_e = 0; - /* equal for aac (would be not equal for mp3) */ len1 = border-start; len2 = stop-border; @@ -130,43 +138,91 @@ static FIXP_DBL spectralChange(FIXP_DBL Energies[NUMBER_TIME_SLOTS_2304][MAX_FRE pos_weight = FL2FXCONST_DBL(0.5f) - (len1*GetInvInt(len1+len2)); pos_weight = /*FL2FXCONST_DBL(1.0)*/ (FIXP_DBL)MAXVAL_DBL - (fMult(pos_weight, pos_weight)<<2); - delta_sum = FL2FXCONST_DBL(0.0f); + /*** Calc scaling for energies ***/ + FDK_ASSERT(scaleEnergies[0] >= 0); + FDK_ASSERT(scaleEnergies[1] >= 0); + + energies_e = 19 - FDKmin(scaleEnergies[0], scaleEnergies[1]); + + /* limit shift for energy accumulation, energies_e can be -10 min. */ + if (energies_e < -10) { + energies_e_add = -10 - energies_e; + energies_e = -10; + } else if (energies_e > 17) { + energies_e_add = energies_e - 17; + energies_e = 17; + } else { + energies_e_add = 0; + } + + /* compensate scaling differences between scaleEnergies[0] and scaleEnergies[1] */ + prevEnergies_e_diff = scaleEnergies[0] - FDKmin(scaleEnergies[0], scaleEnergies[1]) + energies_e_add + NRG_SHIFT; + newEnergies_e_diff = scaleEnergies[1] - FDKmin(scaleEnergies[0], scaleEnergies[1]) + energies_e_add + NRG_SHIFT; + + prevEnergies_e_diff = fMin(prevEnergies_e_diff, DFRACT_BITS-1); + newEnergies_e_diff = fMin(newEnergies_e_diff, DFRACT_BITS-1); + + for (i=start; i<YBufferWriteOffset; i++) { + energies_e_diff[i] = prevEnergies_e_diff; + } + for (i=YBufferWriteOffset; i<stop; i++) { + energies_e_diff[i] = newEnergies_e_diff; + } /* Sum up energies of all QMF-timeslots for both halfs */ + FDK_ASSERT(len1<=8); /* otherwise an overflow is possible */ + FDK_ASSERT(len2<=8); /* otherwise an overflow is possible */ + /* init with some energy to prevent division by zero + and to prevent splitting for very low levels */ + accu1_init = scaleValue((FL2FXCONST_DBL((1.0e6*NORM_QMF_ENERGY))),-energies_e); + accu2_init = scaleValue((FL2FXCONST_DBL((1.0e6*NORM_QMF_ENERGY))),-energies_e); + accu1_init = fMult(accu1_init, (FIXP_DBL)len1<<((DFRACT_BITS-1)-NRG_SHIFT-1))<<1; + accu2_init = fMult(accu2_init, (FIXP_DBL)len2<<((DFRACT_BITS-1)-NRG_SHIFT-1))<<1; + for (j=0; j<nSfb; j++) { - #define NRG_SCALE 3 - /* init with some energy to prevent division by zero - and to prevent splitting for very low levels */ - accu1 = ((FL2FXCONST_DBL((1.0e6*NORM_QMF_ENERGY*8.0/32))) << fixMin(scaleEnergies[0],25))>>NRG_SCALE; /* complex init for compare with original version */ - accu2 = ((FL2FXCONST_DBL((1.0e6*NORM_QMF_ENERGY*8.0/32))) << fixMin(scaleEnergies[0],25))>>NRG_SCALE; /* can be simplified in dsp implementation */ + + accu1 = accu1_init; + accu2 = accu2_init; + accu_e = energies_e+3; /* Sum up energies in first half */ for (i=start; i<border; i++) { - accu1 += (Energies[i][j]>>NRG_SCALE); + accu1 += scaleValue(Energies[i][j], -energies_e_diff[i]); } /* Sum up energies in second half */ for (i=border; i<stop; i++) { - accu2 += (Energies[i][j]>>NRG_SCALE); + accu2 += scaleValue(Energies[i][j], -energies_e_diff[i]); } /* Energy change in current band */ - tmp0 = CalcLdData(accu2); - tmp1 = CalcLdData(accu1); - tmp2 = (tmp0 - tmp1 + CalcLdData(len1)-CalcLdData(len2)); - delta = fixp_abs(fMult(tmp2, FL2FXCONST_DBL(0.6931471806f))); + #define LN2 FL2FXCONST_DBL(0.6931471806f) /* ln(2) */ + tmp0 = fLog2(accu2, accu_e) - fLog2(accu1, accu_e); + tmp1 = fLog2((FIXP_DBL)len1, 31) - fLog2((FIXP_DBL)len2, 31); + delta = fMult(LN2, (tmp0 + tmp1)); + delta = (FIXP_DBL)FDKabs( delta ); /* Weighting with amplitude ratio of this band */ - result = (EnergyTotal == FL2FXCONST_DBL(0.0f)) - ? FL2FXCONST_DBL(0.f) - : FDKsbrEnc_LSI_divide_scale_fract( (accu1+accu2), - (EnergyTotal>>NRG_SCALE)+(FIXP_DBL)1, - (FIXP_DBL)MAXVAL_DBL >> fixMin(scaleEnergies[0],(DFRACT_BITS-1)) ); + accu_e++; + accu1>>=1; + accu2>>=1; + if (accu_e & 1) { + accu_e++; + accu1>>=1; + accu2>>=1; + } - delta_sum += (FIXP_DBL)(fMult(sqrtFixp(result), delta)); + delta_sum += fMult(sqrtFixp(accu1+accu2), delta); + *result_e = ((accu_e>>1) + LD_DATA_SHIFT); } + energyTotal_e+=1; /* for a defined square result exponent, the exponent has to be even */ + EnergyTotal<<=1; + delta_sum = fMult(delta_sum, invSqrtNorm2(EnergyTotal, &tmp_e)); + *result_e = *result_e + (tmp_e-(energyTotal_e>>1)); + return fMult(delta_sum, pos_weight); + } @@ -175,9 +231,12 @@ static FIXP_DBL spectralChange(FIXP_DBL Energies[NUMBER_TIME_SLOTS_2304][MAX_FRE ******************************************************************************* \brief Calculates total lowband energy - The return value nrgTotal is scaled by the factor (1/32.0) + The input values Energies[0] (low-band) are scaled by the factor + 2^(14-*scaleEnergies[0]) + The input values Energies[1] (high-band) are scaled by the factor + 2^(14-*scaleEnergies[1]) - \return total energy in the lowband + \return total energy in the lowband, scaled by the factor 2^19 *******************************************************************************/ static FIXP_DBL addLowbandEnergies(FIXP_DBL **Energies, int *scaleEnergies, @@ -194,6 +253,7 @@ static FIXP_DBL addLowbandEnergies(FIXP_DBL **Energies, int ts,k; /* Sum up lowband energy from one frame at offset tran_off */ + /* freqBandTable[LORES] has MAX_FREQ_COEFFS/2 +1 coeefs max. */ for (ts=tran_offdiv2; ts<YBufferWriteOffset; ts++) { for (k = 0; k < freqBandTable[0]; k++) { accu1 += Energies[ts][k] >> 6; @@ -201,12 +261,12 @@ static FIXP_DBL addLowbandEnergies(FIXP_DBL **Energies, } for (; ts<tran_offdiv2+(slots>>nrgSzShift); ts++) { for (k = 0; k < freqBandTable[0]; k++) { - accu2 += Energies[ts][k] >> 6; + accu2 += Energies[ts][k] >> 9; } } - nrgTotal = ( (accu1 >> fixMin(scaleEnergies[0],(DFRACT_BITS-1))) - + (accu2 >> fixMin(scaleEnergies[1],(DFRACT_BITS-1))) ) << (2); + nrgTotal = ( scaleValueSaturate(accu1, 1-scaleEnergies[0]) ) + + ( scaleValueSaturate(accu2, 4-scaleEnergies[1]) ); return(nrgTotal); } @@ -222,21 +282,23 @@ static FIXP_DBL addLowbandEnergies(FIXP_DBL **Energies, is 1 SBR-band. Therefore the data to be fed into the spectralChange function is reduced. - The values EnergiesM are scaled by the factor (1/32.0) and scaleEnergies[0] - The return value nrgTotal is scaled by the factor (1/32.0) + The values EnergiesM are scaled by the factor (2^19-scaleEnergies[0]) for + slots<YBufferWriteOffset and by the factor (2^19-scaleEnergies[1]) for + slots>=YBufferWriteOffset. - \return total energy in the highband + \return total energy in the highband, scaled by factor 2^19 *******************************************************************************/ static FIXP_DBL addHighbandEnergies(FIXP_DBL **RESTRICT Energies, /*!< input */ INT *scaleEnergies, + INT YBufferWriteOffset, FIXP_DBL EnergiesM[NUMBER_TIME_SLOTS_2304][MAX_FREQ_COEFFS], /*!< Combined output */ UCHAR *RESTRICT freqBandTable, INT nSfb, INT sbrSlots, INT timeStep) { - INT i,j,k,slotIn,slotOut,scale; + INT i,j,k,slotIn,slotOut,scale[2]; INT li,ui; FIXP_DBL nrgTotal; FIXP_DBL accu = FL2FXCONST_DBL(0.0f); @@ -245,7 +307,7 @@ static FIXP_DBL addHighbandEnergies(FIXP_DBL **RESTRICT Energies, /*!< input */ combine QMF-bands to SBR-bands, combine Left and Right channel */ for (slotOut=0; slotOut<sbrSlots; slotOut++) { - slotIn = 2*slotOut; + slotIn = timeStep*slotOut; for (j=0; j<nSfb; j++) { accu = FL2FXCONST_DBL(0.0f); @@ -262,19 +324,29 @@ static FIXP_DBL addHighbandEnergies(FIXP_DBL **RESTRICT Energies, /*!< input */ } } - scale = fixMin(8,scaleEnergies[0]); /* scale energies down before add up */ + /* scale energies down before add up */ + scale[0] = fixMin(8,scaleEnergies[0]); + scale[1] = fixMin(8,scaleEnergies[1]); - if ((scaleEnergies[0]-1) > (DFRACT_BITS-1) ) + if ((scaleEnergies[0]-scale[0]) > (DFRACT_BITS-1) || (scaleEnergies[1]-scale[0]) > (DFRACT_BITS-1)) nrgTotal = FL2FXCONST_DBL(0.0f); else { /* Now add all energies */ accu = FL2FXCONST_DBL(0.0f); - for (slotOut=0; slotOut<sbrSlots; slotOut++) { + + for (slotOut=0; slotOut<YBufferWriteOffset; slotOut++) { for (j=0; j<nSfb; j++) { - accu += (EnergiesM[slotOut][j] >> scale); + accu += (EnergiesM[slotOut][j] >> scale[0]); } } - nrgTotal = accu >> (scaleEnergies[0]-scale); + nrgTotal = accu >> (scaleEnergies[0]-scale[0]); + + for (slotOut=YBufferWriteOffset; slotOut<sbrSlots; slotOut++) { + for (j=0; j<nSfb; j++) { + accu += (EnergiesM[slotOut][j] >> scale[0]); + } + } + nrgTotal = accu >> (scaleEnergies[1]-scale[1]); } return(nrgTotal); @@ -299,18 +371,23 @@ FDKsbrEnc_frameSplitter(FIXP_DBL **Energies, int YBufferSzShift, int nSfb, int timeStep, - int no_cols) + int no_cols, + FIXP_DBL* tonality) { if (tran_vector[1]==0) /* no transient was detected */ { FIXP_DBL delta; - FIXP_DBL EnergiesM[NUMBER_TIME_SLOTS_2304][MAX_FREQ_COEFFS]; + INT delta_e; + FIXP_DBL (*EnergiesM)[MAX_FREQ_COEFFS]; FIXP_DBL EnergyTotal,newLowbandEnergy,newHighbandEnergy; INT border; INT sbrSlots = fMultI(GetInvInt(timeStep),no_cols); + C_ALLOC_SCRATCH_START(_EnergiesM, FIXP_DBL, NUMBER_TIME_SLOTS_2304*MAX_FREQ_COEFFS) FDK_ASSERT( sbrSlots * timeStep == no_cols ); + EnergiesM = (FIXP_DBL(*)[MAX_FREQ_COEFFS])_EnergiesM; + /* Get Lowband-energy over a range of 2 frames (Look half a frame back and ahead). */ @@ -324,16 +401,13 @@ FDKsbrEnc_frameSplitter(FIXP_DBL **Energies, newHighbandEnergy = addHighbandEnergies(Energies, scaleEnergies, + YBufferWriteOffset, EnergiesM, freqBandTable, nSfb, sbrSlots, timeStep); - if ( h_sbrTransientDetector->frameShift != 0 ) { - if (tran_vector[1]==0) - tran_vector[0] = 0; - } else { /* prevLowBandEnergy: Corresponds to 1 frame, starting with half a frame look-behind newLowbandEnergy: Corresponds to 1 frame, starting in the middle of the current frame */ @@ -343,23 +417,39 @@ FDKsbrEnc_frameSplitter(FIXP_DBL **Energies, of a FIXFIX-frame with 2 envelopes. */ border = (sbrSlots+1) >> 1; + if ( (INT)EnergyTotal&0xffffffe0 && (scaleEnergies[0]<32 || scaleEnergies[1]<32) ) /* i.e. > 31 */ { delta = spectralChange(EnergiesM, scaleEnergies, EnergyTotal, nSfb, 0, border, - sbrSlots); + YBufferWriteOffset, + sbrSlots, + &delta_e + ); + } else { + delta = FL2FXCONST_DBL(0.0f); + delta_e = 0; + + /* set tonality to 0 when energy is very low, since the amplitude + resolution should then be low as well */ + *tonality = FL2FXCONST_DBL(0.0f); + } + - if (delta > (h_sbrTransientDetector->split_thr >> LD_DATA_SHIFT)) /* delta scaled by 1/64 */ + if ( fIsLessThan(h_sbrTransientDetector->split_thr_m, h_sbrTransientDetector->split_thr_e, delta, delta_e) ) { tran_vector[0] = 1; /* Set flag for splitting */ - else + } else { tran_vector[0] = 0; + } + } /* Update prevLowBandEnergy */ h_sbrTransientDetector->prevLowBandEnergy = newLowbandEnergy; h_sbrTransientDetector->prevHighBandEnergy = newHighbandEnergy; + C_ALLOC_SCRATCH_END(_EnergiesM, FIXP_DBL, NUMBER_TIME_SLOTS_2304*MAX_FREQ_COEFFS) } } @@ -636,6 +726,7 @@ FDKsbrEnc_transientDetect(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTran, int FDKsbrEnc_InitSbrTransientDetector(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientDetector, + UINT sbrSyntaxFlags, /* SBR syntax flags derived from AOT. */ INT frameSize, INT sampleFreq, sbrConfigurationPtr params, @@ -649,8 +740,8 @@ FDKsbrEnc_InitSbrTransientDetector(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientD { INT totalBitrate = params->codecSettings.standardBitrate * params->codecSettings.nChannels; INT codecBitrate = params->codecSettings.bitRate; - FIXP_DBL bitrateFactor_fix, framedur_fix; - INT scale_0, scale_1; + FIXP_DBL bitrateFactor_m, framedur_fix; + INT bitrateFactor_e, tmp_e; FDKmemclear(h_sbrTransientDetector,sizeof(SBR_TRANSIENT_DETECTOR)); @@ -658,11 +749,12 @@ FDKsbrEnc_InitSbrTransientDetector(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientD h_sbrTransientDetector->tran_off = tran_off; if(codecBitrate) { - bitrateFactor_fix = fDivNorm((FIXP_DBL)totalBitrate, (FIXP_DBL)(codecBitrate<<2),&scale_0); + bitrateFactor_m = fDivNorm((FIXP_DBL)totalBitrate, (FIXP_DBL)(codecBitrate<<2),&bitrateFactor_e); + bitrateFactor_e += 2; } else { - bitrateFactor_fix = FL2FXCONST_DBL(1.0/4.0); - scale_0 = 0; + bitrateFactor_m = FL2FXCONST_DBL(1.0/4.0); + bitrateFactor_e = 2; } framedur_fix = fDivNorm(frameSize, sampleFreq); @@ -674,9 +766,13 @@ FDKsbrEnc_InitSbrTransientDetector(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientD FIXP_DBL tmp = framedur_fix - FL2FXCONST_DBL(0.010); tmp = fixMax(tmp, FL2FXCONST_DBL(0.0001)); - tmp = fDivNorm(FL2FXCONST_DBL(0.000075), fPow2(tmp), &scale_1); + tmp = fDivNorm(FL2FXCONST_DBL(0.000075), fPow2(tmp), &tmp_e); - scale_1 = (scale_1 + scale_0 + 2); + bitrateFactor_e = (tmp_e + bitrateFactor_e); + + if(sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) { + bitrateFactor_e--; /* divide by 2 */ + } FDK_ASSERT(no_cols <= QMF_MAX_TIME_SLOTS); FDK_ASSERT(no_rows <= QMF_CHANNELS); @@ -684,7 +780,8 @@ FDKsbrEnc_InitSbrTransientDetector(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientD h_sbrTransientDetector->no_cols = no_cols; h_sbrTransientDetector->tran_thr = (FIXP_DBL)((params->tran_thr << (32-24-1)) / no_rows); h_sbrTransientDetector->tran_fc = tran_fc; - h_sbrTransientDetector->split_thr = scaleValueSaturate(fMult(tmp, bitrateFactor_fix), scale_1); + h_sbrTransientDetector->split_thr_m = fMult(tmp, bitrateFactor_m); + h_sbrTransientDetector->split_thr_e = bitrateFactor_e; h_sbrTransientDetector->no_rows = no_rows; h_sbrTransientDetector->mode = params->tran_det_mode; h_sbrTransientDetector->prevLowBandEnergy = FL2FXCONST_DBL(0.0f); @@ -692,3 +789,281 @@ FDKsbrEnc_InitSbrTransientDetector(HANDLE_SBR_TRANSIENT_DETECTOR h_sbrTransientD return (0); } + +#define ENERGY_SCALING_SIZE 32 + +INT FDKsbrEnc_InitSbrFastTransientDetector( + HANDLE_FAST_TRAN_DET h_sbrFastTransientDetector, + const INT time_slots_per_frame, + const INT bandwidth_qmf_slot, + const INT no_qmf_channels, + const INT sbr_qmf_1st_band + ) +{ + + int i, e; + int buff_size; + FIXP_DBL myExp; + FIXP_DBL myExpSlot; + + h_sbrFastTransientDetector->lookahead = TRAN_DET_LOOKAHEAD; + h_sbrFastTransientDetector->nTimeSlots = time_slots_per_frame; + + buff_size = h_sbrFastTransientDetector->nTimeSlots + h_sbrFastTransientDetector->lookahead; + + for(i=0; i< buff_size; i++) { + h_sbrFastTransientDetector->delta_energy[i] = FL2FXCONST_DBL(0.0f); + h_sbrFastTransientDetector->energy_timeSlots[i] = FL2FXCONST_DBL(0.0f); + h_sbrFastTransientDetector->lowpass_energy[i] = FL2FXCONST_DBL(0.0f); + h_sbrFastTransientDetector->transientCandidates[i] = 0; + } + + FDK_ASSERT(bandwidth_qmf_slot > 0.f); + h_sbrFastTransientDetector->stopBand = fMin(TRAN_DET_STOP_FREQ/bandwidth_qmf_slot, no_qmf_channels); + h_sbrFastTransientDetector->startBand = fMin(sbr_qmf_1st_band, h_sbrFastTransientDetector->stopBand - TRAN_DET_MIN_QMFBANDS); + + FDK_ASSERT(h_sbrFastTransientDetector->startBand < no_qmf_channels); + FDK_ASSERT(h_sbrFastTransientDetector->startBand < h_sbrFastTransientDetector->stopBand); + FDK_ASSERT(h_sbrFastTransientDetector->startBand > 1); + FDK_ASSERT(h_sbrFastTransientDetector->stopBand > 1); + + /* the energy weighting and adding up has a headroom of 6 Bits, + so up to 64 bands can be added without potential overflow. */ + FDK_ASSERT(h_sbrFastTransientDetector->stopBand - h_sbrFastTransientDetector->startBand <= 64); + + /* QMF_HP_dB_SLOPE_FIX says that we want a 20 dB per 16 kHz HP filter. + The following lines map this to the QMF bandwidth. */ + #define EXP_E 7 /* QMF_CHANNELS (=64) multiplications max, max. allowed sum is 0.5 */ + myExp = fMultNorm(QMF_HP_dBd_SLOPE_FIX, (FIXP_DBL)bandwidth_qmf_slot, &e); + myExp = scaleValueSaturate(myExp, e+0+DFRACT_BITS-1-EXP_E); + myExpSlot = myExp; + + for(i=0; i<QMF_CHANNELS; i++){ + /* Calculate dBf over all qmf bands: + dBf = (10^(0.002266f/10*bw(slot)))^(band) = + = 2^(log2(10)*0.002266f/10*bw(slot)*band) = + = 2^(0.00075275f*bw(slot)*band) */ + + FIXP_DBL dBf_m; /* dBf mantissa */ + INT dBf_e; /* dBf exponent */ + INT tmp; + + INT dBf_int; /* dBf integer part */ + FIXP_DBL dBf_fract; /* dBf fractional part */ + + /* myExp*(i+1) = myExp_int - myExp_fract + myExp*(i+1) is split up here for better accuracy of CalcInvLdData(), + for its result can be split up into an integer and a fractional part */ + + /* Round up to next integer */ + FIXP_DBL myExp_int = (myExpSlot & (FIXP_DBL)0xfe000000) + (FIXP_DBL)0x02000000; + + /* This is the fractional part that needs to be substracted */ + FIXP_DBL myExp_fract = myExp_int - myExpSlot; + + /* Calc integer part */ + dBf_int = CalcInvLdData(myExp_int); + /* The result needs to be re-scaled. The ld(myExp_int) had been scaled by EXP_E, + the CalcInvLdData expects the operand to be scaled by LD_DATA_SHIFT. + Therefore, the correctly scaled result is dBf_int^(2^(EXP_E-LD_DATA_SHIFT)), + which is dBf_int^2 */ + dBf_int *= dBf_int; + + /* Calc fractional part */ + dBf_fract = CalcInvLdData(-myExp_fract); + /* The result needs to be re-scaled. The ld(myExp_fract) had been scaled by EXP_E, + the CalcInvLdData expects the operand to be scaled by LD_DATA_SHIFT. + Therefore, the correctly scaled result is dBf_fract^(2^(EXP_E-LD_DATA_SHIFT)), + which is dBf_fract^2 */ + dBf_fract = fMultNorm(dBf_fract, dBf_fract, &tmp); + + /* Get worst case scaling of multiplication result */ + dBf_e = (DFRACT_BITS-1 - tmp) - CountLeadingBits(dBf_int); + + /* Now multiply integer with fractional part of the result, thus resulting + in the overall accurate fractional result */ + dBf_m = fMultNorm(dBf_int, dBf_fract, &e); + dBf_m = scaleValueSaturate(dBf_m, e+DFRACT_BITS-1+tmp-dBf_e); + myExpSlot += myExp; + + /* Keep the results */ + h_sbrFastTransientDetector->dBf_m[i] = dBf_m; + h_sbrFastTransientDetector->dBf_e[i] = dBf_e; + + } + + /* Make sure that dBf is greater than 1.0 (because it should be a highpass) */ + /* ... */ + + return 0; +} + +void FDKsbrEnc_fastTransientDetect( + const HANDLE_FAST_TRAN_DET h_sbrFastTransientDetector, + const FIXP_DBL *const *Energies, + const int *const scaleEnergies, + const INT YBufferWriteOffset, + UCHAR *const tran_vector + ) +{ + int timeSlot, band; + + FIXP_DBL max_delta_energy; /* helper to store maximum energy ratio */ + int max_delta_energy_scale; /* helper to store scale of maximum energy ratio */ + int ind_max = 0; /* helper to store index of maximum energy ratio */ + int isTransientInFrame = 0; + + const int nTimeSlots = h_sbrFastTransientDetector->nTimeSlots; + const int lookahead = h_sbrFastTransientDetector->lookahead; + const int startBand = h_sbrFastTransientDetector->startBand; + const int stopBand = h_sbrFastTransientDetector->stopBand; + + int * transientCandidates = h_sbrFastTransientDetector->transientCandidates; + + FIXP_DBL * energy_timeSlots = h_sbrFastTransientDetector->energy_timeSlots; + int * energy_timeSlots_scale = h_sbrFastTransientDetector->energy_timeSlots_scale; + + FIXP_DBL * delta_energy = h_sbrFastTransientDetector->delta_energy; + int * delta_energy_scale = h_sbrFastTransientDetector->delta_energy_scale; + + const FIXP_DBL thr = TRAN_DET_THRSHLD; + const INT thr_scale = TRAN_DET_THRSHLD_SCALE; + + /*reset transient info*/ + tran_vector[2] = 0; + + /* reset transient candidates */ + FDKmemclear(transientCandidates+lookahead, nTimeSlots*sizeof(int)); + + for(timeSlot = lookahead; timeSlot < nTimeSlots + lookahead; timeSlot++) { + int i, norm; + FIXP_DBL tmpE = FL2FXCONST_DBL(0.0f); + int headroomEnSlot = DFRACT_BITS-1; + + FIXP_DBL smallNRG = FL2FXCONST_DBL(1e-2f); + FIXP_DBL denominator; + INT denominator_scale; + + /* determine minimum headroom of energy values for this timeslot */ + for(band = startBand; band < stopBand; band++) { + int tmp_headroom = fNormz(Energies[timeSlot][band])-1; + if(tmp_headroom < headroomEnSlot){ + headroomEnSlot = tmp_headroom; + } + } + + for(i = 0, band = startBand; band < stopBand; band++, i++) { + /* energy is weighted by weightingfactor stored in dBf_m array */ + /* dBf_m index runs from 0 to stopBand-startband */ + /* energy shifted by calculated headroom for maximum precision */ + FIXP_DBL weightedEnergy = fMult(Energies[timeSlot][band]<<headroomEnSlot, h_sbrFastTransientDetector->dBf_m[i]); + + /* energy is added up */ + /* shift by 6 to have a headroom for maximum 64 additions */ + /* shift by dBf_e to handle weighting factor dependent scale factors */ + tmpE += weightedEnergy >> (6 + (10 - h_sbrFastTransientDetector->dBf_e[i])); + } + + /* store calculated energy for timeslot */ + energy_timeSlots[timeSlot] = tmpE; + + /* calculate overall scale factor for energy of this timeslot */ + /* = original scale factor of energies (-scaleEnergies[0]+2*QMF_SCALE_OFFSET or -scaleEnergies[1]+2*QMF_SCALE_OFFSET */ + /* depending on YBufferWriteOffset) */ + /* + weighting factor scale (10) */ + /* + adding up scale factor ( 6) */ + /* - headroom of energy value (headroomEnSlot) */ + if(timeSlot < YBufferWriteOffset){ + energy_timeSlots_scale[timeSlot] = (-scaleEnergies[0]+2*QMF_SCALE_OFFSET) + (10+6) - headroomEnSlot; + } else { + energy_timeSlots_scale[timeSlot] = (-scaleEnergies[1]+2*QMF_SCALE_OFFSET) + (10+6) - headroomEnSlot; + } + + /* Add a small energy to the denominator, thus making the transient + detection energy-dependent. Loud transients are being detected, + silent ones not. */ + + /* make sure that smallNRG does not overflow */ + if ( -energy_timeSlots_scale[timeSlot-1] + 1 > 5 ) + { + denominator = smallNRG; + denominator_scale = 0; + } else { + /* Leave an additional headroom of 1 bit for this addition. */ + smallNRG = scaleValue(smallNRG, -(energy_timeSlots_scale[timeSlot-1] + 1)); + denominator = (energy_timeSlots[timeSlot-1]>>1) + smallNRG; + denominator_scale = energy_timeSlots_scale[timeSlot-1]+1; + } + + delta_energy[timeSlot] = fDivNorm(energy_timeSlots[timeSlot], denominator, &norm); + delta_energy_scale[timeSlot] = energy_timeSlots_scale[timeSlot] - denominator_scale + norm; + } + + /*get transient candidates*/ + /* For every timeslot, check if delta(E) exceeds the threshold. If it did, + it could potentially be marked as a transient candidate. However, the 2 + slots before the current one must not be transients with an energy higher + than 1.4*E(current). If both aren't transients or if the energy of the + current timesolot is more than 1.4 times higher than the energy in the + last or the one before the last slot, it is marked as a transient.*/ + + FDK_ASSERT(lookahead >= 2); + for(timeSlot = lookahead; timeSlot < nTimeSlots + lookahead; timeSlot++) { + FIXP_DBL energy_cur_slot_weighted = fMult(energy_timeSlots[timeSlot],FL2FXCONST_DBL(1.0f/1.4f)); + if( !fIsLessThan(delta_energy[timeSlot], delta_energy_scale[timeSlot], thr, thr_scale) && + ( ((transientCandidates[timeSlot-2]==0) && (transientCandidates[timeSlot-1]==0)) || + !fIsLessThan(energy_cur_slot_weighted, energy_timeSlots_scale[timeSlot], energy_timeSlots[timeSlot-1], energy_timeSlots_scale[timeSlot-1] ) || + !fIsLessThan(energy_cur_slot_weighted, energy_timeSlots_scale[timeSlot], energy_timeSlots[timeSlot-2], energy_timeSlots_scale[timeSlot-2] ) + ) + ) +{ + /* in case of strong transients, subsequent + * qmf slots might be recognized as transients. */ + transientCandidates[timeSlot] = 1; + } + } + + /*get transient with max energy*/ + max_delta_energy = FL2FXCONST_DBL(0.0f); + max_delta_energy_scale = 0; + ind_max = 0; + isTransientInFrame = 0; + for(timeSlot = 0; timeSlot < nTimeSlots; timeSlot++) { + int scale = fMax(delta_energy_scale[timeSlot], max_delta_energy_scale); + if(transientCandidates[timeSlot] && ( (delta_energy[timeSlot] >> (scale - delta_energy_scale[timeSlot])) > (max_delta_energy >> (scale - max_delta_energy_scale)) ) ) { + max_delta_energy = delta_energy[timeSlot]; + max_delta_energy_scale = scale; + ind_max = timeSlot; + isTransientInFrame = 1; + } + } + + /*from all transient candidates take the one with the biggest energy*/ + if(isTransientInFrame) { + tran_vector[0] = ind_max; + tran_vector[1] = 1; + } else { + /*reset transient info*/ + tran_vector[0] = tran_vector[1] = 0; + } + + /*check for transients in lookahead*/ + for(timeSlot = nTimeSlots; timeSlot < nTimeSlots + lookahead; timeSlot++) { + if(transientCandidates[timeSlot]) { + tran_vector[2] = 1; + } + } + + /*update buffers*/ + for(timeSlot = 0; timeSlot < lookahead; timeSlot++) { + transientCandidates[timeSlot] = transientCandidates[nTimeSlots + timeSlot]; + + /* fixpoint stuff */ + energy_timeSlots[timeSlot] = energy_timeSlots[nTimeSlots + timeSlot]; + energy_timeSlots_scale[timeSlot] = energy_timeSlots_scale[nTimeSlots + timeSlot]; + + delta_energy[timeSlot] = delta_energy[nTimeSlots + timeSlot]; + delta_energy_scale[timeSlot] = delta_energy_scale[nTimeSlots + timeSlot]; + } +} + |