void WebRtcIlbcfix_CbMemEnergy(int16_t range, int16_t * CB, /* (i) The CB memory (1:st section) */ int16_t * filteredCB, /* (i) The filtered CB memory (2:nd section) */ int16_t lMem, /* (i) Length of the CB memory */ int16_t lTarget, /* (i) Length of the target vector */ int16_t * energyW16, /* (o) Energy in the CB vectors */ int16_t * energyShifts, /* (o) Shift value of the energy */ int16_t scale, /* (i) The scaling of all energy values */ int16_t base_size /* (i) Index to where the energy values should be stored */ ) { int16_t *ppi, *ppo, *pp; int32_t energy, tmp32; /* Compute the energy and store it in a vector. Also the * corresponding shift values are stored. The energy values * are reused in all three stages. */ /* Calculate the energy in the first block of 'lTarget' sampels. */ ppi = CB + lMem - lTarget - 1; ppo = CB + lMem - 1; pp = CB + lMem - lTarget; energy = WebRtcSpl_DotProductWithScale(pp, pp, lTarget, scale); /* Normalize the energy and store the number of shifts */ energyShifts[0] = (int16_t) WebRtcSpl_NormW32(energy); tmp32 = WEBRTC_SPL_LSHIFT_W32(energy, energyShifts[0]); energyW16[0] = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32, 16); /* Compute the energy of the rest of the cb memory * by step wise adding and subtracting the next * sample and the last sample respectively. */ WebRtcIlbcfix_CbMemEnergyCalc(energy, range, ppi, ppo, energyW16, energyShifts, scale, 0); /* Next, precompute the energy values for the filtered cb section */ pp = filteredCB + lMem - lTarget; energy = WebRtcSpl_DotProductWithScale(pp, pp, lTarget, scale); /* Normalize the energy and store the number of shifts */ energyShifts[base_size] = (int16_t) WebRtcSpl_NormW32(energy); tmp32 = WEBRTC_SPL_LSHIFT_W32(energy, energyShifts[base_size]); energyW16[base_size] = (int16_t) WEBRTC_SPL_RSHIFT_W32(tmp32, 16); ppi = filteredCB + lMem - 1 - lTarget; ppo = filteredCB + lMem - 1; WebRtcIlbcfix_CbMemEnergyCalc(energy, range, ppi, ppo, energyW16, energyShifts, scale, base_size); }
void WebRtcIlbcfix_CbMemEnergyAugmentation( int16_t *interpSamples, /* (i) The interpolated samples */ int16_t *CBmem, /* (i) The CB memory */ int16_t scale, /* (i) The scaling of all energy values */ int16_t base_size, /* (i) Index to where the energy values should be stored */ int16_t *energyW16, /* (o) Energy in the CB vectors */ int16_t *energyShifts /* (o) Shift value of the energy */ ){ int32_t energy, tmp32; int16_t *ppe, *pp, *interpSamplesPtr; int16_t *CBmemPtr, lagcount; int16_t *enPtr=&energyW16[base_size-20]; int16_t *enShPtr=&energyShifts[base_size-20]; int32_t nrjRecursive; CBmemPtr = CBmem+147; interpSamplesPtr = interpSamples; /* Compute the energy for the first (low-5) noninterpolated samples */ nrjRecursive = WebRtcSpl_DotProductWithScale( CBmemPtr-19, CBmemPtr-19, 15, scale); ppe = CBmemPtr - 20; for (lagcount=20; lagcount<=39; lagcount++) { /* Update the energy recursively to save complexity */ nrjRecursive = nrjRecursive + WEBRTC_SPL_MUL_16_16_RSFT(*ppe, *ppe, scale); ppe--; energy = nrjRecursive; /* interpolation */ energy += WebRtcSpl_DotProductWithScale(interpSamplesPtr, interpSamplesPtr, 4, scale); interpSamplesPtr += 4; /* Compute energy for the remaining samples */ pp = CBmemPtr - lagcount; energy += WebRtcSpl_DotProductWithScale(pp, pp, SUBL-lagcount, scale); /* Normalize the energy and store the number of shifts */ (*enShPtr) = (int16_t)WebRtcSpl_NormW32(energy); tmp32 = WEBRTC_SPL_LSHIFT_W32(energy, (*enShPtr)); (*enPtr) = (int16_t)WEBRTC_SPL_RSHIFT_W32(tmp32, 16); enShPtr++; enPtr++; } }
void WebRtcIlbcfix_AugmentedCbCorr( int16_t *target, /* (i) Target vector */ int16_t *buffer, /* (i) Memory buffer */ int16_t *interpSamples, /* (i) buffer with interpolated samples */ int32_t *crossDot, /* (o) The cross correlation between the target and the Augmented vector */ int16_t low, /* (i) Lag to start from (typically 20) */ int16_t high, /* (i) Lag to end at (typically 39) */ int scale) /* (i) Scale factor to use for the crossDot */ { int lagcount; int16_t ilow; int16_t *targetPtr; int32_t *crossDotPtr; int16_t *iSPtr=interpSamples; /* Calculate the correlation between the target and the interpolated codebook. The correlation is calculated in 3 sections with the interpolated part in the middle */ crossDotPtr=crossDot; for (lagcount=low; lagcount<=high; lagcount++) { ilow = (int16_t) (lagcount-4); /* Compute dot product for the first (lagcount-4) samples */ (*crossDotPtr) = WebRtcSpl_DotProductWithScale(target, buffer-lagcount, ilow, scale); /* Compute dot product on the interpolated samples */ (*crossDotPtr) += WebRtcSpl_DotProductWithScale(target+ilow, iSPtr, 4, scale); targetPtr = target + lagcount; iSPtr += lagcount-ilow; /* Compute dot product for the remaining samples */ (*crossDotPtr) += WebRtcSpl_DotProductWithScale(targetPtr, buffer-lagcount, SUBL-lagcount, scale); crossDotPtr++; } }
void WebRtcIlbcfix_CompCorr( int32_t *corr, /* (o) cross correlation */ int32_t *ener, /* (o) energy */ int16_t *buffer, /* (i) signal buffer */ int16_t lag, /* (i) pitch lag */ int16_t bLen, /* (i) length of buffer */ int16_t sRange, /* (i) correlation search length */ int16_t scale /* (i) number of rightshifts to use */ ){ int16_t *w16ptr; w16ptr=&buffer[bLen-sRange-lag]; /* Calculate correlation and energy */ (*corr)=WebRtcSpl_DotProductWithScale(&buffer[bLen-sRange], w16ptr, sRange, scale); (*ener)=WebRtcSpl_DotProductWithScale(w16ptr, w16ptr, sRange, scale); /* For zero energy set the energy to 0 in order to avoid potential problems for coming divisions */ if (*ener == 0) { *corr = 0; *ener = 1; } }
void WebRtcIlbcfix_EncodeImpl( WebRtc_UWord16 *bytes, /* (o) encoded data bits iLBC */ const WebRtc_Word16 *block, /* (i) speech vector to encode */ iLBC_Enc_Inst_t *iLBCenc_inst /* (i/o) the general encoder state */ ){ int n, meml_gotten, Nfor, Nback; WebRtc_Word16 diff, start_pos; int index; int subcount, subframe; WebRtc_Word16 start_count, end_count; WebRtc_Word16 *residual; WebRtc_Word32 en1, en2; WebRtc_Word16 scale, max; WebRtc_Word16 *syntdenum; WebRtc_Word16 *decresidual; WebRtc_Word16 *reverseResidual; WebRtc_Word16 *reverseDecresidual; /* Stack based */ WebRtc_Word16 weightdenum[(LPC_FILTERORDER + 1)*NSUB_MAX]; WebRtc_Word16 dataVec[BLOCKL_MAX + LPC_FILTERORDER]; WebRtc_Word16 memVec[CB_MEML+CB_FILTERLEN]; WebRtc_Word16 bitsMemory[sizeof(iLBC_bits)/sizeof(WebRtc_Word16)]; iLBC_bits *iLBCbits_inst = (iLBC_bits*)bitsMemory; #ifdef SPLIT_10MS WebRtc_Word16 *weightdenumbuf = iLBCenc_inst->weightdenumbuf; WebRtc_Word16 last_bit; #endif WebRtc_Word16 *data = &dataVec[LPC_FILTERORDER]; WebRtc_Word16 *mem = &memVec[CB_HALFFILTERLEN]; /* Reuse som buffers to save stack memory */ residual = &iLBCenc_inst->lpc_buffer[LPC_LOOKBACK+BLOCKL_MAX-iLBCenc_inst->blockl]; syntdenum = mem; /* syntdenum[(LPC_FILTERORDER + 1)*NSUB_MAX] and mem are used non overlapping in the code */ decresidual = residual; /* Already encoded residual is overwritten by the decoded version */ reverseResidual = data; /* data and reverseResidual are used non overlapping in the code */ reverseDecresidual = reverseResidual; /* Already encoded residual is overwritten by the decoded version */ #ifdef SPLIT_10MS WebRtcSpl_MemSetW16 ( (WebRtc_Word16 *) iLBCbits_inst, 0, (WebRtc_Word16) (sizeof(iLBC_bits) / sizeof(WebRtc_Word16)) ); start_pos = iLBCenc_inst->start_pos; diff = iLBCenc_inst->diff; if (iLBCenc_inst->section != 0){ WEBRTC_SPL_MEMCPY_W16 (weightdenum, weightdenumbuf, SCRATCH_ENCODE_DATAVEC - SCRATCH_ENCODE_WEIGHTDENUM); /* Un-Packetize the frame into parameters */ last_bit = WebRtcIlbcfix_UnpackBits (iLBCenc_inst->bytes, iLBCbits_inst, iLBCenc_inst->mode); if (last_bit) return; /* adjust index */ WebRtcIlbcfix_IndexConvDec (iLBCbits_inst->cb_index); if (iLBCenc_inst->section == 1){ /* Save first 80 samples of a 160/240 sample frame for 20/30msec */ WEBRTC_SPL_MEMCPY_W16 (iLBCenc_inst->past_samples, block, 80); } else{ // iLBCenc_inst->section == 2 AND mode = 30ms /* Save second 80 samples of a 240 sample frame for 30msec */ WEBRTC_SPL_MEMCPY_W16 (iLBCenc_inst->past_samples + 80, block, 80); } } else{ // iLBCenc_inst->section == 0 /* form a complete frame of 160/240 for 20msec/30msec mode */ WEBRTC_SPL_MEMCPY_W16 (data + (iLBCenc_inst->mode * 8) - 80, block, 80); WEBRTC_SPL_MEMCPY_W16 (data, iLBCenc_inst->past_samples, (iLBCenc_inst->mode * 8) - 80); iLBCenc_inst->Nfor_flag = 0; iLBCenc_inst->Nback_flag = 0; #else /* copy input block to data*/ WEBRTC_SPL_MEMCPY_W16(data,block,iLBCenc_inst->blockl); #endif /* high pass filtering of input signal and scale down the residual (*0.5) */ WebRtcIlbcfix_HpInput(data, (WebRtc_Word16*)WebRtcIlbcfix_kHpInCoefs, iLBCenc_inst->hpimemy, iLBCenc_inst->hpimemx, iLBCenc_inst->blockl); /* LPC of hp filtered input data */ WebRtcIlbcfix_LpcEncode(syntdenum, weightdenum, iLBCbits_inst->lsf, data, iLBCenc_inst); /* Set up state */ WEBRTC_SPL_MEMCPY_W16(dataVec, iLBCenc_inst->anaMem, LPC_FILTERORDER); /* inverse filter to get residual */ for (n=0; n<iLBCenc_inst->nsub; n++ ) { WebRtcSpl_FilterMAFastQ12( &data[n*SUBL], &residual[n*SUBL], &syntdenum[n*(LPC_FILTERORDER+1)], LPC_FILTERORDER+1, SUBL); } /* Copy the state for next frame */ WEBRTC_SPL_MEMCPY_W16(iLBCenc_inst->anaMem, &data[iLBCenc_inst->blockl-LPC_FILTERORDER], LPC_FILTERORDER); /* find state location */ iLBCbits_inst->startIdx = WebRtcIlbcfix_FrameClassify(iLBCenc_inst,residual); /* check if state should be in first or last part of the two subframes */ index = (iLBCbits_inst->startIdx-1)*SUBL; max=WebRtcSpl_MaxAbsValueW16(&residual[index], 2*SUBL); scale=WebRtcSpl_GetSizeInBits(WEBRTC_SPL_MUL_16_16(max,max)); /* Scale to maximum 25 bits so that the MAC won't cause overflow */ scale = scale - 25; if(scale < 0) { scale = 0; } diff = STATE_LEN - iLBCenc_inst->state_short_len; en1=WebRtcSpl_DotProductWithScale(&residual[index], &residual[index], iLBCenc_inst->state_short_len, scale); index += diff; en2=WebRtcSpl_DotProductWithScale(&residual[index], &residual[index], iLBCenc_inst->state_short_len, scale); if (en1 > en2) { iLBCbits_inst->state_first = 1; start_pos = (iLBCbits_inst->startIdx-1)*SUBL; } else { iLBCbits_inst->state_first = 0; start_pos = (iLBCbits_inst->startIdx-1)*SUBL + diff; } /* scalar quantization of state */ WebRtcIlbcfix_StateSearch(iLBCenc_inst, iLBCbits_inst, &residual[start_pos], &syntdenum[(iLBCbits_inst->startIdx-1)*(LPC_FILTERORDER+1)], &weightdenum[(iLBCbits_inst->startIdx-1)*(LPC_FILTERORDER+1)]); WebRtcIlbcfix_StateConstruct(iLBCbits_inst->idxForMax, iLBCbits_inst->idxVec, &syntdenum[(iLBCbits_inst->startIdx-1)*(LPC_FILTERORDER+1)], &decresidual[start_pos], iLBCenc_inst->state_short_len ); /* predictive quantization in state */ if (iLBCbits_inst->state_first) { /* put adaptive part in the end */ /* setup memory */ WebRtcSpl_MemSetW16(mem, 0, (WebRtc_Word16)(CB_MEML-iLBCenc_inst->state_short_len)); WEBRTC_SPL_MEMCPY_W16(mem+CB_MEML-iLBCenc_inst->state_short_len, decresidual+start_pos, iLBCenc_inst->state_short_len); /* encode subframes */ WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index, iLBCbits_inst->gain_index, &residual[start_pos+iLBCenc_inst->state_short_len], mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL, diff, &weightdenum[iLBCbits_inst->startIdx*(LPC_FILTERORDER+1)], 0); /* construct decoded vector */ WebRtcIlbcfix_CbConstruct(&decresidual[start_pos+iLBCenc_inst->state_short_len], iLBCbits_inst->cb_index, iLBCbits_inst->gain_index, mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL, diff ); } else { /* put adaptive part in the beginning */ /* create reversed vectors for prediction */ WebRtcSpl_MemCpyReversedOrder(&reverseResidual[diff-1], &residual[(iLBCbits_inst->startIdx+1)*SUBL-STATE_LEN], diff); /* setup memory */ meml_gotten = iLBCenc_inst->state_short_len; WebRtcSpl_MemCpyReversedOrder(&mem[CB_MEML-1], &decresidual[start_pos], meml_gotten); WebRtcSpl_MemSetW16(mem, 0, (WebRtc_Word16)(CB_MEML-iLBCenc_inst->state_short_len)); /* encode subframes */ WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index, iLBCbits_inst->gain_index, reverseResidual, mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL, diff, &weightdenum[(iLBCbits_inst->startIdx-1)*(LPC_FILTERORDER+1)], 0); /* construct decoded vector */ WebRtcIlbcfix_CbConstruct(reverseDecresidual, iLBCbits_inst->cb_index, iLBCbits_inst->gain_index, mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL, diff ); /* get decoded residual from reversed vector */ WebRtcSpl_MemCpyReversedOrder(&decresidual[start_pos-1], reverseDecresidual, diff); } #ifdef SPLIT_10MS iLBCenc_inst->start_pos = start_pos; iLBCenc_inst->diff = diff; iLBCenc_inst->section++; /* adjust index */ WebRtcIlbcfix_IndexConvEnc (iLBCbits_inst->cb_index); /* Packetize the parameters into the frame */ WebRtcIlbcfix_PackBits (iLBCenc_inst->bytes, iLBCbits_inst, iLBCenc_inst->mode); WEBRTC_SPL_MEMCPY_W16 (weightdenumbuf, weightdenum, SCRATCH_ENCODE_DATAVEC - SCRATCH_ENCODE_WEIGHTDENUM); return; } #endif /* forward prediction of subframes */ Nfor = iLBCenc_inst->nsub-iLBCbits_inst->startIdx-1; /* counter for predicted subframes */ #ifdef SPLIT_10MS if (iLBCenc_inst->mode == 20) { subcount = 1; } if (iLBCenc_inst->mode == 30) { if (iLBCenc_inst->section == 1) { subcount = 1; } if (iLBCenc_inst->section == 2) { subcount = 3; } } #else subcount=1; #endif if( Nfor > 0 ){ /* setup memory */ WebRtcSpl_MemSetW16(mem, 0, CB_MEML-STATE_LEN); WEBRTC_SPL_MEMCPY_W16(mem+CB_MEML-STATE_LEN, decresidual+(iLBCbits_inst->startIdx-1)*SUBL, STATE_LEN); #ifdef SPLIT_10MS if (iLBCenc_inst->Nfor_flag > 0) { for (subframe = 0; subframe < WEBRTC_SPL_MIN (Nfor, 2); subframe++) { /* update memory */ WEBRTC_SPL_MEMCPY_W16 (mem, mem + SUBL, (CB_MEML - SUBL)); WEBRTC_SPL_MEMCPY_W16 (mem + CB_MEML - SUBL, &decresidual[(iLBCbits_inst->startIdx + 1 + subframe) * SUBL], SUBL); } } iLBCenc_inst->Nfor_flag++; if (iLBCenc_inst->mode == 20) { start_count = 0; end_count = Nfor; } if (iLBCenc_inst->mode == 30) { if (iLBCenc_inst->section == 1) { start_count = 0; end_count = WEBRTC_SPL_MIN (Nfor, 2); } if (iLBCenc_inst->section == 2) { start_count = WEBRTC_SPL_MIN (Nfor, 2); end_count = Nfor; } } #else start_count = 0; end_count = (WebRtc_Word16)Nfor; #endif /* loop over subframes to encode */ for (subframe = start_count; subframe < end_count; subframe++){ /* encode subframe */ WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index+subcount*CB_NSTAGES, iLBCbits_inst->gain_index+subcount*CB_NSTAGES, &residual[(iLBCbits_inst->startIdx+1+subframe)*SUBL], mem, MEM_LF_TBL, SUBL, &weightdenum[(iLBCbits_inst->startIdx+1+subframe)*(LPC_FILTERORDER+1)], (WebRtc_Word16)subcount); /* construct decoded vector */ WebRtcIlbcfix_CbConstruct(&decresidual[(iLBCbits_inst->startIdx+1+subframe)*SUBL], iLBCbits_inst->cb_index+subcount*CB_NSTAGES, iLBCbits_inst->gain_index+subcount*CB_NSTAGES, mem, MEM_LF_TBL, SUBL ); /* update memory */ WEBRTC_SPL_MEMMOVE_W16(mem, mem+SUBL, (CB_MEML-SUBL)); WEBRTC_SPL_MEMCPY_W16(mem+CB_MEML-SUBL, &decresidual[(iLBCbits_inst->startIdx+1+subframe)*SUBL], SUBL); subcount++; } } #ifdef SPLIT_10MS if ((iLBCenc_inst->section == 1) && (iLBCenc_inst->mode == 30) && (Nfor > 0) && (end_count == 2)) { iLBCenc_inst->section++; /* adjust index */ WebRtcIlbcfix_IndexConvEnc (iLBCbits_inst->cb_index); /* Packetize the parameters into the frame */ WebRtcIlbcfix_PackBits (iLBCenc_inst->bytes, iLBCbits_inst, iLBCenc_inst->mode); WEBRTC_SPL_MEMCPY_W16 (weightdenumbuf, weightdenum, SCRATCH_ENCODE_DATAVEC - SCRATCH_ENCODE_WEIGHTDENUM); return; } #endif /* backward prediction of subframes */ Nback = iLBCbits_inst->startIdx-1; if( Nback > 0 ){ /* create reverse order vectors (The decresidual does not need to be copied since it is contained in the same vector as the residual) */ WebRtcSpl_MemCpyReversedOrder(&reverseResidual[Nback*SUBL-1], residual, Nback*SUBL); /* setup memory */ meml_gotten = SUBL*(iLBCenc_inst->nsub+1-iLBCbits_inst->startIdx); if( meml_gotten > CB_MEML ) { meml_gotten=CB_MEML; } WebRtcSpl_MemCpyReversedOrder(&mem[CB_MEML-1], &decresidual[Nback*SUBL], meml_gotten); WebRtcSpl_MemSetW16(mem, 0, (WebRtc_Word16)(CB_MEML-meml_gotten)); #ifdef SPLIT_10MS if (iLBCenc_inst->Nback_flag > 0) { for (subframe = 0; subframe < WEBRTC_SPL_MAX (2 - Nfor, 0); subframe++) { /* update memory */ WEBRTC_SPL_MEMCPY_W16 (mem, mem + SUBL, (CB_MEML - SUBL)); WEBRTC_SPL_MEMCPY_W16 (mem + CB_MEML - SUBL, &reverseDecresidual[subframe * SUBL], SUBL); } } iLBCenc_inst->Nback_flag++; if (iLBCenc_inst->mode == 20) { start_count = 0; end_count = Nback; } if (iLBCenc_inst->mode == 30) { if (iLBCenc_inst->section == 1) { start_count = 0; end_count = WEBRTC_SPL_MAX (2 - Nfor, 0); } if (iLBCenc_inst->section == 2) { start_count = WEBRTC_SPL_MAX (2 - Nfor, 0); end_count = Nback; } } #else start_count = 0; end_count = (WebRtc_Word16)Nback; #endif /* loop over subframes to encode */ for (subframe = start_count; subframe < end_count; subframe++){ /* encode subframe */ WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index+subcount*CB_NSTAGES, iLBCbits_inst->gain_index+subcount*CB_NSTAGES, &reverseResidual[subframe*SUBL], mem, MEM_LF_TBL, SUBL, &weightdenum[(iLBCbits_inst->startIdx-2-subframe)*(LPC_FILTERORDER+1)], (WebRtc_Word16)subcount); /* construct decoded vector */ WebRtcIlbcfix_CbConstruct(&reverseDecresidual[subframe*SUBL], iLBCbits_inst->cb_index+subcount*CB_NSTAGES, iLBCbits_inst->gain_index+subcount*CB_NSTAGES, mem, MEM_LF_TBL, SUBL ); /* update memory */ WEBRTC_SPL_MEMMOVE_W16(mem, mem+SUBL, (CB_MEML-SUBL)); WEBRTC_SPL_MEMCPY_W16(mem+CB_MEML-SUBL, &reverseDecresidual[subframe*SUBL], SUBL); subcount++; } /* get decoded residual from reversed vector */ WebRtcSpl_MemCpyReversedOrder(&decresidual[SUBL*Nback-1], reverseDecresidual, SUBL*Nback); } /* end encoding part */ /* adjust index */ WebRtcIlbcfix_IndexConvEnc(iLBCbits_inst->cb_index); /* Packetize the parameters into the frame */ #ifdef SPLIT_10MS if( (iLBCenc_inst->mode==30) && (iLBCenc_inst->section==1) ){ WebRtcIlbcfix_PackBits(iLBCenc_inst->bytes, iLBCbits_inst, iLBCenc_inst->mode); } else{ WebRtcIlbcfix_PackBits(bytes, iLBCbits_inst, iLBCenc_inst->mode); } #else WebRtcIlbcfix_PackBits(bytes, iLBCbits_inst, iLBCenc_inst->mode); #endif #ifndef WEBRTC_BIG_ENDIAN /* Swap bytes for LITTLE ENDIAN since the packbits() function assumes BIG_ENDIAN machine */ #ifdef SPLIT_10MS if (( (iLBCenc_inst->section == 1) && (iLBCenc_inst->mode == 20) ) || ( (iLBCenc_inst->section == 2) && (iLBCenc_inst->mode == 30) )){ WebRtcIlbcfix_SwapBytes(bytes, iLBCenc_inst->no_of_words, bytes); } #else WebRtcIlbcfix_SwapBytes(bytes, iLBCenc_inst->no_of_words, bytes); #endif #endif #ifdef SPLIT_10MS if (subcount == (iLBCenc_inst->nsub - 1)) { iLBCenc_inst->section = 0; } else { iLBCenc_inst->section++; WEBRTC_SPL_MEMCPY_W16 (weightdenumbuf, weightdenum, SCRATCH_ENCODE_DATAVEC - SCRATCH_ENCODE_WEIGHTDENUM); } #endif }
int WebRtcIlbcfix_XcorrCoef( WebRtc_Word16 *target, /* (i) first array */ WebRtc_Word16 *regressor, /* (i) second array */ WebRtc_Word16 subl, /* (i) dimension arrays */ WebRtc_Word16 searchLen, /* (i) the search lenght */ WebRtc_Word16 offset, /* (i) samples offset between arrays */ WebRtc_Word16 step /* (i) +1 or -1 */ ){ int k; WebRtc_Word16 maxlag; WebRtc_Word16 pos; WebRtc_Word16 max; WebRtc_Word16 crossCorrScale, Energyscale; WebRtc_Word16 crossCorrSqMod, crossCorrSqMod_Max; WebRtc_Word32 crossCorr, Energy; WebRtc_Word16 crossCorrmod, EnergyMod, EnergyMod_Max; WebRtc_Word16 *tp, *rp; WebRtc_Word16 *rp_beg, *rp_end; WebRtc_Word16 totscale, totscale_max; WebRtc_Word16 scalediff; WebRtc_Word32 newCrit, maxCrit; int shifts; /* Initializations, to make sure that the first one is selected */ crossCorrSqMod_Max=0; EnergyMod_Max=WEBRTC_SPL_WORD16_MAX; totscale_max=-500; maxlag=0; pos=0; /* Find scale value and start position */ if (step==1) { max=WebRtcSpl_MaxAbsValueW16(regressor, (WebRtc_Word16)(subl+searchLen-1)); rp_beg = regressor; rp_end = ®ressor[subl]; } else { /* step==-1 */ max=WebRtcSpl_MaxAbsValueW16(®ressor[-searchLen], (WebRtc_Word16)(subl+searchLen-1)); rp_beg = ®ressor[-1]; rp_end = ®ressor[subl-1]; } /* Introduce a scale factor on the Energy in WebRtc_Word32 in order to make sure that the calculation does not overflow */ if (max>5000) { shifts=2; } else { shifts=0; } /* Calculate the first energy, then do a +/- to get the other energies */ Energy=WebRtcSpl_DotProductWithScale(regressor, regressor, subl, shifts); for (k=0;k<searchLen;k++) { tp = target; rp = ®ressor[pos]; crossCorr=WebRtcSpl_DotProductWithScale(tp, rp, subl, shifts); if ((Energy>0)&&(crossCorr>0)) { /* Put cross correlation and energy on 16 bit word */ crossCorrScale=(WebRtc_Word16)WebRtcSpl_NormW32(crossCorr)-16; crossCorrmod=(WebRtc_Word16)WEBRTC_SPL_SHIFT_W32(crossCorr, crossCorrScale); Energyscale=(WebRtc_Word16)WebRtcSpl_NormW32(Energy)-16; EnergyMod=(WebRtc_Word16)WEBRTC_SPL_SHIFT_W32(Energy, Energyscale); /* Square cross correlation and store upper WebRtc_Word16 */ crossCorrSqMod=(WebRtc_Word16)WEBRTC_SPL_MUL_16_16_RSFT(crossCorrmod, crossCorrmod, 16); /* Calculate the total number of (dynamic) right shifts that have been performed on (crossCorr*crossCorr)/energy */ totscale=Energyscale-(crossCorrScale<<1); /* Calculate the shift difference in order to be able to compare the two (crossCorr*crossCorr)/energy in the same domain */ scalediff=totscale-totscale_max; scalediff=WEBRTC_SPL_MIN(scalediff,31); scalediff=WEBRTC_SPL_MAX(scalediff,-31); /* Compute the cross multiplication between the old best criteria and the new one to be able to compare them without using a division */ if (scalediff<0) { newCrit = ((WebRtc_Word32)crossCorrSqMod*EnergyMod_Max)>>(-scalediff); maxCrit = ((WebRtc_Word32)crossCorrSqMod_Max*EnergyMod); } else {
void WebRtcIlbcfix_CbSearch( IlbcEncoder *iLBCenc_inst, /* (i) the encoder state structure */ int16_t *index, /* (o) Codebook indices */ int16_t *gain_index, /* (o) Gain quantization indices */ int16_t *intarget, /* (i) Target vector for encoding */ int16_t *decResidual,/* (i) Decoded residual for codebook construction */ int16_t lMem, /* (i) Length of buffer */ int16_t lTarget, /* (i) Length of vector */ int16_t *weightDenum,/* (i) weighting filter coefficients in Q12 */ int16_t block /* (i) the subblock number */ ) { int16_t i, j, stage, range; int16_t *pp, scale, tmp; int16_t bits, temp1, temp2; int16_t base_size; int32_t codedEner, targetEner; int16_t gains[CB_NSTAGES+1]; int16_t *cb_vecPtr; int16_t indexOffset, sInd, eInd; int32_t CritMax=0; int16_t shTotMax=WEBRTC_SPL_WORD16_MIN; int16_t bestIndex=0; int16_t bestGain=0; int16_t indexNew, CritNewSh; int32_t CritNew; int32_t *cDotPtr; int16_t noOfZeros; int16_t *gainPtr; int32_t t32, tmpW32; int16_t *WebRtcIlbcfix_kGainSq5_ptr; /* Stack based */ int16_t CBbuf[CB_MEML+LPC_FILTERORDER+CB_HALFFILTERLEN]; int32_t cDot[128]; int32_t Crit[128]; int16_t targetVec[SUBL+LPC_FILTERORDER]; int16_t cbvectors[CB_MEML + 1]; /* Adding one extra position for Coverity warnings. */ int16_t codedVec[SUBL]; int16_t interpSamples[20*4]; int16_t interpSamplesFilt[20*4]; int16_t energyW16[CB_EXPAND*128]; int16_t energyShifts[CB_EXPAND*128]; int16_t *inverseEnergy=energyW16; /* Reuse memory */ int16_t *inverseEnergyShifts=energyShifts; /* Reuse memory */ int16_t *buf = &CBbuf[LPC_FILTERORDER]; int16_t *target = &targetVec[LPC_FILTERORDER]; int16_t *aug_vec = (int16_t*)cDot; /* length [SUBL], reuse memory */ /* Determine size of codebook sections */ base_size=lMem-lTarget+1; if (lTarget==SUBL) { base_size=lMem-19; } /* weighting of the CB memory */ noOfZeros=lMem-WebRtcIlbcfix_kFilterRange[block]; WebRtcSpl_MemSetW16(&buf[-LPC_FILTERORDER], 0, noOfZeros+LPC_FILTERORDER); WebRtcSpl_FilterARFastQ12( decResidual+noOfZeros, buf+noOfZeros, weightDenum, LPC_FILTERORDER+1, WebRtcIlbcfix_kFilterRange[block]); /* weighting of the target vector */ WEBRTC_SPL_MEMCPY_W16(&target[-LPC_FILTERORDER], buf+noOfZeros+WebRtcIlbcfix_kFilterRange[block]-LPC_FILTERORDER, LPC_FILTERORDER); WebRtcSpl_FilterARFastQ12( intarget, target, weightDenum, LPC_FILTERORDER+1, lTarget); /* Store target, towards the end codedVec is calculated as the initial target minus the remaining target */ WEBRTC_SPL_MEMCPY_W16(codedVec, target, lTarget); /* Find the highest absolute value to calculate proper vector scale factor (so that it uses 12 bits) */ temp1 = WebRtcSpl_MaxAbsValueW16(buf, (int16_t)lMem); temp2 = WebRtcSpl_MaxAbsValueW16(target, (int16_t)lTarget); if ((temp1>0)&&(temp2>0)) { temp1 = WEBRTC_SPL_MAX(temp1, temp2); scale = WebRtcSpl_GetSizeInBits(WEBRTC_SPL_MUL_16_16(temp1, temp1)); } else { /* temp1 or temp2 is negative (maximum was -32768) */ scale = 30; } /* Scale to so that a mul-add 40 times does not overflow */ scale = scale - 25; scale = WEBRTC_SPL_MAX(0, scale); /* Compute energy of the original target */ targetEner = WebRtcSpl_DotProductWithScale(target, target, lTarget, scale); /* Prepare search over one more codebook section. This section is created by filtering the original buffer with a filter. */ WebRtcIlbcfix_FilteredCbVecs(cbvectors, buf, lMem, WebRtcIlbcfix_kFilterRange[block]); range = WebRtcIlbcfix_kSearchRange[block][0]; if(lTarget == SUBL) { /* Create the interpolated samples and store them for use in all stages */ /* First section, non-filtered half of the cb */ WebRtcIlbcfix_InterpolateSamples(interpSamples, buf, lMem); /* Second section, filtered half of the cb */ WebRtcIlbcfix_InterpolateSamples(interpSamplesFilt, cbvectors, lMem); /* Compute the CB vectors' energies for the first cb section (non-filtered) */ WebRtcIlbcfix_CbMemEnergyAugmentation(interpSamples, buf, scale, 20, energyW16, energyShifts); /* Compute the CB vectors' energies for the second cb section (filtered cb) */ WebRtcIlbcfix_CbMemEnergyAugmentation(interpSamplesFilt, cbvectors, scale, (int16_t)(base_size+20), energyW16, energyShifts); /* Compute the CB vectors' energies and store them in the vector * energyW16. Also the corresponding shift values are stored. The * energy values are used in all three stages. */ WebRtcIlbcfix_CbMemEnergy(range, buf, cbvectors, lMem, lTarget, energyW16+20, energyShifts+20, scale, base_size); } else { /* Compute the CB vectors' energies and store them in the vector * energyW16. Also the corresponding shift values are stored. The * energy values are used in all three stages. */ WebRtcIlbcfix_CbMemEnergy(range, buf, cbvectors, lMem, lTarget, energyW16, energyShifts, scale, base_size); /* Set the energy positions 58-63 and 122-127 to zero (otherwise they are uninitialized) */ WebRtcSpl_MemSetW16(energyW16+range, 0, (base_size-range)); WebRtcSpl_MemSetW16(energyW16+range+base_size, 0, (base_size-range)); } /* Calculate Inverse Energy (energyW16 is already normalized and will contain the inverse energy in Q29 after this call */ WebRtcIlbcfix_EnergyInverse(energyW16, base_size*CB_EXPAND); /* The gain value computed in the previous stage is used * as an upper limit to what the next stage gain value * is allowed to be. In stage 0, 16384 (1.0 in Q14) is used as * the upper limit. */ gains[0] = 16384; for (stage=0; stage<CB_NSTAGES; stage++) { /* Set up memories */ range = WebRtcIlbcfix_kSearchRange[block][stage]; /* initialize search measures */ CritMax=0; shTotMax=-100; bestIndex=0; bestGain=0; /* loop over lags 40+ in the first codebook section, full search */ cb_vecPtr = buf+lMem-lTarget; /* Calculate all the cross correlations (augmented part of CB) */ if (lTarget==SUBL) { WebRtcIlbcfix_AugmentedCbCorr(target, buf+lMem, interpSamples, cDot, 20, 39, scale); cDotPtr=&cDot[20]; } else { cDotPtr=cDot; } /* Calculate all the cross correlations (main part of CB) */ WebRtcSpl_CrossCorrelation(cDotPtr, target, cb_vecPtr, lTarget, range, scale, -1); /* Adjust the search range for the augmented vectors */ if (lTarget==SUBL) { range=WebRtcIlbcfix_kSearchRange[block][stage]+20; } else { range=WebRtcIlbcfix_kSearchRange[block][stage]; } indexOffset=0; /* Search for best index in this part of the vector */ WebRtcIlbcfix_CbSearchCore( cDot, range, stage, inverseEnergy, inverseEnergyShifts, Crit, &indexNew, &CritNew, &CritNewSh); /* Update the global best index and the corresponding gain */ WebRtcIlbcfix_CbUpdateBestIndex( CritNew, CritNewSh, (int16_t)(indexNew+indexOffset), cDot[indexNew+indexOffset], inverseEnergy[indexNew+indexOffset], inverseEnergyShifts[indexNew+indexOffset], &CritMax, &shTotMax, &bestIndex, &bestGain); sInd=bestIndex-(int16_t)(CB_RESRANGE>>1); eInd=sInd+CB_RESRANGE; if (sInd<0) { eInd-=sInd; sInd=0; } if (eInd>=range) { eInd=range-1; sInd=eInd-CB_RESRANGE; } range = WebRtcIlbcfix_kSearchRange[block][stage]; if (lTarget==SUBL) { i=sInd; if (sInd<20) { WebRtcIlbcfix_AugmentedCbCorr(target, cbvectors+lMem, interpSamplesFilt, cDot, (int16_t)(sInd+20), (int16_t)(WEBRTC_SPL_MIN(39, (eInd+20))), scale); i=20; } cDotPtr=&cDot[WEBRTC_SPL_MAX(0,(20-sInd))]; cb_vecPtr = cbvectors+lMem-20-i; /* Calculate the cross correlations (main part of the filtered CB) */ WebRtcSpl_CrossCorrelation(cDotPtr, target, cb_vecPtr, lTarget, (int16_t)(eInd-i+1), scale, -1); } else { cDotPtr = cDot; cb_vecPtr = cbvectors+lMem-lTarget-sInd; /* Calculate the cross correlations (main part of the filtered CB) */ WebRtcSpl_CrossCorrelation(cDotPtr, target, cb_vecPtr, lTarget, (int16_t)(eInd-sInd+1), scale, -1); } /* Adjust the search range for the augmented vectors */ indexOffset=base_size+sInd; /* Search for best index in this part of the vector */ WebRtcIlbcfix_CbSearchCore( cDot, (int16_t)(eInd-sInd+1), stage, inverseEnergy+indexOffset, inverseEnergyShifts+indexOffset, Crit, &indexNew, &CritNew, &CritNewSh); /* Update the global best index and the corresponding gain */ WebRtcIlbcfix_CbUpdateBestIndex( CritNew, CritNewSh, (int16_t)(indexNew+indexOffset), cDot[indexNew], inverseEnergy[indexNew+indexOffset], inverseEnergyShifts[indexNew+indexOffset], &CritMax, &shTotMax, &bestIndex, &bestGain); index[stage] = bestIndex; bestGain = WebRtcIlbcfix_GainQuant(bestGain, (int16_t)WEBRTC_SPL_ABS_W16(gains[stage]), stage, &gain_index[stage]); /* Extract the best (according to measure) codebook vector Also adjust the index, so that the augmented vectors are last. Above these vectors were first... */ if(lTarget==(STATE_LEN-iLBCenc_inst->state_short_len)) { if(index[stage]<base_size) { pp=buf+lMem-lTarget-index[stage]; } else { pp=cbvectors+lMem-lTarget- index[stage]+base_size; } } else { if (index[stage]<base_size) { if (index[stage]>=20) { /* Adjust index and extract vector */ index[stage]-=20; pp=buf+lMem-lTarget-index[stage]; } else { /* Adjust index and extract vector */ index[stage]+=(base_size-20); WebRtcIlbcfix_CreateAugmentedVec((int16_t)(index[stage]-base_size+40), buf+lMem, aug_vec); pp = aug_vec; } } else { if ((index[stage] - base_size) >= 20) { /* Adjust index and extract vector */ index[stage]-=20; pp=cbvectors+lMem-lTarget- index[stage]+base_size; } else { /* Adjust index and extract vector */ index[stage]+=(base_size-20); WebRtcIlbcfix_CreateAugmentedVec((int16_t)(index[stage]-2*base_size+40), cbvectors+lMem, aug_vec); pp = aug_vec; } } } /* Subtract the best codebook vector, according to measure, from the target vector */ WebRtcSpl_AddAffineVectorToVector(target, pp, (int16_t)(-bestGain), (int32_t)8192, (int16_t)14, (int)lTarget); /* record quantized gain */ gains[stage+1] = bestGain; } /* end of Main Loop. for (stage=0;... */ /* Calculte the coded vector (original target - what's left) */ for (i=0;i<lTarget;i++) { codedVec[i]-=target[i]; } /* Gain adjustment for energy matching */ codedEner = WebRtcSpl_DotProductWithScale(codedVec, codedVec, lTarget, scale); j=gain_index[0]; temp1 = (int16_t)WebRtcSpl_NormW32(codedEner); temp2 = (int16_t)WebRtcSpl_NormW32(targetEner); if(temp1 < temp2) { bits = 16 - temp1; } else { bits = 16 - temp2; } tmp = (int16_t) WEBRTC_SPL_MUL_16_16_RSFT(gains[1],gains[1], 14); targetEner = WEBRTC_SPL_MUL_16_16( WEBRTC_SPL_SHIFT_W32(targetEner, -bits), tmp); tmpW32 = ((int32_t)(gains[1]-1))<<1; /* Pointer to the table that contains gain_sq5TblFIX * gain_sq5TblFIX in Q14 */ gainPtr=(int16_t*)WebRtcIlbcfix_kGainSq5Sq+gain_index[0]; temp1 = (int16_t)WEBRTC_SPL_SHIFT_W32(codedEner, -bits); WebRtcIlbcfix_kGainSq5_ptr = (int16_t*)&WebRtcIlbcfix_kGainSq5[j]; /* targetEner and codedEner are in Q(-2*scale) */ for (i=gain_index[0];i<32;i++) { /* Change the index if (codedEnergy*gainTbl[i]*gainTbl[i])<(targetEn*gain[0]*gain[0]) AND gainTbl[i] < 2*gain[0] */ t32 = WEBRTC_SPL_MUL_16_16(temp1, (*gainPtr)); t32 = t32 - targetEner; if (t32 < 0) { if ((*WebRtcIlbcfix_kGainSq5_ptr) < tmpW32) { j=i; WebRtcIlbcfix_kGainSq5_ptr = (int16_t*)&WebRtcIlbcfix_kGainSq5[i]; } } gainPtr++; } gain_index[0]=j; return; }