Mercurial > hg > sv-dependency-builds

annotate src/opus-1.3/silk/float/encode_frame_FLP.c @ 79:91c729825bca pa_catalina

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update build for AUDIO_COMPONENT_FIX
author Chris Cannam
date Wed, 30 Oct 2019 12:40:34 +0000
parents 7aeed7906520
children
rev   line source
Chris@69 1 /***********************************************************************
Chris@69 2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
Chris@69 3 Redistribution and use in source and binary forms, with or without
Chris@69 4 modification, are permitted provided that the following conditions
Chris@69 5 are met:
Chris@69 6 - Redistributions of source code must retain the above copyright notice,
Chris@69 7 this list of conditions and the following disclaimer.
Chris@69 8 - Redistributions in binary form must reproduce the above copyright
Chris@69 9 notice, this list of conditions and the following disclaimer in the
Chris@69 10 documentation and/or other materials provided with the distribution.
Chris@69 11 - Neither the name of Internet Society, IETF or IETF Trust, nor the
Chris@69 12 names of specific contributors, may be used to endorse or promote
Chris@69 13 products derived from this software without specific prior written
Chris@69 14 permission.
Chris@69 15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
Chris@69 16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
Chris@69 17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
Chris@69 18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
Chris@69 19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
Chris@69 20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
Chris@69 21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
Chris@69 22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
Chris@69 23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
Chris@69 24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Chris@69 25 POSSIBILITY OF SUCH DAMAGE.
Chris@69 26 ***********************************************************************/
Chris@69 27
Chris@69 28 #ifdef HAVE_CONFIG_H
Chris@69 29 #include "config.h"
Chris@69 30 #endif
Chris@69 31
Chris@69 32 #include <stdlib.h>
Chris@69 33 #include "main_FLP.h"
Chris@69 34 #include "tuning_parameters.h"
Chris@69 35
Chris@69 36 /* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate */
Chris@69 37 static OPUS_INLINE void silk_LBRR_encode_FLP(
Chris@69 38 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
Chris@69 39 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
Chris@69 40 const silk_float xfw[], /* I Input signal */
Chris@69 41 opus_int condCoding /* I The type of conditional coding used so far for this frame */
Chris@69 42 );
Chris@69 43
Chris@69 44 void silk_encode_do_VAD_FLP(
Chris@69 45 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
Chris@69 46 opus_int activity /* I Decision of Opus voice activity detector */
Chris@69 47 )
Chris@69 48 {
Chris@69 49 const opus_int activity_threshold = SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 );
Chris@69 50
Chris@69 51 /****************************/
Chris@69 52 /* Voice Activity Detection */
Chris@69 53 /****************************/
Chris@69 54 silk_VAD_GetSA_Q8( &psEnc->sCmn, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.arch );
Chris@69 55 /* If Opus VAD is inactive and Silk VAD is active: lower Silk VAD to just under the threshold */
Chris@69 56 if( activity == VAD_NO_ACTIVITY && psEnc->sCmn.speech_activity_Q8 >= activity_threshold ) {
Chris@69 57 psEnc->sCmn.speech_activity_Q8 = activity_threshold - 1;
Chris@69 58 }
Chris@69 59
Chris@69 60 /**************************************************/
Chris@69 61 /* Convert speech activity into VAD and DTX flags */
Chris@69 62 /**************************************************/
Chris@69 63 if( psEnc->sCmn.speech_activity_Q8 < activity_threshold ) {
Chris@69 64 psEnc->sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY;
Chris@69 65 psEnc->sCmn.noSpeechCounter++;
Chris@69 66 if( psEnc->sCmn.noSpeechCounter <= NB_SPEECH_FRAMES_BEFORE_DTX ) {
Chris@69 67 psEnc->sCmn.inDTX = 0;
Chris@69 68 } else if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX ) {
Chris@69 69 psEnc->sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX;
Chris@69 70 psEnc->sCmn.inDTX = 0;
Chris@69 71 }
Chris@69 72 psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 0;
Chris@69 73 } else {
Chris@69 74 psEnc->sCmn.noSpeechCounter = 0;
Chris@69 75 psEnc->sCmn.inDTX = 0;
Chris@69 76 psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
Chris@69 77 psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
Chris@69 78 }
Chris@69 79 }
Chris@69 80
Chris@69 81 /****************/
Chris@69 82 /* Encode frame */
Chris@69 83 /****************/
Chris@69 84 opus_int silk_encode_frame_FLP(
Chris@69 85 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
Chris@69 86 opus_int32 *pnBytesOut, /* O Number of payload bytes; */
Chris@69 87 ec_enc *psRangeEnc, /* I/O compressor data structure */
Chris@69 88 opus_int condCoding, /* I The type of conditional coding to use */
Chris@69 89 opus_int maxBits, /* I If > 0: maximum number of output bits */
Chris@69 90 opus_int useCBR /* I Flag to force constant-bitrate operation */
Chris@69 91 )
Chris@69 92 {
Chris@69 93 silk_encoder_control_FLP sEncCtrl;
Chris@69 94 opus_int i, iter, maxIter, found_upper, found_lower, ret = 0;
Chris@69 95 silk_float *x_frame, *res_pitch_frame;
Chris@69 96 silk_float res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
Chris@69 97 ec_enc sRangeEnc_copy, sRangeEnc_copy2;
Chris@69 98 silk_nsq_state sNSQ_copy, sNSQ_copy2;
Chris@69 99 opus_int32 seed_copy, nBits, nBits_lower, nBits_upper, gainMult_lower, gainMult_upper;
Chris@69 100 opus_int32 gainsID, gainsID_lower, gainsID_upper;
Chris@69 101 opus_int16 gainMult_Q8;
Chris@69 102 opus_int16 ec_prevLagIndex_copy;
Chris@69 103 opus_int ec_prevSignalType_copy;
Chris@69 104 opus_int8 LastGainIndex_copy2;
Chris@69 105 opus_int32 pGains_Q16[ MAX_NB_SUBFR ];
Chris@69 106 opus_uint8 ec_buf_copy[ 1275 ];
Chris@69 107 opus_int gain_lock[ MAX_NB_SUBFR ] = {0};
Chris@69 108 opus_int16 best_gain_mult[ MAX_NB_SUBFR ];
Chris@69 109 opus_int best_sum[ MAX_NB_SUBFR ];
Chris@69 110
Chris@69 111 /* This is totally unnecessary but many compilers (including gcc) are too dumb to realise it */
Chris@69 112 LastGainIndex_copy2 = nBits_lower = nBits_upper = gainMult_lower = gainMult_upper = 0;
Chris@69 113
Chris@69 114 psEnc->sCmn.indices.Seed = psEnc->sCmn.frameCounter++ & 3;
Chris@69 115
Chris@69 116 /**************************************************************/
Chris@69 117 /* Set up Input Pointers, and insert frame in input buffer */
Chris@69 118 /**************************************************************/
Chris@69 119 /* pointers aligned with start of frame to encode */
Chris@69 120 x_frame = psEnc->x_buf + psEnc->sCmn.ltp_mem_length; /* start of frame to encode */
Chris@69 121 res_pitch_frame = res_pitch + psEnc->sCmn.ltp_mem_length; /* start of pitch LPC residual frame */
Chris@69 122
Chris@69 123 /***************************************/
Chris@69 124 /* Ensure smooth bandwidth transitions */
Chris@69 125 /***************************************/
Chris@69 126 silk_LP_variable_cutoff( &psEnc->sCmn.sLP, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
Chris@69 127
Chris@69 128 /*******************************************/
Chris@69 129 /* Copy new frame to front of input buffer */
Chris@69 130 /*******************************************/
Chris@69 131 silk_short2float_array( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
Chris@69 132
Chris@69 133 /* Add tiny signal to avoid high CPU load from denormalized floating point numbers */
Chris@69 134 for( i = 0; i < 8; i++ ) {
Chris@69 135 x_frame[ LA_SHAPE_MS * psEnc->sCmn.fs_kHz + i * ( psEnc->sCmn.frame_length >> 3 ) ] += ( 1 - ( i & 2 ) ) * 1e-6f;
Chris@69 136 }
Chris@69 137
Chris@69 138 if( !psEnc->sCmn.prefillFlag ) {
Chris@69 139 /*****************************************/
Chris@69 140 /* Find pitch lags, initial LPC analysis */
Chris@69 141 /*****************************************/
Chris@69 142 silk_find_pitch_lags_FLP( psEnc, &sEncCtrl, res_pitch, x_frame, psEnc->sCmn.arch );
Chris@69 143
Chris@69 144 /************************/
Chris@69 145 /* Noise shape analysis */
Chris@69 146 /************************/
Chris@69 147 silk_noise_shape_analysis_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame );
Chris@69 148
Chris@69 149 /***************************************************/
Chris@69 150 /* Find linear prediction coefficients (LPC + LTP) */
Chris@69 151 /***************************************************/
Chris@69 152 silk_find_pred_coefs_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame, condCoding );
Chris@69 153
Chris@69 154 /****************************************/
Chris@69 155 /* Process gains */
Chris@69 156 /****************************************/
Chris@69 157 silk_process_gains_FLP( psEnc, &sEncCtrl, condCoding );
Chris@69 158
Chris@69 159 /****************************************/
Chris@69 160 /* Low Bitrate Redundant Encoding */
Chris@69 161 /****************************************/
Chris@69 162 silk_LBRR_encode_FLP( psEnc, &sEncCtrl, x_frame, condCoding );
Chris@69 163
Chris@69 164 /* Loop over quantizer and entroy coding to control bitrate */
Chris@69 165 maxIter = 6;
Chris@69 166 gainMult_Q8 = SILK_FIX_CONST( 1, 8 );
Chris@69 167 found_lower = 0;
Chris@69 168 found_upper = 0;
Chris@69 169 gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
Chris@69 170 gainsID_lower = -1;
Chris@69 171 gainsID_upper = -1;
Chris@69 172 /* Copy part of the input state */
Chris@69 173 silk_memcpy( &sRangeEnc_copy, psRangeEnc, sizeof( ec_enc ) );
Chris@69 174 silk_memcpy( &sNSQ_copy, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
Chris@69 175 seed_copy = psEnc->sCmn.indices.Seed;
Chris@69 176 ec_prevLagIndex_copy = psEnc->sCmn.ec_prevLagIndex;
Chris@69 177 ec_prevSignalType_copy = psEnc->sCmn.ec_prevSignalType;
Chris@69 178 for( iter = 0; ; iter++ ) {
Chris@69 179 if( gainsID == gainsID_lower ) {
Chris@69 180 nBits = nBits_lower;
Chris@69 181 } else if( gainsID == gainsID_upper ) {
Chris@69 182 nBits = nBits_upper;
Chris@69 183 } else {
Chris@69 184 /* Restore part of the input state */
Chris@69 185 if( iter > 0 ) {
Chris@69 186 silk_memcpy( psRangeEnc, &sRangeEnc_copy, sizeof( ec_enc ) );
Chris@69 187 silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy, sizeof( silk_nsq_state ) );
Chris@69 188 psEnc->sCmn.indices.Seed = seed_copy;
Chris@69 189 psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
Chris@69 190 psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
Chris@69 191 }
Chris@69 192
Chris@69 193 /*****************************************/
Chris@69 194 /* Noise shaping quantization */
Chris@69 195 /*****************************************/
Chris@69 196 silk_NSQ_wrapper_FLP( psEnc, &sEncCtrl, &psEnc->sCmn.indices, &psEnc->sCmn.sNSQ, psEnc->sCmn.pulses, x_frame );
Chris@69 197
Chris@69 198 if ( iter == maxIter && !found_lower ) {
Chris@69 199 silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
Chris@69 200 }
Chris@69 201
Chris@69 202 /****************************************/
Chris@69 203 /* Encode Parameters */
Chris@69 204 /****************************************/
Chris@69 205 silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
Chris@69 206
Chris@69 207 /****************************************/
Chris@69 208 /* Encode Excitation Signal */
Chris@69 209 /****************************************/
Chris@69 210 silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
Chris@69 211 psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
Chris@69 212
Chris@69 213 nBits = ec_tell( psRangeEnc );
Chris@69 214
Chris@69 215 /* If we still bust after the last iteration, do some damage control. */
Chris@69 216 if ( iter == maxIter && !found_lower && nBits > maxBits ) {
Chris@69 217 silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
Chris@69 218
Chris@69 219 /* Keep gains the same as the last frame. */
Chris@69 220 psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
Chris@69 221 for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
Chris@69 222 psEnc->sCmn.indices.GainsIndices[ i ] = 4;
Chris@69 223 }
Chris@69 224 if (condCoding != CODE_CONDITIONALLY) {
Chris@69 225 psEnc->sCmn.indices.GainsIndices[ 0 ] = sEncCtrl.lastGainIndexPrev;
Chris@69 226 }
Chris@69 227 psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
Chris@69 228 psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
Chris@69 229 /* Clear all pulses. */
Chris@69 230 for ( i = 0; i < psEnc->sCmn.frame_length; i++ ) {
Chris@69 231 psEnc->sCmn.pulses[ i ] = 0;
Chris@69 232 }
Chris@69 233
Chris@69 234 silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
Chris@69 235
Chris@69 236 silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
Chris@69 237 psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
Chris@69 238
Chris@69 239 nBits = ec_tell( psRangeEnc );
Chris@69 240 }
Chris@69 241
Chris@69 242 if( useCBR == 0 && iter == 0 && nBits <= maxBits ) {
Chris@69 243 break;
Chris@69 244 }
Chris@69 245 }
Chris@69 246
Chris@69 247 if( iter == maxIter ) {
Chris@69 248 if( found_lower && ( gainsID == gainsID_lower || nBits > maxBits ) ) {
Chris@69 249 /* Restore output state from earlier iteration that did meet the bitrate budget */
Chris@69 250 silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
Chris@69 251 celt_assert( sRangeEnc_copy2.offs <= 1275 );
Chris@69 252 silk_memcpy( psRangeEnc->buf, ec_buf_copy, sRangeEnc_copy2.offs );
Chris@69 253 silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy2, sizeof( silk_nsq_state ) );
Chris@69 254 psEnc->sShape.LastGainIndex = LastGainIndex_copy2;
Chris@69 255 }
Chris@69 256 break;
Chris@69 257 }
Chris@69 258
Chris@69 259 if( nBits > maxBits ) {
Chris@69 260 if( found_lower == 0 && iter >= 2 ) {
Chris@69 261 /* Adjust the quantizer's rate/distortion tradeoff and discard previous "upper" results */
Chris@69 262 sEncCtrl.Lambda = silk_max_float(sEncCtrl.Lambda*1.5f, 1.5f);
Chris@69 263 /* Reducing dithering can help us hit the target. */
Chris@69 264 psEnc->sCmn.indices.quantOffsetType = 0;
Chris@69 265 found_upper = 0;
Chris@69 266 gainsID_upper = -1;
Chris@69 267 } else {
Chris@69 268 found_upper = 1;
Chris@69 269 nBits_upper = nBits;
Chris@69 270 gainMult_upper = gainMult_Q8;
Chris@69 271 gainsID_upper = gainsID;
Chris@69 272 }
Chris@69 273 } else if( nBits < maxBits - 5 ) {
Chris@69 274 found_lower = 1;
Chris@69 275 nBits_lower = nBits;
Chris@69 276 gainMult_lower = gainMult_Q8;
Chris@69 277 if( gainsID != gainsID_lower ) {
Chris@69 278 gainsID_lower = gainsID;
Chris@69 279 /* Copy part of the output state */
Chris@69 280 silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
Chris@69 281 celt_assert( psRangeEnc->offs <= 1275 );
Chris@69 282 silk_memcpy( ec_buf_copy, psRangeEnc->buf, psRangeEnc->offs );
Chris@69 283 silk_memcpy( &sNSQ_copy2, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
Chris@69 284 LastGainIndex_copy2 = psEnc->sShape.LastGainIndex;
Chris@69 285 }
Chris@69 286 } else {
Chris@69 287 /* Within 5 bits of budget: close enough */
Chris@69 288 break;
Chris@69 289 }
Chris@69 290
Chris@69 291 if ( !found_lower && nBits > maxBits ) {
Chris@69 292 int j;
Chris@69 293 for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
Chris@69 294 int sum=0;
Chris@69 295 for ( j = i*psEnc->sCmn.subfr_length; j < (i+1)*psEnc->sCmn.subfr_length; j++ ) {
Chris@69 296 sum += abs( psEnc->sCmn.pulses[j] );
Chris@69 297 }
Chris@69 298 if ( iter == 0 || (sum < best_sum[i] && !gain_lock[i]) ) {
Chris@69 299 best_sum[i] = sum;
Chris@69 300 best_gain_mult[i] = gainMult_Q8;
Chris@69 301 } else {
Chris@69 302 gain_lock[i] = 1;
Chris@69 303 }
Chris@69 304 }
Chris@69 305 }
Chris@69 306 if( ( found_lower & found_upper ) == 0 ) {
Chris@69 307 /* Adjust gain according to high-rate rate/distortion curve */
Chris@69 308 if( nBits > maxBits ) {
Chris@69 309 if (gainMult_Q8 < 16384) {
Chris@69 310 gainMult_Q8 *= 2;
Chris@69 311 } else {
Chris@69 312 gainMult_Q8 = 32767;
Chris@69 313 }
Chris@69 314 } else {
Chris@69 315 opus_int32 gain_factor_Q16;
Chris@69 316 gain_factor_Q16 = silk_log2lin( silk_LSHIFT( nBits - maxBits, 7 ) / psEnc->sCmn.frame_length + SILK_FIX_CONST( 16, 7 ) );
Chris@69 317 gainMult_Q8 = silk_SMULWB( gain_factor_Q16, gainMult_Q8 );
Chris@69 318 }
Chris@69 319 } else {
Chris@69 320 /* Adjust gain by interpolating */
Chris@69 321 gainMult_Q8 = gainMult_lower + ( ( gainMult_upper - gainMult_lower ) * ( maxBits - nBits_lower ) ) / ( nBits_upper - nBits_lower );
Chris@69 322 /* New gain multplier must be between 25% and 75% of old range (note that gainMult_upper < gainMult_lower) */
Chris@69 323 if( gainMult_Q8 > silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 ) ) {
Chris@69 324 gainMult_Q8 = silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 );
Chris@69 325 } else
Chris@69 326 if( gainMult_Q8 < silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 ) ) {
Chris@69 327 gainMult_Q8 = silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 );
Chris@69 328 }
Chris@69 329 }
Chris@69 330
Chris@69 331 for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
Chris@69 332 opus_int16 tmp;
Chris@69 333 if ( gain_lock[i] ) {
Chris@69 334 tmp = best_gain_mult[i];
Chris@69 335 } else {
Chris@69 336 tmp = gainMult_Q8;
Chris@69 337 }
Chris@69 338 pGains_Q16[ i ] = silk_LSHIFT_SAT32( silk_SMULWB( sEncCtrl.GainsUnq_Q16[ i ], tmp ), 8 );
Chris@69 339 }
Chris@69 340
Chris@69 341 /* Quantize gains */
Chris@69 342 psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
Chris@69 343 silk_gains_quant( psEnc->sCmn.indices.GainsIndices, pGains_Q16,
Chris@69 344 &psEnc->sShape.LastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
Chris@69 345
Chris@69 346 /* Unique identifier of gains vector */
Chris@69 347 gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
Chris@69 348
Chris@69 349 /* Overwrite unquantized gains with quantized gains and convert back to Q0 from Q16 */
Chris@69 350 for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
Chris@69 351 sEncCtrl.Gains[ i ] = pGains_Q16[ i ] / 65536.0f;
Chris@69 352 }
Chris@69 353 }
Chris@69 354 }
Chris@69 355
Chris@69 356 /* Update input buffer */
Chris@69 357 silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
Chris@69 358 ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( silk_float ) );
Chris@69 359
Chris@69 360 /* Exit without entropy coding */
Chris@69 361 if( psEnc->sCmn.prefillFlag ) {
Chris@69 362 /* No payload */
Chris@69 363 *pnBytesOut = 0;
Chris@69 364 return ret;
Chris@69 365 }
Chris@69 366
Chris@69 367 /* Parameters needed for next frame */
Chris@69 368 psEnc->sCmn.prevLag = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];
Chris@69 369 psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;
Chris@69 370
Chris@69 371 /****************************************/
Chris@69 372 /* Finalize payload */
Chris@69 373 /****************************************/
Chris@69 374 psEnc->sCmn.first_frame_after_reset = 0;
Chris@69 375 /* Payload size */
Chris@69 376 *pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
Chris@69 377
Chris@69 378 return ret;
Chris@69 379 }
Chris@69 380
Chris@69 381 /* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate */
Chris@69 382 static OPUS_INLINE void silk_LBRR_encode_FLP(
Chris@69 383 silk_encoder_state_FLP *psEnc, /* I/O Encoder state FLP */
Chris@69 384 silk_encoder_control_FLP *psEncCtrl, /* I/O Encoder control FLP */
Chris@69 385 const silk_float xfw[], /* I Input signal */
Chris@69 386 opus_int condCoding /* I The type of conditional coding used so far for this frame */
Chris@69 387 )
Chris@69 388 {
Chris@69 389 opus_int k;
Chris@69 390 opus_int32 Gains_Q16[ MAX_NB_SUBFR ];
Chris@69 391 silk_float TempGains[ MAX_NB_SUBFR ];
Chris@69 392 SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];
Chris@69 393 silk_nsq_state sNSQ_LBRR;
Chris@69 394
Chris@69 395 /*******************************************/
Chris@69 396 /* Control use of inband LBRR */
Chris@69 397 /*******************************************/
Chris@69 398 if( psEnc->sCmn.LBRR_enabled && psEnc->sCmn.speech_activity_Q8 > SILK_FIX_CONST( LBRR_SPEECH_ACTIVITY_THRES, 8 ) ) {
Chris@69 399 psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
Chris@69 400
Chris@69 401 /* Copy noise shaping quantizer state and quantization indices from regular encoding */
Chris@69 402 silk_memcpy( &sNSQ_LBRR, &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
Chris@69 403 silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
Chris@69 404
Chris@69 405 /* Save original gains */
Chris@69 406 silk_memcpy( TempGains, psEncCtrl->Gains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
Chris@69 407
Chris@69 408 if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {
Chris@69 409 /* First frame in packet or previous frame not LBRR coded */
Chris@69 410 psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex;
Chris@69 411
Chris@69 412 /* Increase Gains to get target LBRR rate */
Chris@69 413 psIndices_LBRR->GainsIndices[ 0 ] += psEnc->sCmn.LBRR_GainIncreases;
Chris@69 414 psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
Chris@69 415 }
Chris@69 416
Chris@69 417 /* Decode to get gains in sync with decoder */
Chris@69 418 silk_gains_dequant( Gains_Q16, psIndices_LBRR->GainsIndices,
Chris@69 419 &psEnc->sCmn.LBRRprevLastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
Chris@69 420
Chris@69 421 /* Overwrite unquantized gains with quantized gains and convert back to Q0 from Q16 */
Chris@69 422 for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
Chris@69 423 psEncCtrl->Gains[ k ] = Gains_Q16[ k ] * ( 1.0f / 65536.0f );
Chris@69 424 }
Chris@69 425
Chris@69 426 /*****************************************/
Chris@69 427 /* Noise shaping quantization */
Chris@69 428 /*****************************************/
Chris@69 429 silk_NSQ_wrapper_FLP( psEnc, psEncCtrl, psIndices_LBRR, &sNSQ_LBRR,
Chris@69 430 psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], xfw );
Chris@69 431
Chris@69 432 /* Restore original gains */
Chris@69 433 silk_memcpy( psEncCtrl->Gains, TempGains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
Chris@69 434 }
Chris@69 435 }