Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 1 | /*********************************************************************** |
| 2 | Copyright (c) 2006-2011, Skype Limited. All rights reserved. |
| 3 | Redistribution and use in source and binary forms, with or without |
| 4 | modification, are permitted provided that the following conditions |
| 5 | are met: |
| 6 | - Redistributions of source code must retain the above copyright notice, |
| 7 | this list of conditions and the following disclaimer. |
| 8 | - Redistributions in binary form must reproduce the above copyright |
| 9 | notice, this list of conditions and the following disclaimer in the |
| 10 | documentation and/or other materials provided with the distribution. |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 11 | - Neither the name of Internet Society, IETF or IETF Trust, nor the |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 12 | names of specific contributors, may be used to endorse or promote |
| 13 | products derived from this software without specific prior written |
| 14 | permission. |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 16 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 17 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 18 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| 19 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 20 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 21 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| 22 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| 23 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 24 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 25 | POSSIBILITY OF SUCH DAMAGE. |
| 26 | ***********************************************************************/ |
| 27 | |
| 28 | #ifdef HAVE_CONFIG_H |
| 29 | #include "config.h" |
| 30 | #endif |
| 31 | #include "define.h" |
| 32 | #include "API.h" |
| 33 | #include "control.h" |
| 34 | #include "typedef.h" |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 35 | #include "stack_alloc.h" |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 36 | #include "structs.h" |
| 37 | #include "tuning_parameters.h" |
| 38 | #ifdef FIXED_POINT |
| 39 | #include "main_FIX.h" |
| 40 | #else |
| 41 | #include "main_FLP.h" |
| 42 | #endif |
| 43 | |
| 44 | /***************************************/ |
| 45 | /* Read control structure from encoder */ |
| 46 | /***************************************/ |
| 47 | static opus_int silk_QueryEncoder( /* O Returns error code */ |
| 48 | const void *encState, /* I State */ |
| 49 | silk_EncControlStruct *encStatus /* O Encoder Status */ |
| 50 | ); |
| 51 | |
| 52 | /****************************************/ |
| 53 | /* Encoder functions */ |
| 54 | /****************************************/ |
| 55 | |
| 56 | opus_int silk_Get_Encoder_Size( /* O Returns error code */ |
| 57 | opus_int *encSizeBytes /* O Number of bytes in SILK encoder state */ |
| 58 | ) |
| 59 | { |
| 60 | opus_int ret = SILK_NO_ERROR; |
| 61 | |
| 62 | *encSizeBytes = sizeof( silk_encoder ); |
| 63 | |
| 64 | return ret; |
| 65 | } |
| 66 | |
| 67 | /*************************/ |
| 68 | /* Init or Reset encoder */ |
| 69 | /*************************/ |
| 70 | opus_int silk_InitEncoder( /* O Returns error code */ |
| 71 | void *encState, /* I/O State */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 72 | int arch, /* I Run-time architecture */ |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 73 | silk_EncControlStruct *encStatus /* O Encoder Status */ |
| 74 | ) |
| 75 | { |
| 76 | silk_encoder *psEnc; |
| 77 | opus_int n, ret = SILK_NO_ERROR; |
| 78 | |
| 79 | psEnc = (silk_encoder *)encState; |
| 80 | |
| 81 | /* Reset encoder */ |
| 82 | silk_memset( psEnc, 0, sizeof( silk_encoder ) ); |
| 83 | for( n = 0; n < ENCODER_NUM_CHANNELS; n++ ) { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 84 | if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ], arch ) ) { |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 85 | silk_assert( 0 ); |
| 86 | } |
| 87 | } |
| 88 | |
| 89 | psEnc->nChannelsAPI = 1; |
| 90 | psEnc->nChannelsInternal = 1; |
| 91 | |
| 92 | /* Read control structure */ |
| 93 | if( ret += silk_QueryEncoder( encState, encStatus ) ) { |
| 94 | silk_assert( 0 ); |
| 95 | } |
| 96 | |
| 97 | return ret; |
| 98 | } |
| 99 | |
| 100 | /***************************************/ |
| 101 | /* Read control structure from encoder */ |
| 102 | /***************************************/ |
| 103 | static opus_int silk_QueryEncoder( /* O Returns error code */ |
| 104 | const void *encState, /* I State */ |
| 105 | silk_EncControlStruct *encStatus /* O Encoder Status */ |
| 106 | ) |
| 107 | { |
| 108 | opus_int ret = SILK_NO_ERROR; |
| 109 | silk_encoder_state_Fxx *state_Fxx; |
| 110 | silk_encoder *psEnc = (silk_encoder *)encState; |
| 111 | |
| 112 | state_Fxx = psEnc->state_Fxx; |
| 113 | |
| 114 | encStatus->nChannelsAPI = psEnc->nChannelsAPI; |
| 115 | encStatus->nChannelsInternal = psEnc->nChannelsInternal; |
| 116 | encStatus->API_sampleRate = state_Fxx[ 0 ].sCmn.API_fs_Hz; |
| 117 | encStatus->maxInternalSampleRate = state_Fxx[ 0 ].sCmn.maxInternal_fs_Hz; |
| 118 | encStatus->minInternalSampleRate = state_Fxx[ 0 ].sCmn.minInternal_fs_Hz; |
| 119 | encStatus->desiredInternalSampleRate = state_Fxx[ 0 ].sCmn.desiredInternal_fs_Hz; |
| 120 | encStatus->payloadSize_ms = state_Fxx[ 0 ].sCmn.PacketSize_ms; |
| 121 | encStatus->bitRate = state_Fxx[ 0 ].sCmn.TargetRate_bps; |
| 122 | encStatus->packetLossPercentage = state_Fxx[ 0 ].sCmn.PacketLoss_perc; |
| 123 | encStatus->complexity = state_Fxx[ 0 ].sCmn.Complexity; |
| 124 | encStatus->useInBandFEC = state_Fxx[ 0 ].sCmn.useInBandFEC; |
| 125 | encStatus->useDTX = state_Fxx[ 0 ].sCmn.useDTX; |
| 126 | encStatus->useCBR = state_Fxx[ 0 ].sCmn.useCBR; |
| 127 | encStatus->internalSampleRate = silk_SMULBB( state_Fxx[ 0 ].sCmn.fs_kHz, 1000 ); |
| 128 | encStatus->allowBandwidthSwitch = state_Fxx[ 0 ].sCmn.allow_bandwidth_switch; |
| 129 | encStatus->inWBmodeWithoutVariableLP = state_Fxx[ 0 ].sCmn.fs_kHz == 16 && state_Fxx[ 0 ].sCmn.sLP.mode == 0; |
| 130 | |
| 131 | return ret; |
| 132 | } |
| 133 | |
| 134 | |
| 135 | /**************************/ |
| 136 | /* Encode frame with Silk */ |
| 137 | /**************************/ |
| 138 | /* Note: if prefillFlag is set, the input must contain 10 ms of audio, irrespective of what */ |
| 139 | /* encControl->payloadSize_ms is set to */ |
| 140 | opus_int silk_Encode( /* O Returns error code */ |
| 141 | void *encState, /* I/O State */ |
| 142 | silk_EncControlStruct *encControl, /* I Control status */ |
| 143 | const opus_int16 *samplesIn, /* I Speech sample input vector */ |
| 144 | opus_int nSamplesIn, /* I Number of samples in input vector */ |
| 145 | ec_enc *psRangeEnc, /* I/O Compressor data structure */ |
| 146 | opus_int32 *nBytesOut, /* I/O Number of bytes in payload (input: Max bytes) */ |
| 147 | const opus_int prefillFlag /* I Flag to indicate prefilling buffers no coding */ |
| 148 | ) |
| 149 | { |
| 150 | opus_int n, i, nBits, flags, tmp_payloadSize_ms = 0, tmp_complexity = 0, ret = 0; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 151 | opus_int nSamplesToBuffer, nSamplesToBufferMax, nBlocksOf10ms; |
| 152 | opus_int nSamplesFromInput = 0, nSamplesFromInputMax; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 153 | opus_int speech_act_thr_for_switch_Q8; |
| 154 | opus_int32 TargetRate_bps, MStargetRates_bps[ 2 ], channelRate_bps, LBRR_symbol, sum; |
| 155 | silk_encoder *psEnc = ( silk_encoder * )encState; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 156 | VARDECL( opus_int16, buf ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 157 | opus_int transition, curr_block, tot_blocks; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 158 | SAVE_STACK; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 159 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 160 | if (encControl->reducedDependency) |
| 161 | { |
| 162 | psEnc->state_Fxx[0].sCmn.first_frame_after_reset = 1; |
| 163 | psEnc->state_Fxx[1].sCmn.first_frame_after_reset = 1; |
| 164 | } |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 165 | psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded = psEnc->state_Fxx[ 1 ].sCmn.nFramesEncoded = 0; |
| 166 | |
| 167 | /* Check values in encoder control structure */ |
| 168 | if( ( ret = check_control_input( encControl ) != 0 ) ) { |
| 169 | silk_assert( 0 ); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 170 | RESTORE_STACK; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 171 | return ret; |
| 172 | } |
| 173 | |
| 174 | encControl->switchReady = 0; |
| 175 | |
| 176 | if( encControl->nChannelsInternal > psEnc->nChannelsInternal ) { |
| 177 | /* Mono -> Stereo transition: init state of second channel and stereo state */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 178 | ret += silk_init_encoder( &psEnc->state_Fxx[ 1 ], psEnc->state_Fxx[ 0 ].sCmn.arch ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 179 | silk_memset( psEnc->sStereo.pred_prev_Q13, 0, sizeof( psEnc->sStereo.pred_prev_Q13 ) ); |
| 180 | silk_memset( psEnc->sStereo.sSide, 0, sizeof( psEnc->sStereo.sSide ) ); |
| 181 | psEnc->sStereo.mid_side_amp_Q0[ 0 ] = 0; |
| 182 | psEnc->sStereo.mid_side_amp_Q0[ 1 ] = 1; |
| 183 | psEnc->sStereo.mid_side_amp_Q0[ 2 ] = 0; |
| 184 | psEnc->sStereo.mid_side_amp_Q0[ 3 ] = 1; |
| 185 | psEnc->sStereo.width_prev_Q14 = 0; |
| 186 | psEnc->sStereo.smth_width_Q14 = SILK_FIX_CONST( 1, 14 ); |
| 187 | if( psEnc->nChannelsAPI == 2 ) { |
| 188 | silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof( silk_resampler_state_struct ) ); |
| 189 | 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 ) ); |
| 190 | } |
| 191 | } |
| 192 | |
| 193 | transition = (encControl->payloadSize_ms != psEnc->state_Fxx[ 0 ].sCmn.PacketSize_ms) || (psEnc->nChannelsInternal != encControl->nChannelsInternal); |
| 194 | |
| 195 | psEnc->nChannelsAPI = encControl->nChannelsAPI; |
| 196 | psEnc->nChannelsInternal = encControl->nChannelsInternal; |
| 197 | |
| 198 | nBlocksOf10ms = silk_DIV32( 100 * nSamplesIn, encControl->API_sampleRate ); |
| 199 | tot_blocks = ( nBlocksOf10ms > 1 ) ? nBlocksOf10ms >> 1 : 1; |
| 200 | curr_block = 0; |
| 201 | if( prefillFlag ) { |
| 202 | /* Only accept input length of 10 ms */ |
| 203 | if( nBlocksOf10ms != 1 ) { |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 204 | silk_assert( 0 ); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 205 | RESTORE_STACK; |
| 206 | return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 207 | } |
| 208 | /* Reset Encoder */ |
| 209 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 210 | ret = silk_init_encoder( &psEnc->state_Fxx[ n ], psEnc->state_Fxx[ n ].sCmn.arch ); |
| 211 | silk_assert( !ret ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 212 | } |
| 213 | tmp_payloadSize_ms = encControl->payloadSize_ms; |
| 214 | encControl->payloadSize_ms = 10; |
| 215 | tmp_complexity = encControl->complexity; |
| 216 | encControl->complexity = 0; |
| 217 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 218 | psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0; |
| 219 | psEnc->state_Fxx[ n ].sCmn.prefillFlag = 1; |
| 220 | } |
| 221 | } else { |
| 222 | /* Only accept input lengths that are a multiple of 10 ms */ |
| 223 | if( nBlocksOf10ms * encControl->API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0 ) { |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 224 | silk_assert( 0 ); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 225 | RESTORE_STACK; |
| 226 | return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 227 | } |
| 228 | /* Make sure no more than one packet can be produced */ |
| 229 | if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) { |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 230 | silk_assert( 0 ); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 231 | RESTORE_STACK; |
| 232 | return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 233 | } |
| 234 | } |
| 235 | |
| 236 | TargetRate_bps = silk_RSHIFT32( encControl->bitRate, encControl->nChannelsInternal - 1 ); |
| 237 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 238 | /* Force the side channel to the same rate as the mid */ |
| 239 | opus_int force_fs_kHz = (n==1) ? psEnc->state_Fxx[0].sCmn.fs_kHz : 0; |
| 240 | if( ( ret = silk_control_encoder( &psEnc->state_Fxx[ n ], encControl, TargetRate_bps, psEnc->allowBandwidthSwitch, n, force_fs_kHz ) ) != 0 ) { |
| 241 | silk_assert( 0 ); |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 242 | RESTORE_STACK; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 243 | return ret; |
| 244 | } |
| 245 | if( psEnc->state_Fxx[n].sCmn.first_frame_after_reset || transition ) { |
| 246 | for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) { |
| 247 | psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] = 0; |
| 248 | } |
| 249 | } |
| 250 | psEnc->state_Fxx[ n ].sCmn.inDTX = psEnc->state_Fxx[ n ].sCmn.useDTX; |
| 251 | } |
| 252 | silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == psEnc->state_Fxx[ 1 ].sCmn.fs_kHz ); |
| 253 | |
| 254 | /* Input buffering/resampling and encoding */ |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 255 | nSamplesToBufferMax = |
| 256 | 10 * nBlocksOf10ms * psEnc->state_Fxx[ 0 ].sCmn.fs_kHz; |
| 257 | nSamplesFromInputMax = |
| 258 | silk_DIV32_16( nSamplesToBufferMax * |
| 259 | psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, |
| 260 | psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 ); |
| 261 | ALLOC( buf, nSamplesFromInputMax, opus_int16 ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 262 | while( 1 ) { |
| 263 | nSamplesToBuffer = psEnc->state_Fxx[ 0 ].sCmn.frame_length - psEnc->state_Fxx[ 0 ].sCmn.inputBufIx; |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 264 | nSamplesToBuffer = silk_min( nSamplesToBuffer, nSamplesToBufferMax ); |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 265 | nSamplesFromInput = silk_DIV32_16( nSamplesToBuffer * psEnc->state_Fxx[ 0 ].sCmn.API_fs_Hz, psEnc->state_Fxx[ 0 ].sCmn.fs_kHz * 1000 ); |
| 266 | /* Resample and write to buffer */ |
| 267 | if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 2 ) { |
| 268 | opus_int id = psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded; |
| 269 | for( n = 0; n < nSamplesFromInput; n++ ) { |
| 270 | buf[ n ] = samplesIn[ 2 * n ]; |
| 271 | } |
| 272 | /* Making sure to start both resamplers from the same state when switching from mono to stereo */ |
| 273 | if( psEnc->nPrevChannelsInternal == 1 && id==0 ) { |
| 274 | silk_memcpy( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, sizeof(psEnc->state_Fxx[ 1 ].sCmn.resampler_state)); |
| 275 | } |
| 276 | |
| 277 | ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, |
| 278 | &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); |
| 279 | psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer; |
| 280 | |
| 281 | nSamplesToBuffer = psEnc->state_Fxx[ 1 ].sCmn.frame_length - psEnc->state_Fxx[ 1 ].sCmn.inputBufIx; |
| 282 | nSamplesToBuffer = silk_min( nSamplesToBuffer, 10 * nBlocksOf10ms * psEnc->state_Fxx[ 1 ].sCmn.fs_kHz ); |
| 283 | for( n = 0; n < nSamplesFromInput; n++ ) { |
| 284 | buf[ n ] = samplesIn[ 2 * n + 1 ]; |
| 285 | } |
| 286 | ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, |
| 287 | &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); |
| 288 | |
| 289 | psEnc->state_Fxx[ 1 ].sCmn.inputBufIx += nSamplesToBuffer; |
| 290 | } else if( encControl->nChannelsAPI == 2 && encControl->nChannelsInternal == 1 ) { |
| 291 | /* Combine left and right channels before resampling */ |
| 292 | for( n = 0; n < nSamplesFromInput; n++ ) { |
| 293 | sum = samplesIn[ 2 * n ] + samplesIn[ 2 * n + 1 ]; |
| 294 | buf[ n ] = (opus_int16)silk_RSHIFT_ROUND( sum, 1 ); |
| 295 | } |
| 296 | ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, |
| 297 | &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); |
| 298 | /* On the first mono frame, average the results for the two resampler states */ |
| 299 | if( psEnc->nPrevChannelsInternal == 2 && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 ) { |
| 300 | ret += silk_resampler( &psEnc->state_Fxx[ 1 ].sCmn.resampler_state, |
| 301 | &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); |
| 302 | for( n = 0; n < psEnc->state_Fxx[ 0 ].sCmn.frame_length; n++ ) { |
| 303 | psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx+n+2 ] = |
| 304 | silk_RSHIFT(psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx+n+2 ] |
| 305 | + psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ psEnc->state_Fxx[ 1 ].sCmn.inputBufIx+n+2 ], 1); |
| 306 | } |
| 307 | } |
| 308 | psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer; |
| 309 | } else { |
| 310 | silk_assert( encControl->nChannelsAPI == 1 && encControl->nChannelsInternal == 1 ); |
| 311 | silk_memcpy(buf, samplesIn, nSamplesFromInput*sizeof(opus_int16)); |
| 312 | ret += silk_resampler( &psEnc->state_Fxx[ 0 ].sCmn.resampler_state, |
| 313 | &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.inputBufIx + 2 ], buf, nSamplesFromInput ); |
| 314 | psEnc->state_Fxx[ 0 ].sCmn.inputBufIx += nSamplesToBuffer; |
| 315 | } |
| 316 | |
| 317 | samplesIn += nSamplesFromInput * encControl->nChannelsAPI; |
| 318 | nSamplesIn -= nSamplesFromInput; |
| 319 | |
| 320 | /* Default */ |
| 321 | psEnc->allowBandwidthSwitch = 0; |
| 322 | |
| 323 | /* Silk encoder */ |
| 324 | if( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx >= psEnc->state_Fxx[ 0 ].sCmn.frame_length ) { |
| 325 | /* Enough data in input buffer, so encode */ |
| 326 | silk_assert( psEnc->state_Fxx[ 0 ].sCmn.inputBufIx == psEnc->state_Fxx[ 0 ].sCmn.frame_length ); |
| 327 | silk_assert( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inputBufIx == psEnc->state_Fxx[ 1 ].sCmn.frame_length ); |
| 328 | |
| 329 | /* Deal with LBRR data */ |
| 330 | if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == 0 && !prefillFlag ) { |
| 331 | /* Create space at start of payload for VAD and FEC flags */ |
| 332 | opus_uint8 iCDF[ 2 ] = { 0, 0 }; |
| 333 | iCDF[ 0 ] = 256 - silk_RSHIFT( 256, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal ); |
| 334 | ec_enc_icdf( psRangeEnc, 0, iCDF, 8 ); |
| 335 | |
| 336 | /* Encode any LBRR data from previous packet */ |
| 337 | /* Encode LBRR flags */ |
| 338 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 339 | LBRR_symbol = 0; |
| 340 | for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) { |
| 341 | LBRR_symbol |= silk_LSHIFT( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ], i ); |
| 342 | } |
| 343 | psEnc->state_Fxx[ n ].sCmn.LBRR_flag = LBRR_symbol > 0 ? 1 : 0; |
| 344 | if( LBRR_symbol && psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket > 1 ) { |
| 345 | ec_enc_icdf( psRangeEnc, LBRR_symbol - 1, silk_LBRR_flags_iCDF_ptr[ psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket - 2 ], 8 ); |
| 346 | } |
| 347 | } |
| 348 | |
| 349 | /* Code LBRR indices and excitation signals */ |
| 350 | for( i = 0; i < psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket; i++ ) { |
| 351 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 352 | if( psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i ] ) { |
| 353 | opus_int condCoding; |
| 354 | |
| 355 | if( encControl->nChannelsInternal == 2 && n == 0 ) { |
| 356 | silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ i ] ); |
| 357 | /* For LBRR data there's no need to code the mid-only flag if the side-channel LBRR flag is set */ |
| 358 | if( psEnc->state_Fxx[ 1 ].sCmn.LBRR_flags[ i ] == 0 ) { |
| 359 | silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ i ] ); |
| 360 | } |
| 361 | } |
| 362 | /* Use conditional coding if previous frame available */ |
| 363 | if( i > 0 && psEnc->state_Fxx[ n ].sCmn.LBRR_flags[ i - 1 ] ) { |
| 364 | condCoding = CODE_CONDITIONALLY; |
| 365 | } else { |
| 366 | condCoding = CODE_INDEPENDENTLY; |
| 367 | } |
| 368 | silk_encode_indices( &psEnc->state_Fxx[ n ].sCmn, psRangeEnc, i, 1, condCoding ); |
| 369 | silk_encode_pulses( psRangeEnc, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].signalType, psEnc->state_Fxx[ n ].sCmn.indices_LBRR[i].quantOffsetType, |
| 370 | psEnc->state_Fxx[ n ].sCmn.pulses_LBRR[ i ], psEnc->state_Fxx[ n ].sCmn.frame_length ); |
| 371 | } |
| 372 | } |
| 373 | } |
| 374 | |
| 375 | /* Reset LBRR flags */ |
| 376 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 377 | silk_memset( psEnc->state_Fxx[ n ].sCmn.LBRR_flags, 0, sizeof( psEnc->state_Fxx[ n ].sCmn.LBRR_flags ) ); |
| 378 | } |
| 379 | } |
| 380 | |
| 381 | silk_HP_variable_cutoff( psEnc->state_Fxx ); |
| 382 | |
| 383 | /* Total target bits for packet */ |
| 384 | nBits = silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 ); |
| 385 | /* Subtract half of the bits already used */ |
| 386 | if( !prefillFlag ) { |
| 387 | nBits -= ec_tell( psRangeEnc ) >> 1; |
| 388 | } |
| 389 | /* Divide by number of uncoded frames left in packet */ |
| 390 | nBits = silk_DIV32_16( nBits, psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket - psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ); |
| 391 | /* Convert to bits/second */ |
| 392 | if( encControl->payloadSize_ms == 10 ) { |
| 393 | TargetRate_bps = silk_SMULBB( nBits, 100 ); |
| 394 | } else { |
| 395 | TargetRate_bps = silk_SMULBB( nBits, 50 ); |
| 396 | } |
| 397 | /* Subtract fraction of bits in excess of target in previous packets */ |
| 398 | TargetRate_bps -= silk_DIV32_16( silk_MUL( psEnc->nBitsExceeded, 1000 ), BITRESERVOIR_DECAY_TIME_MS ); |
| 399 | /* Never exceed input bitrate */ |
| 400 | TargetRate_bps = silk_LIMIT( TargetRate_bps, encControl->bitRate, 5000 ); |
| 401 | |
| 402 | /* Convert Left/Right to Mid/Side */ |
| 403 | if( encControl->nChannelsInternal == 2 ) { |
| 404 | silk_stereo_LR_to_MS( &psEnc->sStereo, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ 2 ], &psEnc->state_Fxx[ 1 ].sCmn.inputBuf[ 2 ], |
| 405 | psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], &psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ], |
| 406 | MStargetRates_bps, TargetRate_bps, psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8, encControl->toMono, |
| 407 | psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, psEnc->state_Fxx[ 0 ].sCmn.frame_length ); |
| 408 | if( psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] == 0 ) { |
| 409 | /* Reset side channel encoder memory for first frame with side coding */ |
| 410 | if( psEnc->prev_decode_only_middle == 1 ) { |
| 411 | silk_memset( &psEnc->state_Fxx[ 1 ].sShape, 0, sizeof( psEnc->state_Fxx[ 1 ].sShape ) ); |
| 412 | silk_memset( &psEnc->state_Fxx[ 1 ].sPrefilt, 0, sizeof( psEnc->state_Fxx[ 1 ].sPrefilt ) ); |
| 413 | silk_memset( &psEnc->state_Fxx[ 1 ].sCmn.sNSQ, 0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.sNSQ ) ); |
| 414 | silk_memset( psEnc->state_Fxx[ 1 ].sCmn.prev_NLSFq_Q15, 0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.prev_NLSFq_Q15 ) ); |
| 415 | silk_memset( &psEnc->state_Fxx[ 1 ].sCmn.sLP.In_LP_State, 0, sizeof( psEnc->state_Fxx[ 1 ].sCmn.sLP.In_LP_State ) ); |
| 416 | psEnc->state_Fxx[ 1 ].sCmn.prevLag = 100; |
| 417 | psEnc->state_Fxx[ 1 ].sCmn.sNSQ.lagPrev = 100; |
| 418 | psEnc->state_Fxx[ 1 ].sShape.LastGainIndex = 10; |
| 419 | psEnc->state_Fxx[ 1 ].sCmn.prevSignalType = TYPE_NO_VOICE_ACTIVITY; |
| 420 | psEnc->state_Fxx[ 1 ].sCmn.sNSQ.prev_gain_Q16 = 65536; |
| 421 | psEnc->state_Fxx[ 1 ].sCmn.first_frame_after_reset = 1; |
| 422 | } |
| 423 | silk_encode_do_VAD_Fxx( &psEnc->state_Fxx[ 1 ] ); |
| 424 | } else { |
| 425 | psEnc->state_Fxx[ 1 ].sCmn.VAD_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] = 0; |
| 426 | } |
| 427 | if( !prefillFlag ) { |
| 428 | silk_stereo_encode_pred( psRangeEnc, psEnc->sStereo.predIx[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] ); |
| 429 | if( psEnc->state_Fxx[ 1 ].sCmn.VAD_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] == 0 ) { |
| 430 | silk_stereo_encode_mid_only( psRangeEnc, psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded ] ); |
| 431 | } |
| 432 | } |
| 433 | } else { |
| 434 | /* Buffering */ |
| 435 | silk_memcpy( psEnc->state_Fxx[ 0 ].sCmn.inputBuf, psEnc->sStereo.sMid, 2 * sizeof( opus_int16 ) ); |
| 436 | silk_memcpy( psEnc->sStereo.sMid, &psEnc->state_Fxx[ 0 ].sCmn.inputBuf[ psEnc->state_Fxx[ 0 ].sCmn.frame_length ], 2 * sizeof( opus_int16 ) ); |
| 437 | } |
| 438 | silk_encode_do_VAD_Fxx( &psEnc->state_Fxx[ 0 ] ); |
| 439 | |
| 440 | /* Encode */ |
| 441 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 442 | opus_int maxBits, useCBR; |
| 443 | |
| 444 | /* Handling rate constraints */ |
| 445 | maxBits = encControl->maxBits; |
| 446 | if( tot_blocks == 2 && curr_block == 0 ) { |
| 447 | maxBits = maxBits * 3 / 5; |
| 448 | } else if( tot_blocks == 3 ) { |
| 449 | if( curr_block == 0 ) { |
| 450 | maxBits = maxBits * 2 / 5; |
| 451 | } else if( curr_block == 1 ) { |
| 452 | maxBits = maxBits * 3 / 4; |
| 453 | } |
| 454 | } |
| 455 | useCBR = encControl->useCBR && curr_block == tot_blocks - 1; |
| 456 | |
| 457 | if( encControl->nChannelsInternal == 1 ) { |
| 458 | channelRate_bps = TargetRate_bps; |
| 459 | } else { |
| 460 | channelRate_bps = MStargetRates_bps[ n ]; |
| 461 | if( n == 0 && MStargetRates_bps[ 1 ] > 0 ) { |
| 462 | useCBR = 0; |
| 463 | /* Give mid up to 1/2 of the max bits for that frame */ |
| 464 | maxBits -= encControl->maxBits / ( tot_blocks * 2 ); |
| 465 | } |
| 466 | } |
| 467 | |
| 468 | if( channelRate_bps > 0 ) { |
| 469 | opus_int condCoding; |
| 470 | |
| 471 | silk_control_SNR( &psEnc->state_Fxx[ n ].sCmn, channelRate_bps ); |
| 472 | |
| 473 | /* Use independent coding if no previous frame available */ |
| 474 | if( psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded - n <= 0 ) { |
| 475 | condCoding = CODE_INDEPENDENTLY; |
| 476 | } else if( n > 0 && psEnc->prev_decode_only_middle ) { |
| 477 | /* If we skipped a side frame in this packet, we don't |
| 478 | need LTP scaling; the LTP state is well-defined. */ |
| 479 | condCoding = CODE_INDEPENDENTLY_NO_LTP_SCALING; |
| 480 | } else { |
| 481 | condCoding = CODE_CONDITIONALLY; |
| 482 | } |
| 483 | if( ( ret = silk_encode_frame_Fxx( &psEnc->state_Fxx[ n ], nBytesOut, psRangeEnc, condCoding, maxBits, useCBR ) ) != 0 ) { |
| 484 | silk_assert( 0 ); |
| 485 | } |
| 486 | } |
| 487 | psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0; |
| 488 | psEnc->state_Fxx[ n ].sCmn.inputBufIx = 0; |
| 489 | psEnc->state_Fxx[ n ].sCmn.nFramesEncoded++; |
| 490 | } |
| 491 | psEnc->prev_decode_only_middle = psEnc->sStereo.mid_only_flags[ psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded - 1 ]; |
| 492 | |
| 493 | /* Insert VAD and FEC flags at beginning of bitstream */ |
| 494 | if( *nBytesOut > 0 && psEnc->state_Fxx[ 0 ].sCmn.nFramesEncoded == psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket) { |
| 495 | flags = 0; |
| 496 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 497 | for( i = 0; i < psEnc->state_Fxx[ n ].sCmn.nFramesPerPacket; i++ ) { |
| 498 | flags = silk_LSHIFT( flags, 1 ); |
| 499 | flags |= psEnc->state_Fxx[ n ].sCmn.VAD_flags[ i ]; |
| 500 | } |
| 501 | flags = silk_LSHIFT( flags, 1 ); |
| 502 | flags |= psEnc->state_Fxx[ n ].sCmn.LBRR_flag; |
| 503 | } |
| 504 | if( !prefillFlag ) { |
| 505 | ec_enc_patch_initial_bits( psRangeEnc, flags, ( psEnc->state_Fxx[ 0 ].sCmn.nFramesPerPacket + 1 ) * encControl->nChannelsInternal ); |
| 506 | } |
| 507 | |
| 508 | /* Return zero bytes if all channels DTXed */ |
| 509 | if( psEnc->state_Fxx[ 0 ].sCmn.inDTX && ( encControl->nChannelsInternal == 1 || psEnc->state_Fxx[ 1 ].sCmn.inDTX ) ) { |
| 510 | *nBytesOut = 0; |
| 511 | } |
| 512 | |
| 513 | psEnc->nBitsExceeded += *nBytesOut * 8; |
| 514 | psEnc->nBitsExceeded -= silk_DIV32_16( silk_MUL( encControl->bitRate, encControl->payloadSize_ms ), 1000 ); |
| 515 | psEnc->nBitsExceeded = silk_LIMIT( psEnc->nBitsExceeded, 0, 10000 ); |
| 516 | |
| 517 | /* Update flag indicating if bandwidth switching is allowed */ |
| 518 | speech_act_thr_for_switch_Q8 = silk_SMLAWB( SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 ), |
| 519 | SILK_FIX_CONST( ( 1 - SPEECH_ACTIVITY_DTX_THRES ) / MAX_BANDWIDTH_SWITCH_DELAY_MS, 16 + 8 ), psEnc->timeSinceSwitchAllowed_ms ); |
| 520 | if( psEnc->state_Fxx[ 0 ].sCmn.speech_activity_Q8 < speech_act_thr_for_switch_Q8 ) { |
| 521 | psEnc->allowBandwidthSwitch = 1; |
| 522 | psEnc->timeSinceSwitchAllowed_ms = 0; |
| 523 | } else { |
| 524 | psEnc->allowBandwidthSwitch = 0; |
| 525 | psEnc->timeSinceSwitchAllowed_ms += encControl->payloadSize_ms; |
| 526 | } |
| 527 | } |
| 528 | |
| 529 | if( nSamplesIn == 0 ) { |
| 530 | break; |
| 531 | } |
| 532 | } else { |
| 533 | break; |
| 534 | } |
| 535 | curr_block++; |
| 536 | } |
| 537 | |
| 538 | psEnc->nPrevChannelsInternal = encControl->nChannelsInternal; |
| 539 | |
| 540 | encControl->allowBandwidthSwitch = psEnc->allowBandwidthSwitch; |
| 541 | encControl->inWBmodeWithoutVariableLP = psEnc->state_Fxx[ 0 ].sCmn.fs_kHz == 16 && psEnc->state_Fxx[ 0 ].sCmn.sLP.mode == 0; |
| 542 | encControl->internalSampleRate = silk_SMULBB( psEnc->state_Fxx[ 0 ].sCmn.fs_kHz, 1000 ); |
| 543 | encControl->stereoWidth_Q14 = encControl->toMono ? 0 : psEnc->sStereo.smth_width_Q14; |
| 544 | if( prefillFlag ) { |
| 545 | encControl->payloadSize_ms = tmp_payloadSize_ms; |
| 546 | encControl->complexity = tmp_complexity; |
| 547 | for( n = 0; n < encControl->nChannelsInternal; n++ ) { |
| 548 | psEnc->state_Fxx[ n ].sCmn.controlled_since_last_payload = 0; |
| 549 | psEnc->state_Fxx[ n ].sCmn.prefillFlag = 0; |
| 550 | } |
| 551 | } |
| 552 | |
Alexandre Lision | 8538238 | 2014-01-27 15:54:16 -0500 | [diff] [blame] | 553 | RESTORE_STACK; |
Alexandre Lision | 744f742 | 2013-09-25 11:39:37 -0400 | [diff] [blame] | 554 | return ret; |
| 555 | } |
| 556 | |