The Tor Browser / file comparison
comparison: media/libopus/silk/enc_API.c
media/libopus/silk/enc_API.c
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:24e93f7264f8 |
|---|---|
| 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. | |
| 11 - Neither the name of Internet Society, IETF or IETF Trust, nor the | |
| 12 names of specific contributors, may be used to endorse or promote | |
| 13 products derived from this software without specific prior written | |
| 14 permission. | |
| 15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| 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" | |
| 35 #include "stack_alloc.h" | |
| 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 */ | |
| 72 int arch, /* I Run-time architecture */ | |
| 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++ ) { | |
| 84 if( ret += silk_init_encoder( &psEnc->state_Fxx[ n ], arch ) ) { | |
| 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; | |
| 151 opus_int nSamplesToBuffer, nSamplesToBufferMax, nBlocksOf10ms; | |
| 152 opus_int nSamplesFromInput = 0, nSamplesFromInputMax; | |
| 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; | |
| 156 VARDECL( opus_int16, buf ); | |
| 157 opus_int transition, curr_block, tot_blocks; | |
| 158 SAVE_STACK; | |
| 159 | |
| 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 } | |
| 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 ); | |
| 170 RESTORE_STACK; | |
| 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 */ | |
| 178 ret += silk_init_encoder( &psEnc->state_Fxx[ 1 ], psEnc->state_Fxx[ 0 ].sCmn.arch ); | |
| 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 ) { | |
| 204 silk_assert( 0 ); | |
| 205 RESTORE_STACK; | |
| 206 return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; | |
| 207 } | |
| 208 /* Reset Encoder */ | |
| 209 for( n = 0; n < encControl->nChannelsInternal; n++ ) { | |
| 210 ret = silk_init_encoder( &psEnc->state_Fxx[ n ], psEnc->state_Fxx[ n ].sCmn.arch ); | |
| 211 silk_assert( !ret ); | |
| 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 ) { | |
| 224 silk_assert( 0 ); | |
| 225 RESTORE_STACK; | |
| 226 return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; | |
| 227 } | |
| 228 /* Make sure no more than one packet can be produced */ | |
| 229 if( 1000 * (opus_int32)nSamplesIn > encControl->payloadSize_ms * encControl->API_sampleRate ) { | |
| 230 silk_assert( 0 ); | |
| 231 RESTORE_STACK; | |
| 232 return SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES; | |
| 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 ); | |
| 242 RESTORE_STACK; | |
| 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 */ | |
| 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 ); | |
| 262 while( 1 ) { | |
| 263 nSamplesToBuffer = psEnc->state_Fxx[ 0 ].sCmn.frame_length - psEnc->state_Fxx[ 0 ].sCmn.inputBufIx; | |
| 264 nSamplesToBuffer = silk_min( nSamplesToBuffer, nSamplesToBufferMax ); | |
| 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 | |
| 553 RESTORE_STACK; | |
| 554 return ret; | |
| 555 } | |
| 556 |
