/src/opus/silk/float/encode_frame_FLP.c

Source
/***********************************************************************
Copyright (c) 2006-2011, Skype Limited. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of Internet Society, IETF or IETF Trust, nor the
names of specific contributors, may be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
***********************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdlib.h>
#include "main_FLP.h"
#include "tuning_parameters.h"
#include "stack_alloc.h"

/* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate */
static OPUS_INLINE void silk_LBRR_encode_FLP(
    silk_encoder_state_FLP          *psEnc,                             /* I/O  Encoder state FLP                           */
    silk_encoder_control_FLP        *psEncCtrl,                         /* I/O  Encoder control FLP                         */
    const silk_float                xfw[],                              /* I    Input signal                                */
    opus_int                        condCoding                          /* I    The type of conditional coding used so far for this frame */
);

void silk_encode_do_VAD_FLP(
    silk_encoder_state_FLP          *psEnc,                             /* I/O  Encoder state FLP                           */
    opus_int                        activity                            /* I    Decision of Opus voice activity detector    */
)
{
    const opus_int activity_threshold = SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 );

    /****************************/
    /* Voice Activity Detection */
    /****************************/
    silk_VAD_GetSA_Q8( &psEnc->sCmn, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.arch );
    /* If Opus VAD is inactive and Silk VAD is active: lower Silk VAD to just under the threshold */
    if( activity == VAD_NO_ACTIVITY && psEnc->sCmn.speech_activity_Q8 >= activity_threshold ) {
        psEnc->sCmn.speech_activity_Q8 = activity_threshold - 1;
    }

    /**************************************************/
    /* Convert speech activity into VAD and DTX flags */
    /**************************************************/
    if( psEnc->sCmn.speech_activity_Q8 < activity_threshold ) {
        psEnc->sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY;
        psEnc->sCmn.noSpeechCounter++;
        if( psEnc->sCmn.noSpeechCounter <= NB_SPEECH_FRAMES_BEFORE_DTX ) {
            psEnc->sCmn.inDTX = 0;
        } else if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX ) {
            psEnc->sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX;
            psEnc->sCmn.inDTX           = 0;
        }
        psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 0;
    } else {
        psEnc->sCmn.noSpeechCounter    = 0;
        psEnc->sCmn.inDTX              = 0;
        psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
        psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
    }
}

/****************/
/* Encode frame */
/****************/
opus_int silk_encode_frame_FLP(
    silk_encoder_state_FLP          *psEnc,                             /* I/O  Encoder state FLP                           */
    opus_int32                      *pnBytesOut,                        /* O    Number of payload bytes;                    */
    ec_enc                          *psRangeEnc,                        /* I/O  compressor data structure                   */
    opus_int                        condCoding,                         /* I    The type of conditional coding to use       */
    opus_int                        maxBits,                            /* I    If > 0: maximum number of output bits       */
    opus_int                        useCBR                              /* I    Flag to force constant-bitrate operation    */
)
{
    silk_encoder_control_FLP sEncCtrl;
    opus_int     i, iter, maxIter, found_upper, found_lower, ret = 0;
    silk_float   *x_frame, *res_pitch_frame;
    silk_float   res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
    ec_enc       sRangeEnc_copy, sRangeEnc_copy2;
    VARDECL(silk_nsq_state, sNSQ_copy);
    opus_int32   seed_copy, nBits, nBits_lower, nBits_upper, gainMult_lower, gainMult_upper;
    opus_int32   gainsID, gainsID_lower, gainsID_upper;
    opus_int16   gainMult_Q8;
    opus_int16   ec_prevLagIndex_copy;
    opus_int     ec_prevSignalType_copy;
    opus_int8    LastGainIndex_copy2;
    opus_int32   pGains_Q16[ MAX_NB_SUBFR ];
    opus_int     gain_lock[ MAX_NB_SUBFR ] = {0};
    opus_int16   best_gain_mult[ MAX_NB_SUBFR ];
    opus_int     best_sum[ MAX_NB_SUBFR ];
    opus_int     bits_margin;
    SAVE_STACK;

    /* Using ALLOC() instead of a regular stack allocation to minimize real stack use when using the pseudostack.
       This is useful on some embedded systems. */
    ALLOC(sNSQ_copy, 2, silk_nsq_state);

    /* For CBR, 5 bits below budget is close enough. For VBR, allow up to 25% below the cap if we initially busted the budget. */
    bits_margin = useCBR ? 5 : maxBits/4;
    /* This is totally unnecessary but many compilers (including gcc) are too dumb to realise it */
    LastGainIndex_copy2 = nBits_lower = nBits_upper = gainMult_lower = gainMult_upper = 0;

    psEnc->sCmn.indices.Seed = psEnc->sCmn.frameCounter++ & 3;

    /**************************************************************/
    /* Set up Input Pointers, and insert frame in input buffer    */
    /**************************************************************/
    /* pointers aligned with start of frame to encode */
    x_frame         = psEnc->x_buf + psEnc->sCmn.ltp_mem_length;    /* start of frame to encode */
    res_pitch_frame = res_pitch    + psEnc->sCmn.ltp_mem_length;    /* start of pitch LPC residual frame */

    /***************************************/
    /* Ensure smooth bandwidth transitions */
    /***************************************/
    silk_LP_variable_cutoff( &psEnc->sCmn.sLP, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );

    /*******************************************/
    /* Copy new frame to front of input buffer */
    /*******************************************/
    silk_short2float_array( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );

    /* Add tiny signal to avoid high CPU load from denormalized floating point numbers */
    for( i = 0; i < 8; i++ ) {
        x_frame[ LA_SHAPE_MS * psEnc->sCmn.fs_kHz + i * ( psEnc->sCmn.frame_length >> 3 ) ] += ( 1 - ( i & 2 ) ) * 1e-6f;
    }

    if( !psEnc->sCmn.prefillFlag ) {
        VARDECL( opus_uint8, ec_buf_copy );
        /*****************************************/
        /* Find pitch lags, initial LPC analysis */
        /*****************************************/
        silk_find_pitch_lags_FLP( psEnc, &sEncCtrl, res_pitch, x_frame, psEnc->sCmn.arch );

        /************************/
        /* Noise shape analysis */
        /************************/
        silk_noise_shape_analysis_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame );

        /***************************************************/
        /* Find linear prediction coefficients (LPC + LTP) */
        /***************************************************/
        silk_find_pred_coefs_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame, condCoding );

        /****************************************/
        /* Process gains                        */
        /****************************************/
        silk_process_gains_FLP( psEnc, &sEncCtrl, condCoding );

        /****************************************/
        /* Low Bitrate Redundant Encoding       */
        /****************************************/
        silk_LBRR_encode_FLP( psEnc, &sEncCtrl, x_frame, condCoding );

        /* Loop over quantizer and entroy coding to control bitrate */
        maxIter = 6;
        gainMult_Q8 = SILK_FIX_CONST( 1, 8 );
        found_lower = 0;
        found_upper = 0;
        gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
        gainsID_lower = -1;
        gainsID_upper = -1;
        /* Copy part of the input state */
        silk_memcpy( &sRangeEnc_copy, psRangeEnc, sizeof( ec_enc ) );
        silk_memcpy( &sNSQ_copy[0], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
        seed_copy = psEnc->sCmn.indices.Seed;
        ec_prevLagIndex_copy = psEnc->sCmn.ec_prevLagIndex;
        ec_prevSignalType_copy = psEnc->sCmn.ec_prevSignalType;
        ALLOC( ec_buf_copy, 1275, opus_uint8 );
        for( iter = 0; ; iter++ ) {
            if( gainsID == gainsID_lower ) {
                nBits = nBits_lower;
            } else if( gainsID == gainsID_upper ) {
                nBits = nBits_upper;
            } else {
                /* Restore part of the input state */
                if( iter > 0 ) {
                    silk_memcpy( psRangeEnc, &sRangeEnc_copy, sizeof( ec_enc ) );
                    silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy[0], sizeof( silk_nsq_state ) );
                    psEnc->sCmn.indices.Seed = seed_copy;
                    psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
                    psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
                }

                /*****************************************/
                /* Noise shaping quantization            */
                /*****************************************/
                silk_NSQ_wrapper_FLP( psEnc, &sEncCtrl, &psEnc->sCmn.indices, &psEnc->sCmn.sNSQ, psEnc->sCmn.pulses, x_frame );

                if ( iter == maxIter && !found_lower ) {
                    silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
                }

                /****************************************/
                /* Encode Parameters                    */
                /****************************************/
                silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );

                /****************************************/
                /* Encode Excitation Signal             */
                /****************************************/
                silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
                      psEnc->sCmn.pulses, psEnc->sCmn.frame_length );

                nBits = ec_tell( psRangeEnc );

                /* If we still bust after the last iteration, do some damage control. */
                if ( iter == maxIter && !found_lower && nBits > maxBits ) {
                    silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );

                    /* Keep gains the same as the last frame. */
                    psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
                    for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
                        psEnc->sCmn.indices.GainsIndices[ i ] = 4;
                    }
                    if (condCoding != CODE_CONDITIONALLY) {
                       psEnc->sCmn.indices.GainsIndices[ 0 ] = sEncCtrl.lastGainIndexPrev;
                    }
                    psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
                    psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
                    /* Clear all pulses. */
                    for ( i = 0; i < psEnc->sCmn.frame_length; i++ ) {
                        psEnc->sCmn.pulses[ i ] = 0;
                    }

                    silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );

                    silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
                        psEnc->sCmn.pulses, psEnc->sCmn.frame_length );

                    nBits = ec_tell( psRangeEnc );
                }

                if( useCBR == 0 && iter == 0 && nBits <= maxBits ) {
                    break;
                }
            }

            if( iter == maxIter ) {
                if( found_lower && ( gainsID == gainsID_lower || nBits > maxBits ) ) {
                    /* Restore output state from earlier iteration that did meet the bitrate budget */
                    silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
                    celt_assert( sRangeEnc_copy2.offs <= 1275 );
                    silk_memcpy( psRangeEnc->buf, ec_buf_copy, sRangeEnc_copy2.offs );
                    silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy[1], sizeof( silk_nsq_state ) );
                    psEnc->sShape.LastGainIndex = LastGainIndex_copy2;
                }
                break;
            }

            if( nBits > maxBits ) {
                if( found_lower == 0 && iter >= 2 ) {
                    /* Adjust the quantizer's rate/distortion tradeoff and discard previous "upper" results */
                    sEncCtrl.Lambda = silk_max_float(sEncCtrl.Lambda*1.5f, 1.5f);
                    /* Reducing dithering can help us hit the target. */
                    psEnc->sCmn.indices.quantOffsetType = 0;
                    found_upper = 0;
                    gainsID_upper = -1;
                } else {
                    found_upper = 1;
                    nBits_upper = nBits;
                    gainMult_upper = gainMult_Q8;
                    gainsID_upper = gainsID;
                }
            } else if( nBits < maxBits - bits_margin ) {
                found_lower = 1;
                nBits_lower = nBits;
                gainMult_lower = gainMult_Q8;
                if( gainsID != gainsID_lower ) {
                    gainsID_lower = gainsID;
                    /* Copy part of the output state */
                    silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
                    celt_assert( psRangeEnc->offs <= 1275 );
                    silk_memcpy( ec_buf_copy, psRangeEnc->buf, psRangeEnc->offs );
                    silk_memcpy( &sNSQ_copy[1], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
                    LastGainIndex_copy2 = psEnc->sShape.LastGainIndex;
                }
            } else {
                /* Close enough */
                break;
            }

            if ( !found_lower && nBits > maxBits ) {
                int j;
                for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
                    int sum=0;
                    for ( j = i*psEnc->sCmn.subfr_length; j < (i+1)*psEnc->sCmn.subfr_length; j++ ) {
                        sum += abs( psEnc->sCmn.pulses[j] );
                    }
                    if ( iter == 0 || (sum < best_sum[i] && !gain_lock[i]) ) {
                        best_sum[i] = sum;
                        best_gain_mult[i] = gainMult_Q8;
                    } else {
                        gain_lock[i] = 1;
                    }
                }
            }
            if( ( found_lower & found_upper ) == 0 ) {
                /* Adjust gain according to high-rate rate/distortion curve */
                if( nBits > maxBits ) {
                    gainMult_Q8 = silk_min_32( 1024, gainMult_Q8*3/2 );
                } else {
                    gainMult_Q8 = silk_max_32( 64, gainMult_Q8*4/5 );
                }
            } else {
                /* Adjust gain by interpolating */
                gainMult_Q8 = gainMult_lower + ( ( gainMult_upper - gainMult_lower ) * ( maxBits - nBits_lower ) ) / ( nBits_upper - nBits_lower );
                /* New gain multiplier must be between 25% and 75% of old range (note that gainMult_upper < gainMult_lower) */
                if( gainMult_Q8 > silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 ) ) {
                    gainMult_Q8 = silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 );
                } else
                if( gainMult_Q8 < silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 ) ) {
                    gainMult_Q8 = silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 );
                }
            }

            for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
                opus_int16 tmp;
                if ( gain_lock[i] ) {
                    tmp = best_gain_mult[i];
                } else {
                    tmp = gainMult_Q8;
                }
                pGains_Q16[ i ] = silk_LSHIFT_SAT32( silk_SMULWB( sEncCtrl.GainsUnq_Q16[ i ], tmp ), 8 );
            }

            /* Quantize gains */
            psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
            silk_gains_quant( psEnc->sCmn.indices.GainsIndices, pGains_Q16,
                  &psEnc->sShape.LastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );

            /* Unique identifier of gains vector */
            gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );

            /* Overwrite unquantized gains with quantized gains and convert back to Q0 from Q16 */
            for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
                sEncCtrl.Gains[ i ] = pGains_Q16[ i ] / 65536.0f;
            }
        }
    }

    /* Update input buffer */
    silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
        ( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( silk_float ) );

    /* Exit without entropy coding */
    if( psEnc->sCmn.prefillFlag ) {
        /* No payload */
        *pnBytesOut = 0;
        RESTORE_STACK;
        return ret;
    }

    /* Parameters needed for next frame */
    psEnc->sCmn.prevLag        = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];
    psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;

    /****************************************/
    /* Finalize payload                     */
    /****************************************/
    psEnc->sCmn.first_frame_after_reset = 0;
    /* Payload size */
    *pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );

    RESTORE_STACK;
    return ret;
}

/* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate  */
static OPUS_INLINE void silk_LBRR_encode_FLP(
    silk_encoder_state_FLP          *psEnc,                             /* I/O  Encoder state FLP                           */
    silk_encoder_control_FLP        *psEncCtrl,                         /* I/O  Encoder control FLP                         */
    const silk_float                xfw[],                              /* I    Input signal                                */
    opus_int                        condCoding                          /* I    The type of conditional coding used so far for this frame */
)
{
    opus_int     k;
    opus_int32   Gains_Q16[ MAX_NB_SUBFR ];
    silk_float   TempGains[ MAX_NB_SUBFR ];
    SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];
    VARDECL(silk_nsq_state, sNSQ_LBRR);
    SAVE_STACK;

    /*******************************************/
    /* Control use of inband LBRR              */
    /*******************************************/
    if( psEnc->sCmn.LBRR_enabled && psEnc->sCmn.speech_activity_Q8 > SILK_FIX_CONST( LBRR_SPEECH_ACTIVITY_THRES, 8 ) ) {
        /* Using ALLOC() instead of a regular stack allocation to minimize real stack use when using the pseudostack.
           This is useful on some embedded systems. */
        ALLOC(sNSQ_LBRR, 1, silk_nsq_state);

        psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;

        /* Copy noise shaping quantizer state and quantization indices from regular encoding */
        silk_memcpy( &sNSQ_LBRR[0], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
        silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );

        /* Save original gains */
        silk_memcpy( TempGains, psEncCtrl->Gains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );

        if( psEnc->sCmn.nFramesEncoded == 0 || psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {
            /* First frame in packet or previous frame not LBRR coded */
            psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex;

            /* Increase Gains to get target LBRR rate */
            psIndices_LBRR->GainsIndices[ 0 ] += psEnc->sCmn.LBRR_GainIncreases;
            psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
        }

        /* Decode to get gains in sync with decoder */
        silk_gains_dequant( Gains_Q16, psIndices_LBRR->GainsIndices,
            &psEnc->sCmn.LBRRprevLastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );

        /* Overwrite unquantized gains with quantized gains and convert back to Q0 from Q16 */
        for( k = 0; k <  psEnc->sCmn.nb_subfr; k++ ) {
            psEncCtrl->Gains[ k ] = Gains_Q16[ k ] * ( 1.0f / 65536.0f );
        }

        /*****************************************/
        /* Noise shaping quantization            */
        /*****************************************/
        silk_NSQ_wrapper_FLP( psEnc, psEncCtrl, psIndices_LBRR, &sNSQ_LBRR[0],
            psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], xfw );

        /* Restore original gains */
        silk_memcpy( psEncCtrl->Gains, TempGains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
    }
    RESTORE_STACK;
}

Coverage Report

Created: 2026-03-19 07:24

Line	Count	Source
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
32		#include <stdlib.h>
33		#include "main_FLP.h"
34		#include "tuning_parameters.h"
35		#include "stack_alloc.h"
36
37		/* Low Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode with lower bitrate */
38		static OPUS_INLINE void silk_LBRR_encode_FLP(
39		silk_encoder_state_FLP psEnc, / I/O Encoder state FLP */
40		silk_encoder_control_FLP psEncCtrl, / I/O Encoder control FLP */
41		const silk_float xfw[], /* I Input signal */
42		opus_int condCoding /* I The type of conditional coding used so far for this frame */
43		);
44
45		void silk_encode_do_VAD_FLP(
46		silk_encoder_state_FLP psEnc, / I/O Encoder state FLP */
47		opus_int activity /* I Decision of Opus voice activity detector */
48		)
49	231k	{
50	231k	const opus_int activity_threshold = SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 );
51
52		/****************************/
53		/* Voice Activity Detection */
54		/****************************/
55	231k	silk_VAD_GetSA_Q8( &psEnc->sCmn, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.arch );
56		/* If Opus VAD is inactive and Silk VAD is active: lower Silk VAD to just under the threshold */
57	231k	if( activity == VAD_NO_ACTIVITY && psEnc->sCmn.speech_activity_Q8 >= activity_threshold ) {
58	934	psEnc->sCmn.speech_activity_Q8 = activity_threshold - 1;
59	934	}
60
61		/**************************************************/
62		/* Convert speech activity into VAD and DTX flags */
63		/**************************************************/
64	231k	if( psEnc->sCmn.speech_activity_Q8 < activity_threshold ) {
65	45.5k	psEnc->sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY;
66	45.5k	psEnc->sCmn.noSpeechCounter++;
67	45.5k	if( psEnc->sCmn.noSpeechCounter <= NB_SPEECH_FRAMES_BEFORE_DTX ) {
68	45.5k	psEnc->sCmn.inDTX = 0;
69	45.5k	} else if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX ) {
70	0	psEnc->sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX;
71	0	psEnc->sCmn.inDTX = 0;
72	0	}
73	45.5k	psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 0;
74	186k	} else {
75	186k	psEnc->sCmn.noSpeechCounter = 0;
76	186k	psEnc->sCmn.inDTX = 0;
77	186k	psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
78	186k	psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
79	186k	}
80	231k	}
81
82		/****************/
83		/* Encode frame */
84		/****************/
85		opus_int silk_encode_frame_FLP(
86		silk_encoder_state_FLP psEnc, / I/O Encoder state FLP */
87		opus_int32 pnBytesOut, / O Number of payload bytes; */
88		ec_enc psRangeEnc, / I/O compressor data structure */
89		opus_int condCoding, /* I The type of conditional coding to use */
90		opus_int maxBits, /* I If > 0: maximum number of output bits */
91		opus_int useCBR /* I Flag to force constant-bitrate operation */
92		)
93	231k	{
94	231k	silk_encoder_control_FLP sEncCtrl;
95	231k	opus_int i, iter, maxIter, found_upper, found_lower, ret = 0;
96	231k	silk_float x_frame, res_pitch_frame;
97	231k	silk_float res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
98	231k	ec_enc sRangeEnc_copy, sRangeEnc_copy2;
99	231k	VARDECL(silk_nsq_state, sNSQ_copy);
100	231k	opus_int32 seed_copy, nBits, nBits_lower, nBits_upper, gainMult_lower, gainMult_upper;
101	231k	opus_int32 gainsID, gainsID_lower, gainsID_upper;
102	231k	opus_int16 gainMult_Q8;
103	231k	opus_int16 ec_prevLagIndex_copy;
104	231k	opus_int ec_prevSignalType_copy;
105	231k	opus_int8 LastGainIndex_copy2;
106	231k	opus_int32 pGains_Q16[ MAX_NB_SUBFR ];
107	231k	opus_int gain_lock[ MAX_NB_SUBFR ] = {0};
108	231k	opus_int16 best_gain_mult[ MAX_NB_SUBFR ];
109	231k	opus_int best_sum[ MAX_NB_SUBFR ];
110	231k	opus_int bits_margin;
111	231k	SAVE_STACK;
112
113		/* Using ALLOC() instead of a regular stack allocation to minimize real stack use when using the pseudostack.
114		This is useful on some embedded systems. */
115	231k	ALLOC(sNSQ_copy, 2, silk_nsq_state);
116
117		/* For CBR, 5 bits below budget is close enough. For VBR, allow up to 25% below the cap if we initially busted the budget. */
118	231k	bits_margin = useCBR ? 5 : maxBits/4;
119		/* This is totally unnecessary but many compilers (including gcc) are too dumb to realise it */
120	231k	LastGainIndex_copy2 = nBits_lower = nBits_upper = gainMult_lower = gainMult_upper = 0;
121
122	231k	psEnc->sCmn.indices.Seed = psEnc->sCmn.frameCounter++ & 3;
123
124		/**************************************************************/
125		/* Set up Input Pointers, and insert frame in input buffer */
126		/**************************************************************/
127		/* pointers aligned with start of frame to encode */
128	231k	x_frame = psEnc->x_buf + psEnc->sCmn.ltp_mem_length; /* start of frame to encode */
129	231k	res_pitch_frame = res_pitch + psEnc->sCmn.ltp_mem_length; /* start of pitch LPC residual frame */
130
131		/***************************************/
132		/* Ensure smooth bandwidth transitions */
133		/***************************************/
134	231k	silk_LP_variable_cutoff( &psEnc->sCmn.sLP, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
135
136		/*******************************************/
137		/* Copy new frame to front of input buffer */
138		/*******************************************/
139	231k	silk_short2float_array( x_frame + LA_SHAPE_MS * psEnc->sCmn.fs_kHz, psEnc->sCmn.inputBuf + 1, psEnc->sCmn.frame_length );
140
141		/* Add tiny signal to avoid high CPU load from denormalized floating point numbers */
142	2.08M	for( i = 0; i < 8; i++ ) {
143	1.85M	x_frame[ LA_SHAPE_MS * psEnc->sCmn.fs_kHz + i * ( psEnc->sCmn.frame_length >> 3 ) ] += ( 1 - ( i & 2 ) ) * 1e-6f;
144	1.85M	}
145
146	231k	if( !psEnc->sCmn.prefillFlag ) {
147	231k	VARDECL( opus_uint8, ec_buf_copy );
148		/*****************************************/
149		/* Find pitch lags, initial LPC analysis */
150		/*****************************************/
151	231k	silk_find_pitch_lags_FLP( psEnc, &sEncCtrl, res_pitch, x_frame, psEnc->sCmn.arch );
152
153		/************************/
154		/* Noise shape analysis */
155		/************************/
156	231k	silk_noise_shape_analysis_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame );
157
158		/***************************************************/
159		/* Find linear prediction coefficients (LPC + LTP) */
160		/***************************************************/
161	231k	silk_find_pred_coefs_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame, condCoding );
162
163		/****************************************/
164		/* Process gains */
165		/****************************************/
166	231k	silk_process_gains_FLP( psEnc, &sEncCtrl, condCoding );
167
168		/****************************************/
169		/* Low Bitrate Redundant Encoding */
170		/****************************************/
171	231k	silk_LBRR_encode_FLP( psEnc, &sEncCtrl, x_frame, condCoding );
172
173		/* Loop over quantizer and entroy coding to control bitrate */
174	231k	maxIter = 6;
175	231k	gainMult_Q8 = SILK_FIX_CONST( 1, 8 );
176	231k	found_lower = 0;
177	231k	found_upper = 0;
178	231k	gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
179	231k	gainsID_lower = -1;
180	231k	gainsID_upper = -1;
181		/* Copy part of the input state */
182	231k	silk_memcpy( &sRangeEnc_copy, psRangeEnc, sizeof( ec_enc ) );
183	231k	silk_memcpy( &sNSQ_copy[0], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
184	231k	seed_copy = psEnc->sCmn.indices.Seed;
185	231k	ec_prevLagIndex_copy = psEnc->sCmn.ec_prevLagIndex;
186	231k	ec_prevSignalType_copy = psEnc->sCmn.ec_prevSignalType;
187	231k	ALLOC( ec_buf_copy, 1275, opus_uint8 );
188	703k	for( iter = 0; ; iter++ ) {
189	703k	if( gainsID == gainsID_lower ) {
190	84.7k	nBits = nBits_lower;
191	618k	} else if( gainsID == gainsID_upper ) {
192	13.4k	nBits = nBits_upper;
193	605k	} else {
194		/* Restore part of the input state */
195	605k	if( iter > 0 ) {
196	373k	silk_memcpy( psRangeEnc, &sRangeEnc_copy, sizeof( ec_enc ) );
197	373k	silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy[0], sizeof( silk_nsq_state ) );
198	373k	psEnc->sCmn.indices.Seed = seed_copy;
199	373k	psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
200	373k	psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
201	373k	}
202
203		/*****************************************/
204		/* Noise shaping quantization */
205		/*****************************************/
206	605k	silk_NSQ_wrapper_FLP( psEnc, &sEncCtrl, &psEnc->sCmn.indices, &psEnc->sCmn.sNSQ, psEnc->sCmn.pulses, x_frame );
207
208	605k	if ( iter == maxIter && !found_lower ) {
209	15.2k	silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
210	15.2k	}
211
212		/****************************************/
213		/* Encode Parameters */
214		/****************************************/
215	605k	silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
216
217		/****************************************/
218		/* Encode Excitation Signal */
219		/****************************************/
220	605k	silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
221	605k	psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
222
223	605k	nBits = ec_tell( psRangeEnc );
224
225		/* If we still bust after the last iteration, do some damage control. */
226	605k	if ( iter == maxIter && !found_lower && nBits > maxBits ) {
227	14.3k	silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
228
229		/* Keep gains the same as the last frame. */
230	14.3k	psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
231	70.7k	for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
232	56.4k	psEnc->sCmn.indices.GainsIndices[ i ] = 4;
233	56.4k	}
234	14.3k	if (condCoding != CODE_CONDITIONALLY) {
235	10.1k	psEnc->sCmn.indices.GainsIndices[ 0 ] = sEncCtrl.lastGainIndexPrev;
236	10.1k	}
237	14.3k	psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
238	14.3k	psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
239		/* Clear all pulses. */
240	2.84M	for ( i = 0; i < psEnc->sCmn.frame_length; i++ ) {
241	2.83M	psEnc->sCmn.pulses[ i ] = 0;
242	2.83M	}
243
244	14.3k	silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
245
246	14.3k	silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
247	14.3k	psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
248
249	14.3k	nBits = ec_tell( psRangeEnc );
250	14.3k	}
251
252	605k	if( useCBR == 0 && iter == 0 && nBits <= maxBits ) {
253	147k	break;
254	147k	}
255	605k	}
256
257	555k	if( iter == maxIter ) {
258	73.9k	if( found_lower && ( gainsID == gainsID_lower \|\| nBits > maxBits ) ) {
259		/* Restore output state from earlier iteration that did meet the bitrate budget */
260	24.6k	silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
261	24.6k	celt_assert( sRangeEnc_copy2.offs <= 1275 );
262	24.6k	silk_memcpy( psRangeEnc->buf, ec_buf_copy, sRangeEnc_copy2.offs );
263	24.6k	silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy[1], sizeof( silk_nsq_state ) );
264	24.6k	psEnc->sShape.LastGainIndex = LastGainIndex_copy2;
265	24.6k	}
266	73.9k	break;
267	73.9k	}
268
269	481k	if( nBits > maxBits ) {
270	129k	if( found_lower == 0 && iter >= 2 ) {
271		/* Adjust the quantizer's rate/distortion tradeoff and discard previous "upper" results */
272	67.1k	sEncCtrl.Lambda = silk_max_float(sEncCtrl.Lambda*1.5f, 1.5f);
273		/* Reducing dithering can help us hit the target. */
274	67.1k	psEnc->sCmn.indices.quantOffsetType = 0;
275	67.1k	found_upper = 0;
276	67.1k	gainsID_upper = -1;
277	67.1k	} else {
278	62.1k	found_upper = 1;
279	62.1k	nBits_upper = nBits;
280	62.1k	gainMult_upper = gainMult_Q8;
281	62.1k	gainsID_upper = gainsID;
282	62.1k	}
283	352k	} else if( nBits < maxBits - bits_margin ) {
284	342k	found_lower = 1;
285	342k	nBits_lower = nBits;
286	342k	gainMult_lower = gainMult_Q8;
287	342k	if( gainsID != gainsID_lower ) {
288	275k	gainsID_lower = gainsID;
289		/* Copy part of the output state */
290	275k	silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
291	275k	celt_assert( psRangeEnc->offs <= 1275 );
292	275k	silk_memcpy( ec_buf_copy, psRangeEnc->buf, psRangeEnc->offs );
293	275k	silk_memcpy( &sNSQ_copy[1], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
294	275k	LastGainIndex_copy2 = psEnc->sShape.LastGainIndex;
295	275k	}
296	342k	} else {
297		/* Close enough */
298	10.1k	break;
299	10.1k	}
300
301	471k	if ( !found_lower && nBits > maxBits ) {
302	110k	int j;
303	542k	for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
304	431k	int sum=0;
305	22.1M	for ( j = ipsEnc->sCmn.subfr_length; j < (i+1)psEnc->sCmn.subfr_length; j++ ) {
306	21.6M	sum += abs( psEnc->sCmn.pulses[j] );
307	21.6M	}
308	431k	if ( iter == 0 \|\| (sum < best_sum[i] && !gain_lock[i]) ) {
309	183k	best_sum[i] = sum;
310	183k	best_gain_mult[i] = gainMult_Q8;
311	248k	} else {
312	248k	gain_lock[i] = 1;
313	248k	}
314	431k	}
315	110k	}
316	471k	if( ( found_lower & found_upper ) == 0 ) {
317		/* Adjust gain according to high-rate rate/distortion curve */
318	442k	if( nBits > maxBits ) {
319	110k	gainMult_Q8 = silk_min_32( 1024, gainMult_Q8*3/2 );
320	331k	} else {
321	331k	gainMult_Q8 = silk_max_32( 64, gainMult_Q8*4/5 );
322	331k	}
323	442k	} else {
324		/* Adjust gain by interpolating */
325	29.0k	gainMult_Q8 = gainMult_lower + ( ( gainMult_upper - gainMult_lower ) * ( maxBits - nBits_lower ) ) / ( nBits_upper - nBits_lower );
326		/* New gain multiplier must be between 25% and 75% of old range (note that gainMult_upper < gainMult_lower) */
327	29.0k	if( gainMult_Q8 > silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 ) ) {
328	4.64k	gainMult_Q8 = silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 );
329	4.64k	} else
330	24.3k	if( gainMult_Q8 < silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 ) ) {
331	7.42k	gainMult_Q8 = silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 );
332	7.42k	}
333	29.0k	}
334
335	2.03M	for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
336	1.56M	opus_int16 tmp;
337	1.56M	if ( gain_lock[i] ) {
338	253k	tmp = best_gain_mult[i];
339	1.31M	} else {
340	1.31M	tmp = gainMult_Q8;
341	1.31M	}
342	1.56M	pGains_Q16[ i ] = silk_LSHIFT_SAT32( silk_SMULWB( sEncCtrl.GainsUnq_Q16[ i ], tmp ), 8 );
343	1.56M	}
344
345		/* Quantize gains */
346	471k	psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
347	471k	silk_gains_quant( psEnc->sCmn.indices.GainsIndices, pGains_Q16,
348	471k	&psEnc->sShape.LastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
349
350		/* Unique identifier of gains vector */
351	471k	gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
352
353		/* Overwrite unquantized gains with quantized gains and convert back to Q0 from Q16 */
354	2.03M	for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
355	1.56M	sEncCtrl.Gains[ i ] = pGains_Q16[ i ] / 65536.0f;
356	1.56M	}
357	471k	}
358	231k	}
359
360		/* Update input buffer */
361	231k	silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
362	231k	( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( silk_float ) );
363
364		/* Exit without entropy coding */
365	231k	if( psEnc->sCmn.prefillFlag ) {
366		/* No payload */
367	0	*pnBytesOut = 0;
368	0	RESTORE_STACK;
369	0	return ret;
370	0	}
371
372		/* Parameters needed for next frame */
373	231k	psEnc->sCmn.prevLag = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];
374	231k	psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;
375
376		/****************************************/
377		/* Finalize payload */
378		/****************************************/
379	231k	psEnc->sCmn.first_frame_after_reset = 0;
380		/* Payload size */
381	231k	*pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
382
383	231k	RESTORE_STACK;
384	231k	return ret;
385	231k	}
386
387		/* Low-Bitrate Redundancy (LBRR) encoding. Reuse all parameters but encode excitation at lower bitrate */
388		static OPUS_INLINE void silk_LBRR_encode_FLP(
389		silk_encoder_state_FLP psEnc, / I/O Encoder state FLP */
390		silk_encoder_control_FLP psEncCtrl, / I/O Encoder control FLP */
391		const silk_float xfw[], /* I Input signal */
392		opus_int condCoding /* I The type of conditional coding used so far for this frame */
393		)
394	231k	{
395	231k	opus_int k;
396	231k	opus_int32 Gains_Q16[ MAX_NB_SUBFR ];
397	231k	silk_float TempGains[ MAX_NB_SUBFR ];
398	231k	SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];
399	231k	VARDECL(silk_nsq_state, sNSQ_LBRR);
400	231k	SAVE_STACK;
401
402		/*******************************************/
403		/* Control use of inband LBRR */
404		/*******************************************/
405	231k	if( psEnc->sCmn.LBRR_enabled && psEnc->sCmn.speech_activity_Q8 > SILK_FIX_CONST( LBRR_SPEECH_ACTIVITY_THRES, 8 ) ) {
406		/* Using ALLOC() instead of a regular stack allocation to minimize real stack use when using the pseudostack.
407		This is useful on some embedded systems. */
408	108k	ALLOC(sNSQ_LBRR, 1, silk_nsq_state);
409
410	108k	psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
411
412		/* Copy noise shaping quantizer state and quantization indices from regular encoding */
413	108k	silk_memcpy( &sNSQ_LBRR[0], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
414	108k	silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
415
416		/* Save original gains */
417	108k	silk_memcpy( TempGains, psEncCtrl->Gains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
418
419	108k	if( psEnc->sCmn.nFramesEncoded == 0 \|\| psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded - 1 ] == 0 ) {
420		/* First frame in packet or previous frame not LBRR coded */
421	82.4k	psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex;
422
423		/* Increase Gains to get target LBRR rate */
424	82.4k	psIndices_LBRR->GainsIndices[ 0 ] += psEnc->sCmn.LBRR_GainIncreases;
425	82.4k	psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
426	82.4k	}
427
428		/* Decode to get gains in sync with decoder */
429	108k	silk_gains_dequant( Gains_Q16, psIndices_LBRR->GainsIndices,
430	108k	&psEnc->sCmn.LBRRprevLastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
431
432		/* Overwrite unquantized gains with quantized gains and convert back to Q0 from Q16 */
433	489k	for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
434	380k	psEncCtrl->Gains[ k ] = Gains_Q16[ k ] * ( 1.0f / 65536.0f );
435	380k	}
436
437		/*****************************************/
438		/* Noise shaping quantization */
439		/*****************************************/
440	108k	silk_NSQ_wrapper_FLP( psEnc, psEncCtrl, psIndices_LBRR, &sNSQ_LBRR[0],
441	108k	psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], xfw );
442
443		/* Restore original gains */
444	108k	silk_memcpy( psEncCtrl->Gains, TempGains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
445	108k	}
446	231k	RESTORE_STACK;
447	231k	}