/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-08-13 07:15

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	67.3M	{
50	67.3M	const opus_int activity_threshold = SILK_FIX_CONST( SPEECH_ACTIVITY_DTX_THRES, 8 );
51
52		/****************************/
53		/* Voice Activity Detection */
54		/****************************/
55	67.3M	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	67.3M	if( activity == VAD_NO_ACTIVITY && psEnc->sCmn.speech_activity_Q8 >= activity_threshold ) {
58	13.4k	psEnc->sCmn.speech_activity_Q8 = activity_threshold - 1;
59	13.4k	}
60
61		/**************************************************/
62		/* Convert speech activity into VAD and DTX flags */
63		/**************************************************/
64	67.3M	if( psEnc->sCmn.speech_activity_Q8 < activity_threshold ) {
65	65.6M	psEnc->sCmn.indices.signalType = TYPE_NO_VOICE_ACTIVITY;
66	65.6M	psEnc->sCmn.noSpeechCounter++;
67	65.6M	if( psEnc->sCmn.noSpeechCounter <= NB_SPEECH_FRAMES_BEFORE_DTX ) {
68	406k	psEnc->sCmn.inDTX = 0;
69	65.2M	} else if( psEnc->sCmn.noSpeechCounter > MAX_CONSECUTIVE_DTX + NB_SPEECH_FRAMES_BEFORE_DTX ) {
70	3.10M	psEnc->sCmn.noSpeechCounter = NB_SPEECH_FRAMES_BEFORE_DTX;
71	3.10M	psEnc->sCmn.inDTX = 0;
72	3.10M	}
73	65.6M	psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 0;
74	65.6M	} else {
75	1.74M	psEnc->sCmn.noSpeechCounter = 0;
76	1.74M	psEnc->sCmn.inDTX = 0;
77	1.74M	psEnc->sCmn.indices.signalType = TYPE_UNVOICED;
78	1.74M	psEnc->sCmn.VAD_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
79	1.74M	}
80	67.3M	}
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	67.3M	{
94	67.3M	silk_encoder_control_FLP sEncCtrl;
95	67.3M	opus_int i, iter, maxIter, found_upper, found_lower, ret = 0;
96	67.3M	silk_float x_frame, res_pitch_frame;
97	67.3M	silk_float res_pitch[ 2 * MAX_FRAME_LENGTH + LA_PITCH_MAX ];
98	67.3M	ec_enc sRangeEnc_copy, sRangeEnc_copy2;
99	67.3M	VARDECL(silk_nsq_state, sNSQ_copy);
100	67.3M	opus_int32 seed_copy, nBits, nBits_lower, nBits_upper, gainMult_lower, gainMult_upper;
101	67.3M	opus_int32 gainsID, gainsID_lower, gainsID_upper;
102	67.3M	opus_int16 gainMult_Q8;
103	67.3M	opus_int16 ec_prevLagIndex_copy;
104	67.3M	opus_int ec_prevSignalType_copy;
105	67.3M	opus_int8 LastGainIndex_copy2;
106	67.3M	opus_int32 pGains_Q16[ MAX_NB_SUBFR ];
107	67.3M	opus_int gain_lock[ MAX_NB_SUBFR ] = {0};
108	67.3M	opus_int16 best_gain_mult[ MAX_NB_SUBFR ];
109	67.3M	opus_int best_sum[ MAX_NB_SUBFR ];
110	67.3M	opus_int bits_margin;
111	67.3M	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	67.3M	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	67.3M	bits_margin = useCBR ? 5 : maxBits/4;
119		/* This is totally unnecessary but many compilers (including gcc) are too dumb to realise it */
120	67.3M	LastGainIndex_copy2 = nBits_lower = nBits_upper = gainMult_lower = gainMult_upper = 0;
121
122	67.3M	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	67.3M	x_frame = psEnc->x_buf + psEnc->sCmn.ltp_mem_length; /* start of frame to encode */
129	67.3M	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	67.3M	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	67.3M	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	606M	for( i = 0; i < 8; i++ ) {
143	539M	x_frame[ LA_SHAPE_MS * psEnc->sCmn.fs_kHz + i * ( psEnc->sCmn.frame_length >> 3 ) ] += ( 1 - ( i & 2 ) ) * 1e-6f;
144	539M	}
145
146	67.3M	if( !psEnc->sCmn.prefillFlag ) {
147	67.3M	VARDECL( opus_uint8, ec_buf_copy );
148		/*****************************************/
149		/* Find pitch lags, initial LPC analysis */
150		/*****************************************/
151	67.3M	silk_find_pitch_lags_FLP( psEnc, &sEncCtrl, res_pitch, x_frame, psEnc->sCmn.arch );
152
153		/************************/
154		/* Noise shape analysis */
155		/************************/
156	67.3M	silk_noise_shape_analysis_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame );
157
158		/***************************************************/
159		/* Find linear prediction coefficients (LPC + LTP) */
160		/***************************************************/
161	67.3M	silk_find_pred_coefs_FLP( psEnc, &sEncCtrl, res_pitch_frame, x_frame, condCoding );
162
163		/****************************************/
164		/* Process gains */
165		/****************************************/
166	67.3M	silk_process_gains_FLP( psEnc, &sEncCtrl, condCoding );
167
168		/****************************************/
169		/* Low Bitrate Redundant Encoding */
170		/****************************************/
171	67.3M	silk_LBRR_encode_FLP( psEnc, &sEncCtrl, x_frame, condCoding );
172
173		/* Loop over quantizer and entroy coding to control bitrate */
174	67.3M	maxIter = 6;
175	67.3M	gainMult_Q8 = SILK_FIX_CONST( 1, 8 );
176	67.3M	found_lower = 0;
177	67.3M	found_upper = 0;
178	67.3M	gainsID = silk_gains_ID( psEnc->sCmn.indices.GainsIndices, psEnc->sCmn.nb_subfr );
179	67.3M	gainsID_lower = -1;
180	67.3M	gainsID_upper = -1;
181		/* Copy part of the input state */
182	67.3M	silk_memcpy( &sRangeEnc_copy, psRangeEnc, sizeof( ec_enc ) );
183	67.3M	silk_memcpy( &sNSQ_copy[0], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
184	67.3M	seed_copy = psEnc->sCmn.indices.Seed;
185	67.3M	ec_prevLagIndex_copy = psEnc->sCmn.ec_prevLagIndex;
186	67.3M	ec_prevSignalType_copy = psEnc->sCmn.ec_prevSignalType;
187	67.3M	ALLOC( ec_buf_copy, 1275, opus_uint8 );
188	237M	for( iter = 0; ; iter++ ) {
189	237M	if( gainsID == gainsID_lower ) {
190	166M	nBits = nBits_lower;
191	166M	} else if( gainsID == gainsID_upper ) {
192	492k	nBits = nBits_upper;
193	70.4M	} else {
194		/* Restore part of the input state */
195	70.4M	if( iter > 0 ) {
196	3.07M	silk_memcpy( psRangeEnc, &sRangeEnc_copy, sizeof( ec_enc ) );
197	3.07M	silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy[0], sizeof( silk_nsq_state ) );
198	3.07M	psEnc->sCmn.indices.Seed = seed_copy;
199	3.07M	psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
200	3.07M	psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
201	3.07M	}
202
203		/*****************************************/
204		/* Noise shaping quantization */
205		/*****************************************/
206	70.4M	silk_NSQ_wrapper_FLP( psEnc, &sEncCtrl, &psEnc->sCmn.indices, &psEnc->sCmn.sNSQ, psEnc->sCmn.pulses, x_frame );
207
208	70.4M	if ( iter == maxIter && !found_lower ) {
209	75.5k	silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
210	75.5k	}
211
212		/****************************************/
213		/* Encode Parameters */
214		/****************************************/
215	70.4M	silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
216
217		/****************************************/
218		/* Encode Excitation Signal */
219		/****************************************/
220	70.4M	silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
221	70.4M	psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
222
223	70.4M	nBits = ec_tell( psRangeEnc );
224
225		/* If we still bust after the last iteration, do some damage control. */
226	70.4M	if ( iter == maxIter && !found_lower && nBits > maxBits ) {
227	69.8k	silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
228
229		/* Keep gains the same as the last frame. */
230	69.8k	psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
231	326k	for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
232	256k	psEnc->sCmn.indices.GainsIndices[ i ] = 4;
233	256k	}
234	69.8k	if (condCoding != CODE_CONDITIONALLY) {
235	53.6k	psEnc->sCmn.indices.GainsIndices[ 0 ] = sEncCtrl.lastGainIndexPrev;
236	53.6k	}
237	69.8k	psEnc->sCmn.ec_prevLagIndex = ec_prevLagIndex_copy;
238	69.8k	psEnc->sCmn.ec_prevSignalType = ec_prevSignalType_copy;
239		/* Clear all pulses. */
240	12.6M	for ( i = 0; i < psEnc->sCmn.frame_length; i++ ) {
241	12.6M	psEnc->sCmn.pulses[ i ] = 0;
242	12.6M	}
243
244	69.8k	silk_encode_indices( &psEnc->sCmn, psRangeEnc, psEnc->sCmn.nFramesEncoded, 0, condCoding );
245
246	69.8k	silk_encode_pulses( psRangeEnc, psEnc->sCmn.indices.signalType, psEnc->sCmn.indices.quantOffsetType,
247	69.8k	psEnc->sCmn.pulses, psEnc->sCmn.frame_length );
248
249	69.8k	nBits = ec_tell( psRangeEnc );
250	69.8k	}
251
252	70.4M	if( useCBR == 0 && iter == 0 && nBits <= maxBits ) {
253	38.7M	break;
254	38.7M	}
255	70.4M	}
256
257	199M	if( iter == maxIter ) {
258	28.2M	if( found_lower && ( gainsID == gainsID_lower \|\| nBits > maxBits ) ) {
259		/* Restore output state from earlier iteration that did meet the bitrate budget */
260	28.0M	silk_memcpy( psRangeEnc, &sRangeEnc_copy2, sizeof( ec_enc ) );
261	28.0M	celt_assert( sRangeEnc_copy2.offs <= 1275 );
262	28.0M	silk_memcpy( psRangeEnc->buf, ec_buf_copy, sRangeEnc_copy2.offs );
263	28.0M	silk_memcpy( &psEnc->sCmn.sNSQ, &sNSQ_copy[1], sizeof( silk_nsq_state ) );
264	28.0M	psEnc->sShape.LastGainIndex = LastGainIndex_copy2;
265	28.0M	}
266	28.2M	break;
267	28.2M	}
268
269	170M	if( nBits > maxBits ) {
270	1.70M	if( found_lower == 0 && iter >= 2 ) {
271		/* Adjust the quantizer's rate/distortion tradeoff and discard previous "upper" results */
272	456k	sEncCtrl.Lambda = silk_max_float(sEncCtrl.Lambda*1.5f, 1.5f);
273		/* Reducing dithering can help us hit the target. */
274	456k	psEnc->sCmn.indices.quantOffsetType = 0;
275	456k	found_upper = 0;
276	456k	gainsID_upper = -1;
277	1.25M	} else {
278	1.25M	found_upper = 1;
279	1.25M	nBits_upper = nBits;
280	1.25M	gainMult_upper = gainMult_Q8;
281	1.25M	gainsID_upper = gainsID;
282	1.25M	}
283	169M	} else if( nBits < maxBits - bits_margin ) {
284	168M	found_lower = 1;
285	168M	nBits_lower = nBits;
286	168M	gainMult_lower = gainMult_Q8;
287	168M	if( gainsID != gainsID_lower ) {
288	29.7M	gainsID_lower = gainsID;
289		/* Copy part of the output state */
290	29.7M	silk_memcpy( &sRangeEnc_copy2, psRangeEnc, sizeof( ec_enc ) );
291	29.7M	celt_assert( psRangeEnc->offs <= 1275 );
292	29.7M	silk_memcpy( ec_buf_copy, psRangeEnc->buf, psRangeEnc->offs );
293	29.7M	silk_memcpy( &sNSQ_copy[1], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
294	29.7M	LastGainIndex_copy2 = psEnc->sShape.LastGainIndex;
295	29.7M	}
296	168M	} else {
297		/* Close enough */
298	289k	break;
299	289k	}
300
301	170M	if ( !found_lower && nBits > maxBits ) {
302	1.08M	int j;
303	5.01M	for ( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
304	3.93M	int sum=0;
305	197M	for ( j = ipsEnc->sCmn.subfr_length; j < (i+1)psEnc->sCmn.subfr_length; j++ ) {
306	193M	sum += abs( psEnc->sCmn.pulses[j] );
307	193M	}
308	3.93M	if ( iter == 0 \|\| (sum < best_sum[i] && !gain_lock[i]) ) {
309	2.16M	best_sum[i] = sum;
310	2.16M	best_gain_mult[i] = gainMult_Q8;
311	2.16M	} else {
312	1.76M	gain_lock[i] = 1;
313	1.76M	}
314	3.93M	}
315	1.08M	}
316	170M	if( ( found_lower & found_upper ) == 0 ) {
317		/* Adjust gain according to high-rate rate/distortion curve */
318	169M	if( nBits > maxBits ) {
319	1.08M	gainMult_Q8 = silk_min_32( 1024, gainMult_Q8*3/2 );
320	168M	} else {
321	168M	gainMult_Q8 = silk_max_32( 64, gainMult_Q8*4/5 );
322	168M	}
323	169M	} else {
324		/* Adjust gain by interpolating */
325	1.19M	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	1.19M	if( gainMult_Q8 > silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 ) ) {
328	177k	gainMult_Q8 = silk_ADD_RSHIFT32( gainMult_lower, gainMult_upper - gainMult_lower, 2 );
329	177k	} else
330	1.02M	if( gainMult_Q8 < silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 ) ) {
331	284k	gainMult_Q8 = silk_SUB_RSHIFT32( gainMult_upper, gainMult_upper - gainMult_lower, 2 );
332	284k	}
333	1.19M	}
334
335	703M	for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
336	532M	opus_int16 tmp;
337	532M	if ( gain_lock[i] ) {
338	2.07M	tmp = best_gain_mult[i];
339	530M	} else {
340	530M	tmp = gainMult_Q8;
341	530M	}
342	532M	pGains_Q16[ i ] = silk_LSHIFT_SAT32( silk_SMULWB( sEncCtrl.GainsUnq_Q16[ i ], tmp ), 8 );
343	532M	}
344
345		/* Quantize gains */
346	170M	psEnc->sShape.LastGainIndex = sEncCtrl.lastGainIndexPrev;
347	170M	silk_gains_quant( psEnc->sCmn.indices.GainsIndices, pGains_Q16,
348	170M	&psEnc->sShape.LastGainIndex, condCoding == CODE_CONDITIONALLY, psEnc->sCmn.nb_subfr );
349
350		/* Unique identifier of gains vector */
351	170M	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	703M	for( i = 0; i < psEnc->sCmn.nb_subfr; i++ ) {
355	532M	sEncCtrl.Gains[ i ] = pGains_Q16[ i ] / 65536.0f;
356	532M	}
357	170M	}
358	67.3M	}
359
360		/* Update input buffer */
361	67.3M	silk_memmove( psEnc->x_buf, &psEnc->x_buf[ psEnc->sCmn.frame_length ],
362	67.3M	( psEnc->sCmn.ltp_mem_length + LA_SHAPE_MS * psEnc->sCmn.fs_kHz ) * sizeof( silk_float ) );
363
364		/* Exit without entropy coding */
365	67.3M	if( psEnc->sCmn.prefillFlag ) {
366		/* No payload */
367	1.24k	*pnBytesOut = 0;
368	1.24k	RESTORE_STACK;
369	1.24k	return ret;
370	1.24k	}
371
372		/* Parameters needed for next frame */
373	67.3M	psEnc->sCmn.prevLag = sEncCtrl.pitchL[ psEnc->sCmn.nb_subfr - 1 ];
374	67.3M	psEnc->sCmn.prevSignalType = psEnc->sCmn.indices.signalType;
375
376		/****************************************/
377		/* Finalize payload */
378		/****************************************/
379	67.3M	psEnc->sCmn.first_frame_after_reset = 0;
380		/* Payload size */
381	67.3M	*pnBytesOut = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
382
383	67.3M	RESTORE_STACK;
384	67.3M	return ret;
385	67.3M	}
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	67.3M	{
395	67.3M	opus_int k;
396	67.3M	opus_int32 Gains_Q16[ MAX_NB_SUBFR ];
397	67.3M	silk_float TempGains[ MAX_NB_SUBFR ];
398	67.3M	SideInfoIndices *psIndices_LBRR = &psEnc->sCmn.indices_LBRR[ psEnc->sCmn.nFramesEncoded ];
399	67.3M	VARDECL(silk_nsq_state, sNSQ_LBRR);
400	67.3M	SAVE_STACK;
401
402		/*******************************************/
403		/* Control use of inband LBRR */
404		/*******************************************/
405	67.3M	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	612k	ALLOC(sNSQ_LBRR, 1, silk_nsq_state);
409
410	612k	psEnc->sCmn.LBRR_flags[ psEnc->sCmn.nFramesEncoded ] = 1;
411
412		/* Copy noise shaping quantizer state and quantization indices from regular encoding */
413	612k	silk_memcpy( &sNSQ_LBRR[0], &psEnc->sCmn.sNSQ, sizeof( silk_nsq_state ) );
414	612k	silk_memcpy( psIndices_LBRR, &psEnc->sCmn.indices, sizeof( SideInfoIndices ) );
415
416		/* Save original gains */
417	612k	silk_memcpy( TempGains, psEncCtrl->Gains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
418
419	612k	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	487k	psEnc->sCmn.LBRRprevLastGainIndex = psEnc->sShape.LastGainIndex;
422
423		/* Increase Gains to get target LBRR rate */
424	487k	psIndices_LBRR->GainsIndices[ 0 ] += psEnc->sCmn.LBRR_GainIncreases;
425	487k	psIndices_LBRR->GainsIndices[ 0 ] = silk_min_int( psIndices_LBRR->GainsIndices[ 0 ], N_LEVELS_QGAIN - 1 );
426	487k	}
427
428		/* Decode to get gains in sync with decoder */
429	612k	silk_gains_dequant( Gains_Q16, psIndices_LBRR->GainsIndices,
430	612k	&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	2.83M	for( k = 0; k < psEnc->sCmn.nb_subfr; k++ ) {
434	2.22M	psEncCtrl->Gains[ k ] = Gains_Q16[ k ] * ( 1.0f / 65536.0f );
435	2.22M	}
436
437		/*****************************************/
438		/* Noise shaping quantization */
439		/*****************************************/
440	612k	silk_NSQ_wrapper_FLP( psEnc, psEncCtrl, psIndices_LBRR, &sNSQ_LBRR[0],
441	612k	psEnc->sCmn.pulses_LBRR[ psEnc->sCmn.nFramesEncoded ], xfw );
442
443		/* Restore original gains */
444	612k	silk_memcpy( psEncCtrl->Gains, TempGains, psEnc->sCmn.nb_subfr * sizeof( silk_float ) );
445	612k	}
446	67.3M	RESTORE_STACK;
447	67.3M	}