cannam@154: /*********************************************************************** cannam@154: Copyright (c) 2006-2011, Skype Limited. All rights reserved. cannam@154: Redistribution and use in source and binary forms, with or without cannam@154: modification, are permitted provided that the following conditions cannam@154: are met: cannam@154: - Redistributions of source code must retain the above copyright notice, cannam@154: this list of conditions and the following disclaimer. cannam@154: - Redistributions in binary form must reproduce the above copyright cannam@154: notice, this list of conditions and the following disclaimer in the cannam@154: documentation and/or other materials provided with the distribution. cannam@154: - Neither the name of Internet Society, IETF or IETF Trust, nor the cannam@154: names of specific contributors, may be used to endorse or promote cannam@154: products derived from this software without specific prior written cannam@154: permission. cannam@154: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" cannam@154: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE cannam@154: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE cannam@154: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE cannam@154: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR cannam@154: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF cannam@154: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS cannam@154: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN cannam@154: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) cannam@154: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE cannam@154: POSSIBILITY OF SUCH DAMAGE. cannam@154: ***********************************************************************/ cannam@154: cannam@154: #ifdef HAVE_CONFIG_H cannam@154: #include "config.h" cannam@154: #endif cannam@154: #include "define.h" cannam@154: #include "API.h" cannam@154: #include "control.h" cannam@154: #include "typedef.h" cannam@154: #include "stack_alloc.h" cannam@154: #include "structs.h" cannam@154: #include "tuning_parameters.h" cannam@154: #ifdef FIXED_POINT cannam@154: #include "main_FIX.h" cannam@154: #else cannam@154: #include "main_FLP.h" cannam@154: #endif cannam@154: cannam@154: /***************************************/ cannam@154: /* Read control structure from encoder */ cannam@154: /***************************************/ cannam@154: static opus_int silk_QueryEncoder( /* O Returns error code */ cannam@154: const void *encState, /* I State */ cannam@154: silk_EncControlStruct *encStatus /* O Encoder Status */ cannam@154: ); cannam@154: cannam@154: /****************************************/ cannam@154: /* Encoder functions */ cannam@154: /****************************************/ cannam@154: cannam@154: opus_int silk_Get_Encoder_Size( /* O Returns error code */ cannam@154: opus_int *encSizeBytes /* O Number of bytes in SILK encoder state */ cannam@154: ) cannam@154: { cannam@154: opus_int ret = SILK_NO_ERROR; cannam@154: cannam@154: *encSizeBytes = sizeof( silk_encoder ); cannam@154: cannam@154: return ret; cannam@154: } cannam@154: cannam@154: /*************************/ cannam@154: /* Init or Reset encoder */ cannam@154: /*************************/ cannam@154: opus_int silk_InitEncoder( /* O Returns error code */ cannam@154: void *encState, /* I/O State */ cannam@154: int arch, /* I Run-time architecture */ cannam@154: silk_EncControlStruct *encStatus /* O Encoder Status */ cannam@154: ) cannam@154: { cannam@154: silk_encoder *psEnc; cannam@154: opus_int n, ret = SILK_NO_ERROR; cannam@154: cannam@154: psEnc = (silk_encoder *)encState; cannam@154: cannam@154: /* Reset encoder */ cannam@154: silk_memset( psEnc, 0, sizeof( silk_encoder ) ); cannam@154: for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) { cannam@154: if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ], arch ) ) { cannam@154: celt_assert( 0 ); cannam@154: } cannam@154: } cannam@154: cannam@154: psEnc->nChannelsAPI = 1; cannam@154: psEnc->nChannelsInternal = 1; cannam@154: cannam@154: /* Read control structure */ cannam@154: if( ret += silk_QueryEncoder( encState, encStatus ) ) { cannam@154: celt_assert( 0 ); cannam@154: } cannam@154: cannam@154: return ret; cannam@154: } cannam@154: cannam@154: /***************************************/ cannam@154: /* Read control structure from encoder */ cannam@154: /***************************************/ cannam@154: static opus_int silk_QueryEncoder( /* O Returns error code */ cannam@154: const void *encState, /* I State */ cannam@154: silk_EncControlStruct *encStatus /* O Encoder Status */ cannam@154: ) cannam@154: { cannam@154: opus_int ret = SILK_NO_ERROR; cannam@154: silk_encoder_state_Fxx *state_Fxx; cannam@154: silk_encoder *psEnc = (silk_encoder *)encState; cannam@154: cannam@154: state_Fxx = psEnc->state_Fxx; cannam@154: cannam@154: encStatus->nChannelsAPI = psEnc->nChannelsAPI; cannam@154: encStatus->nChannelsInternal = psEnc->nChannelsInternal; cannam@154: encStatus->API_sampleRate = state_Fxx[ 0 ].sCmn.API_fs_Hz; cannam@154: encStatus->maxInternalSampleRate = state_Fxx[ 0 ].sCmn.maxInternal_fs_Hz; cannam@154: encStatus->minInternalSampleRate = state_Fxx[ 0 ].sCmn.minInternal_fs_Hz; cannam@154: encStatus->desiredInternalSampleRate = state_Fxx[ 0 ].sCmn.desiredInternal_fs_Hz; cannam@154: encStatus->payloadSize_ms = state_Fxx[ 0 ].sCmn.PacketSize_ms; cannam@154: encStatus->bitRate = state_Fxx[ 0 ].sCmn.TargetRate_bps; cannam@154: encStatus->packetLossPercentage = state_Fxx[ 0 ].sCmn.PacketLoss_perc; cannam@154: encStatus->complexity = state_Fxx[ 0 ].sCmn.Complexity; cannam@154: encStatus->useInBandFEC = state_Fxx[ 0 ].sCmn.useInBandFEC; cannam@154: encStatus->useDTX = state_Fxx[ 0 ].sCmn.useDTX; cannam@154: encStatus->useCBR = state_Fxx[ 0 ].sCmn.useCBR; cannam@154: encStatus->internalSampleRate = silk_SMULBB( state_Fxx[ 0 ].sCmn.fs_kHz, 1000 ); cannam@154: encStatus->allowBandwidthSwitch = state_Fxx[ 0 ].sCmn.allow_bandwidth_switch; cannam@154: encStatus->inWBmodeWithoutVariableLP = state_Fxx[ 0 ].sCmn.fs_kHz == 16 && state_Fxx[ 0 ].sCmn.sLP.mode == 0; cannam@154: cannam@154: return ret; cannam@154: } cannam@154: cannam@154: cannam@154: /**************************/ cannam@154: /* Encode frame with Silk */ cannam@154: /**************************/ cannam@154: /* Note: if prefillFlag is set, the input must contain 10 ms of audio, irrespective of what */ cannam@154: /* encControl->payloadSize_ms is set to */ cannam@154: opus_int silk_Encode( /* O Returns error code */ cannam@154: void *encState, /* I/O State */ cannam@154: silk_EncControlStruct *encControl, /* I Control status */ cannam@154: const opus_int16 *samplesIn, /* I Speech sample input vector */ cannam@154: opus_int nSamplesIn, /* I Number of samples in input vector */ cannam@154: ec_enc *psRangeEnc, /* I/O Compressor data structure */ cannam@154: opus_int32 *nBytesOut, /* I/O Number of bytes in payload (input: Max bytes) */ cannam@154: const opus_int prefillFlag, /* I Flag to indicate prefilling buffers no coding */ cannam@154: opus_int activity /* I Decision of Opus voice activity detector */ cannam@154: ) cannam@154: { cannam@154: opus_int n, i, nBits, flags, tmp_payloadSize_ms = 0, tmp_complexity = 0, ret = 0; cannam@154: opus_int nSamplesToBuffer, nSamplesToBufferMax, nBlocksOf10ms; cannam@154: opus_int nSamplesFromInput = 0, nSamplesFromInputMax; cannam@154: opus_int speech_act_thr_for_switch_Q8; cannam@154: opus_int32 TargetRate_bps, MStargetRates_bps[ 2 ], channelRate_bps, LBRR_symbol, sum; cannam@154: silk_encoder *psEnc = ( silk_encoder * )encState; cannam@154: VARDECL( opus_int16, buf ); cannam@154: opus_int transition, curr_block, tot_blocks; cannam@154: SAVE_STACK; cannam@154: cannam@154: if (encControl->reducedDependency) cannam@154: { cannam@154: psEnc->state_Fxx[0].sCmn.first_frame_after_reset = 1; cannam@154: psEnc->state_Fxx[1].sCmn.first_frame_after_reset = 1; cannam@154: } cannam@154: psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded = psEnc->state_Fxx[ 1 ].sCmn.nFramesEncoded = 0; cannam@154: cannam@154: /* Check values in encoder control structure */ cannam@154: if( ( ret = check_control_input( encControl ) ) != 0 ) { cannam@154: celt_assert( 0 ); cannam@154: RESTORE_STACK; cannam@154: return ret; cannam@154: } cannam@154: cannam@154: encControl->switchReady = 0; cannam@154: cannam@154: if( encControl->nChannelsInternal > psEnc->nChannelsInternal ) { cannam@154: /* Mono -> Stereo transition: init state of second channel and stereo state */ cannam@154: ret += silk_init_encoder( &psEnc->state_Fxx[ 1 ], psEnc->state_Fxx[ 0 ].sCmn.arch ); cannam@154: silk_memset( psEnc->sStereo.pred_prev_Q13, 0, sizeof( psEnc->sStereo.pred_prev_Q13 ) ); cannam@154: silk_memset( psEnc->sStereo.sSide, 0, sizeof( psEnc->sStereo.sSide ) ); cannam@154: psEnc->sStereo.mid_side_amp_Q0[ 0 ] = 0; cannam@154: psEnc->sStereo.mid_side_amp_Q0[ 1 ] = 1; cannam@154: psEnc->sStereo.mid_side_amp_Q0[ 2 ] = 0; cannam@154: psEnc->sStereo.mid_side_amp_Q0[ 3 ] = 1; cannam@154: psEnc->sStereo.width_prev_Q14 = 0; cannam@154: psEnc->sStereo.smth_width_Q14 = SILK_FIX_CONST( 1, 14 ); cannam@154: if( psEnc->nChannelsAPI == 2 ) { cannam@154: silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof( silk_resampler_state_struct ) ); cannam@154: silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.In_HP_State, &psEnc->state_Fxx[ 0 ].sCmn.In_HP_State, sizeof( psEnc->state_Fxx[ 1 ].sCmn.In_HP_State ) ); cannam@154: } cannam@154: } cannam@154: cannam@154: transition = (encControl->payloadSize_ms != psEnc->state_Fxx[ 0 ].sCmn.PacketSize_ms) || (psEnc->nChannelsInternal != encControl->nChannelsInternal); cannam@154: cannam@154: psEnc->nChannelsAPI = encControl->nChannelsAPI; cannam@154: psEnc->nChannelsInternal = encControl->nChannelsInternal; cannam@154: cannam@154: nBlocksOf10ms = silk_DIV32( 100 * nSamplesIn, encControl->API_sampleRate ); cannam@154: tot_blocks = ( nBlocksOf10ms > 1 ) ? nBlocksOf10ms >> 1 : 1; cannam@154: curr_block = 0; cannam@154: if( prefillFlag ) { cannam@154: silk_LP_state save_LP; cannam@154: /* Only accept input length of 10 ms */ cannam@154: if( nBlocksOf10ms != 1 ) { cannam@154: celt_assert( 0 ); cannam@154: RESTORE_STACK; cannam@154: return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; cannam@154: } cannam@154: if ( prefillFlag == 2 ) { cannam@154: save_LP = psEnc->state_Fxx[ 0 ].sCmn.sLP; cannam@154: /* Save the sampling rate so the bandwidth switching code can keep handling transitions. */ cannam@154: save_LP.saved_fs_kHz = psEnc->state_Fxx[ 0 ].sCmn.fs_kHz; cannam@154: } cannam@154: /* Reset Encoder */ cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: ret = silk_init_encoder( &psEnc->state_Fxx[ n ], psEnc->state_Fxx[ n ].sCmn.arch ); cannam@154: /* Restore the variable LP state. */ cannam@154: if ( prefillFlag == 2 ) { cannam@154: psEnc->state_Fxx[ n ].sCmn.sLP = save_LP; cannam@154: } cannam@154: celt_assert( !ret ); cannam@154: } cannam@154: tmp_payloadSize_ms = encControl->payloadSize_ms; cannam@154: encControl->payloadSize_ms = 10; cannam@154: tmp_complexity = encControl->complexity; cannam@154: encControl->complexity = 0; cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0; cannam@154: psEnc->state_Fxx[ n ].sCmn.prefillFlag = 1; cannam@154: } cannam@154: } else { cannam@154: /* Only accept input lengths that are a multiple of 10 ms */ cannam@154: if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) { cannam@154: celt_assert( 0 ); cannam@154: RESTORE_STACK; cannam@154: return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; cannam@154: } cannam@154: /* Make sure no more than one packet can be produced */ cannam@154: if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) { cannam@154: celt_assert( 0 ); cannam@154: RESTORE_STACK; cannam@154: return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; cannam@154: } cannam@154: } cannam@154: cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: /* Force the side channel to the same rate as the mid */ cannam@154: opus_int force_fs_kHz = (n==1) ? psEnc->state_Fxx[0].sCmn.fs_kHz : 0; cannam@154: if( ( ret = silk_control_encoder( &psEnc->state_Fxx[ n ], encControl, psEnc->allowBandwidthSwitch, n, force_fs_kHz ) ) != 0 ) { cannam@154: silk_assert( 0 ); cannam@154: RESTORE_STACK; cannam@154: return ret; cannam@154: } cannam@154: if( psEnc->state_Fxx[n].sCmn.first_frame_after_reset || transition ) { cannam@154: for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) { cannam@154: psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] = 0; cannam@154: } cannam@154: } cannam@154: psEnc->state_Fxx[ n ].sCmn.inDTX = psEnc->state_Fxx[ n ].sCmn.useDTX; cannam@154: } cannam@154: celt_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz ); cannam@154: cannam@154: /* Input buffering/resampling and encoding */ cannam@154: nSamplesToBufferMax = cannam@154: 10 * nBlocksOf10ms * psEnc->state_Fxx[ 0 ].sCmn.fs_kHz; cannam@154: nSamplesFromInputMax = cannam@154: silk_DIV32_16( nSamplesToBufferMax * cannam@154: psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, cannam@154: psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 ); cannam@154: ALLOC( buf, nSamplesFromInputMax, opus_int16 ); cannam@154: while( 1 ) { cannam@154: nSamplesToBuffer = psEnc->state_Fxx[ 0 ].sCmn.frame_length - psEnc->state_Fxx[ 0 ].sCmn.inputBufIx; cannam@154: nSamplesToBuffer = silk_min( nSamplesToBuffer, nSamplesToBufferMax ); cannam@154: nSamplesFromInput = silk_DIV32_16( nSamplesToBuffer * psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 ); cannam@154: /* Resample and write to buffer */ cannam@154: if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 2 ) { cannam@154: opus_int id = psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded; cannam@154: for( n = 0; n < nSamplesFromInput; n++ ) { cannam@154: buf[ n ] = samplesIn[ 2 * n ]; cannam@154: } cannam@154: /* Making sure to start both resamplers from the same state when switching from mono to stereo */ cannam@154: if( psEnc->nPrevChannelsInternal == 1 && id==0 ) { cannam@154: silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof(psEnc->state_Fxx[ 1 ].sCmn.resampler_state)); cannam@154: } cannam@154: cannam@154: ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, cannam@154: &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); cannam@154: psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer; cannam@154: cannam@154: nSamplesToBuffer = psEnc->state_Fxx[ 1 ].sCmn.frame_length - psEnc->state_Fxx[ 1 ].sCmn.inputBufIx; cannam@154: nSamplesToBuffer = silk_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 1 ].sCmn.fs_kHz ); cannam@154: for( n = 0; n < nSamplesFromInput; n++ ) { cannam@154: buf[ n ] = samplesIn[ 2 * n + 1 ]; cannam@154: } cannam@154: ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, cannam@154: &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); cannam@154: cannam@154: psEnc->state_Fxx[ 1 ].sCmn.inputBufIx += nSamplesToBuffer; cannam@154: } else if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 1 ) { cannam@154: /* Combine left and right channels before resampling */ cannam@154: for( n = 0; n < nSamplesFromInput; n++ ) { cannam@154: sum = samplesIn[ 2 * n ] + samplesIn[ 2 * n + 1 ]; cannam@154: buf[ n ] = (opus_int16)silk_RSHIFT_ROUND( sum, 1 ); cannam@154: } cannam@154: ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, cannam@154: &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); cannam@154: /* On the first mono frame, average the results for the two resampler states */ cannam@154: if( psEnc->nPrevChannelsInternal == 2 && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 ) { cannam@154: ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, cannam@154: &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); cannam@154: for( n = 0; n < psEnc->state_Fxx[ 0 ].sCmn.frame_length; n++ ) { cannam@154: psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx+n+2 ] = cannam@154: silk_RSHIFT(psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx+n+2 ] cannam@154: + psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx+n+2 ], 1); cannam@154: } cannam@154: } cannam@154: psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer; cannam@154: } else { cannam@154: celt_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 ); cannam@154: silk_memcpy(buf, samplesIn, nSamplesFromInput*sizeof(opus_int16)); cannam@154: ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, cannam@154: &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); cannam@154: psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer; cannam@154: } cannam@154: cannam@154: samplesIn += nSamplesFromInput * encControl->nChannelsAPI; cannam@154: nSamplesIn -= nSamplesFromInput; cannam@154: cannam@154: /* Default */ cannam@154: psEnc->allowBandwidthSwitch = 0; cannam@154: cannam@154: /* Silk encoder */ cannam@154: if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) { cannam@154: /* Enough data in input buffer, so encode */ cannam@154: celt_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length ); cannam@154: celt_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length ); cannam@154: cannam@154: /* Deal with LBRR data */ cannam@154: if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) { cannam@154: /* Create space at start of payload for VAD and FEC flags */ cannam@154: opus_uint8 iCDF[ 2 ] = { 0, 0 }; cannam@154: iCDF[ 0 ] = 256 - silk_RSHIFT( 256, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal ); cannam@154: ec_enc_icdf( psRangeEnc, 0, iCDF, 8 ); cannam@154: cannam@154: /* Encode any LBRR data from previous packet */ cannam@154: /* Encode LBRR flags */ cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: LBRR_symbol = 0; cannam@154: for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) { cannam@154: LBRR_symbol |= silk_LSHIFT( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ], i ); cannam@154: } cannam@154: psEnc->state_Fxx[ n ].sCmn.LBRR_flag = LBRR_symbol > 0 ? 1 : 0; cannam@154: if( LBRR_symbol && psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket > 1 ) { cannam@154: ec_enc_icdf( psRangeEnc, LBRR_symbol - 1, silk_LBRR_flags_iCDF_ptr[ psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket - 2 ], 8 ); cannam@154: } cannam@154: } cannam@154: cannam@154: /* Code LBRR indices and excitation signals */ cannam@154: for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) { cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: if( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] ) { cannam@154: opus_int condCoding; cannam@154: cannam@154: if( encControl->nChannelsInternal == 2 && n == 0 ) { cannam@154: silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ i ] ); cannam@154: /* For LBRR data there's no need to code the mid-only flag if the side-channel LBRR flag is set */ cannam@154: if( psEnc->state_Fxx[ 1 ].sCmn.LBRR_flags[ i ] == 0 ) { cannam@154: silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ i ] ); cannam@154: } cannam@154: } cannam@154: /* Use conditional coding if previous frame available */ cannam@154: if( i > 0 && psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i - 1 ] ) { cannam@154: condCoding = CODE_CONDITIONALLY; cannam@154: } else { cannam@154: condCoding = CODE_INDEPENDENTLY; cannam@154: } cannam@154: silk_encode_indices( &psEnc->state_Fxx[ n ].sCmn, psRangeEnc, i, 1, condCoding ); cannam@154: silk_encode_pulses( psRangeEnc, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].signalType, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].quantOffsetType, cannam@154: psEnc->state_Fxx[ n ].sCmn.pulses_LBRR[ i ], psEnc->state_Fxx[ n ].sCmn.frame_length ); cannam@154: } cannam@154: } cannam@154: } cannam@154: cannam@154: /* Reset LBRR flags */ cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: silk_memset( psEnc->state_Fxx[ n ].sCmn.LBRR_flags, 0, sizeof( psEnc->state_Fxx[ n ].sCmn.LBRR_flags ) ); cannam@154: } cannam@154: cannam@154: psEnc->nBitsUsedLBRR = ec_tell( psRangeEnc ); cannam@154: } cannam@154: cannam@154: silk_HP_variable_cutoff( psEnc->state_Fxx ); cannam@154: cannam@154: /* Total target bits for packet */ cannam@154: nBits = silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 ); cannam@154: /* Subtract bits used for LBRR */ cannam@154: if( !prefillFlag ) { cannam@154: nBits -= psEnc->nBitsUsedLBRR; cannam@154: } cannam@154: /* Divide by number of uncoded frames left in packet */ cannam@154: nBits = silk_DIV32_16( nBits, psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket ); cannam@154: /* Convert to bits/second */ cannam@154: if( encControl->payloadSize_ms == 10 ) { cannam@154: TargetRate_bps = silk_SMULBB( nBits, 100 ); cannam@154: } else { cannam@154: TargetRate_bps = silk_SMULBB( nBits, 50 ); cannam@154: } cannam@154: /* Subtract fraction of bits in excess of target in previous frames and packets */ cannam@154: TargetRate_bps -= silk_DIV32_16( silk_MUL( psEnc->nBitsExceeded, 1000 ), BITRESERVOIR_DECAY_TIME_MS ); cannam@154: if( !prefillFlag && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded > 0 ) { cannam@154: /* Compare actual vs target bits so far in this packet */ cannam@154: opus_int32 bitsBalance = ec_tell( psRangeEnc ) - psEnc->nBitsUsedLBRR - nBits * psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded; cannam@154: TargetRate_bps -= silk_DIV32_16( silk_MUL( bitsBalance, 1000 ), BITRESERVOIR_DECAY_TIME_MS ); cannam@154: } cannam@154: /* Never exceed input bitrate */ cannam@154: TargetRate_bps = silk_LIMIT( TargetRate_bps, encControl->bitRate, 5000 ); cannam@154: cannam@154: /* Convert Left/Right to Mid/Side */ cannam@154: if( encControl->nChannelsInternal == 2 ) { cannam@154: silk_stereo_LR_to_MS( &psEnc->sStereo, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ 2 ], &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ 2 ], cannam@154: psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], &psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], cannam@154: MStargetRates_bps, TargetRate_bps, psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8, encControl->toMono, cannam@154: psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, psEnc->state_Fxx[ 0 ].sCmn.frame_length ); cannam@154: if( psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] == 0 ) { cannam@154: /* Reset side channel encoder memory for first frame with side coding */ cannam@154: if( psEnc->prev_decode_only_middle == 1 ) { cannam@154: silk_memset( &psEnc->state_Fxx[ 1 ].sShape, 0, sizeof( psEnc->state_Fxx[ 1 ].sShape ) ); cannam@154: silk_memset( &psEnc->state_Fxx[ 1 ].sCmn.sNSQ, 0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.sNSQ ) ); cannam@154: silk_memset( psEnc->state_Fxx[ 1 ].sCmn.prev_NLSFq_Q15, 0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.prev_NLSFq_Q15 ) ); cannam@154: silk_memset( &psEnc->state_Fxx[ 1 ].sCmn.sLP.In_LP_State, 0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.sLP.In_LP_State ) ); cannam@154: psEnc->state_Fxx[ 1 ].sCmn.prevLag = 100; cannam@154: psEnc->state_Fxx[ 1 ].sCmn.sNSQ.lagPrev = 100; cannam@154: psEnc->state_Fxx[ 1 ].sShape.LastGainIndex = 10; cannam@154: psEnc->state_Fxx[ 1 ].sCmn.prevSignalType = TYPE_NO_VOICE_ACTIVITY; cannam@154: psEnc->state_Fxx[ 1 ].sCmn.sNSQ.prev_gain_Q16 = 65536; cannam@154: psEnc->state_Fxx[ 1 ].sCmn.first_frame_after_reset = 1; cannam@154: } cannam@154: silk_encode_do_VAD_Fxx( &psEnc->state_Fxx[ 1 ], activity ); cannam@154: } else { cannam@154: psEnc->state_Fxx[ 1 ].sCmn.VAD_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] = 0; cannam@154: } cannam@154: if( !prefillFlag ) { cannam@154: silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] ); cannam@154: if( psEnc->state_Fxx[ 1 ].sCmn.VAD_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] == 0 ) { cannam@154: silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] ); cannam@154: } cannam@154: } cannam@154: } else { cannam@154: /* Buffering */ cannam@154: silk_memcpy( psEnc->state_Fxx[ 0 ].sCmn.inputBuf, psEnc->sStereo.sMid, 2 * sizeof( opus_int16 ) ); cannam@154: silk_memcpy( psEnc->sStereo.sMid, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.frame_length ], 2 * sizeof( opus_int16 ) ); cannam@154: } cannam@154: silk_encode_do_VAD_Fxx( &psEnc->state_Fxx[ 0 ], activity ); cannam@154: cannam@154: /* Encode */ cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: opus_int maxBits, useCBR; cannam@154: cannam@154: /* Handling rate constraints */ cannam@154: maxBits = encControl->maxBits; cannam@154: if( tot_blocks == 2 && curr_block == 0 ) { cannam@154: maxBits = maxBits * 3 / 5; cannam@154: } else if( tot_blocks == 3 ) { cannam@154: if( curr_block == 0 ) { cannam@154: maxBits = maxBits * 2 / 5; cannam@154: } else if( curr_block == 1 ) { cannam@154: maxBits = maxBits * 3 / 4; cannam@154: } cannam@154: } cannam@154: useCBR = encControl->useCBR && curr_block == tot_blocks - 1; cannam@154: cannam@154: if( encControl->nChannelsInternal == 1 ) { cannam@154: channelRate_bps = TargetRate_bps; cannam@154: } else { cannam@154: channelRate_bps = MStargetRates_bps[ n ]; cannam@154: if( n == 0 && MStargetRates_bps[ 1 ] > 0 ) { cannam@154: useCBR = 0; cannam@154: /* Give mid up to 1/2 of the max bits for that frame */ cannam@154: maxBits -= encControl->maxBits / ( tot_blocks * 2 ); cannam@154: } cannam@154: } cannam@154: cannam@154: if( channelRate_bps > 0 ) { cannam@154: opus_int condCoding; cannam@154: cannam@154: silk_control_SNR( &psEnc->state_Fxx[ n ].sCmn, channelRate_bps ); cannam@154: cannam@154: /* Use independent coding if no previous frame available */ cannam@154: if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded - n <= 0 ) { cannam@154: condCoding = CODE_INDEPENDENTLY; cannam@154: } else if( n > 0 && psEnc->prev_decode_only_middle ) { cannam@154: /* If we skipped a side frame in this packet, we don't cannam@154: need LTP scaling; the LTP state is well-defined. */ cannam@154: condCoding = CODE_INDEPENDENTLY_NO_LTP_SCALING; cannam@154: } else { cannam@154: condCoding = CODE_CONDITIONALLY; cannam@154: } cannam@154: if( ( ret = silk_encode_frame_Fxx( &psEnc->state_Fxx[ n ], nBytesOut, psRangeEnc, condCoding, maxBits, useCBR ) ) != 0 ) { cannam@154: silk_assert( 0 ); cannam@154: } cannam@154: } cannam@154: psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0; cannam@154: psEnc->state_Fxx[ n ].sCmn.inputBufIx = 0; cannam@154: psEnc->state_Fxx[ n ].sCmn.nFramesEncoded++; cannam@154: } cannam@154: psEnc->prev_decode_only_middle = psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded - 1 ]; cannam@154: cannam@154: /* Insert VAD and FEC flags at beginning of bitstream */ cannam@154: if( *nBytesOut > 0 && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket) { cannam@154: flags = 0; cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) { cannam@154: flags = silk_LSHIFT( flags, 1 ); cannam@154: flags |= psEnc->state_Fxx[ n ].sCmn.VAD_flags[ i ]; cannam@154: } cannam@154: flags = silk_LSHIFT( flags, 1 ); cannam@154: flags |= psEnc->state_Fxx[ n ].sCmn.LBRR_flag; cannam@154: } cannam@154: if( !prefillFlag ) { cannam@154: ec_enc_patch_initial_bits( psRangeEnc, flags, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal ); cannam@154: } cannam@154: cannam@154: /* Return zero bytes if all channels DTXed */ cannam@154: if( psEnc->state_Fxx[ 0 ].sCmn.inDTX && ( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inDTX ) ) { cannam@154: *nBytesOut = 0; cannam@154: } cannam@154: cannam@154: psEnc->nBitsExceeded += *nBytesOut * 8; cannam@154: psEnc->nBitsExceeded -= silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 ); cannam@154: psEnc->nBitsExceeded = silk_LIMIT( psEnc->nBitsExceeded, 0, 10000 ); cannam@154: cannam@154: /* Update flag indicating if bandwidth switching is allowed */ cannam@154: speech_act_thr_for_switch_Q8 = silk_SMLAWB( SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ), cannam@154: SILK_FIX_CONST( ( 1 - SPEECH_ACTIVITY_DTX_THRES ) / MAX_BANDWIDTH_SWITCH_DELAY_MS, 16 + 8 ), psEnc->timeSinceSwitchAllowed_ms ); cannam@154: if( psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8 < speech_act_thr_for_switch_Q8 ) { cannam@154: psEnc->allowBandwidthSwitch = 1; cannam@154: psEnc->timeSinceSwitchAllowed_ms = 0; cannam@154: } else { cannam@154: psEnc->allowBandwidthSwitch = 0; cannam@154: psEnc->timeSinceSwitchAllowed_ms += encControl->payloadSize_ms; cannam@154: } cannam@154: } cannam@154: cannam@154: if( nSamplesIn == 0 ) { cannam@154: break; cannam@154: } cannam@154: } else { cannam@154: break; cannam@154: } cannam@154: curr_block++; cannam@154: } cannam@154: cannam@154: psEnc->nPrevChannelsInternal = encControl->nChannelsInternal; cannam@154: cannam@154: encControl->allowBandwidthSwitch = psEnc->allowBandwidthSwitch; cannam@154: encControl->inWBmodeWithoutVariableLP = psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == 16 && psEnc->state_Fxx[ 0 ].sCmn.sLP.mode == 0; cannam@154: encControl->internalSampleRate = silk_SMULBB( psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, 1000 ); cannam@154: encControl->stereoWidth_Q14 = encControl->toMono ? 0 : psEnc->sStereo.smth_width_Q14; cannam@154: if( prefillFlag ) { cannam@154: encControl->payloadSize_ms = tmp_payloadSize_ms; cannam@154: encControl->complexity = tmp_complexity; cannam@154: for( n = 0; n < encControl->nChannelsInternal; n++ ) { cannam@154: psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0; cannam@154: psEnc->state_Fxx[ n ].sCmn.prefillFlag = 0; cannam@154: } cannam@154: } cannam@154: cannam@154: encControl->signalType = psEnc->state_Fxx[0].sCmn.indices.signalType; cannam@154: encControl->offset = silk_Quantization_Offsets_Q10 cannam@154: [ psEnc->state_Fxx[0].sCmn.indices.signalType >> 1 ] cannam@154: [ psEnc->state_Fxx[0].sCmn.indices.quantOffsetType ]; cannam@154: RESTORE_STACK; cannam@154: return ret; cannam@154: } cannam@154: