@scrypted/libav 1.0.170 → 1.0.171

package/opus/silk/float/LPC_analysis_filter_FLP.c

@@ -1,249 +0,0 @@
-/***********************************************************************
-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"
-
-/************************************************/
-/* LPC analysis filter                          */
-/* NB! State is kept internally and the         */
-/* filter always starts with zero state         */
-/* first Order output samples are set to zero   */
-/************************************************/
-
-/* 16th order LPC analysis filter, does not write first 16 samples */
-static OPUS_INLINE void silk_LPC_analysis_filter16_FLP(
-          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const silk_float                 s[],                /* I    Input signal                            */
-    const opus_int                   length              /* I    Length of input signal                  */
-)
-{
-    opus_int   ix;
-    silk_float LPC_pred;
-    const silk_float *s_ptr;
-
-    for( ix = 16; ix < length; ix++ ) {
-        s_ptr = &s[ix - 1];
-
-        /* short-term prediction */
-        LPC_pred = s_ptr[  0 ]  * PredCoef[ 0 ]  +
-                   s_ptr[ -1 ]  * PredCoef[ 1 ]  +
-                   s_ptr[ -2 ]  * PredCoef[ 2 ]  +
-                   s_ptr[ -3 ]  * PredCoef[ 3 ]  +
-                   s_ptr[ -4 ]  * PredCoef[ 4 ]  +
-                   s_ptr[ -5 ]  * PredCoef[ 5 ]  +
-                   s_ptr[ -6 ]  * PredCoef[ 6 ]  +
-                   s_ptr[ -7 ]  * PredCoef[ 7 ]  +
-                   s_ptr[ -8 ]  * PredCoef[ 8 ]  +
-                   s_ptr[ -9 ]  * PredCoef[ 9 ]  +
-                   s_ptr[ -10 ] * PredCoef[ 10 ] +
-                   s_ptr[ -11 ] * PredCoef[ 11 ] +
-                   s_ptr[ -12 ] * PredCoef[ 12 ] +
-                   s_ptr[ -13 ] * PredCoef[ 13 ] +
-                   s_ptr[ -14 ] * PredCoef[ 14 ] +
-                   s_ptr[ -15 ] * PredCoef[ 15 ];
-
-        /* prediction error */
-        r_LPC[ix] = s_ptr[ 1 ] - LPC_pred;
-    }
-}
-
-/* 12th order LPC analysis filter, does not write first 12 samples */
-static OPUS_INLINE void silk_LPC_analysis_filter12_FLP(
-          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const silk_float                 s[],                /* I    Input signal                            */
-    const opus_int                   length              /* I    Length of input signal                  */
-)
-{
-    opus_int   ix;
-    silk_float LPC_pred;
-    const silk_float *s_ptr;
-
-    for( ix = 12; ix < length; ix++ ) {
-        s_ptr = &s[ix - 1];
-
-        /* short-term prediction */
-        LPC_pred = s_ptr[  0 ]  * PredCoef[ 0 ]  +
-                   s_ptr[ -1 ]  * PredCoef[ 1 ]  +
-                   s_ptr[ -2 ]  * PredCoef[ 2 ]  +
-                   s_ptr[ -3 ]  * PredCoef[ 3 ]  +
-                   s_ptr[ -4 ]  * PredCoef[ 4 ]  +
-                   s_ptr[ -5 ]  * PredCoef[ 5 ]  +
-                   s_ptr[ -6 ]  * PredCoef[ 6 ]  +
-                   s_ptr[ -7 ]  * PredCoef[ 7 ]  +
-                   s_ptr[ -8 ]  * PredCoef[ 8 ]  +
-                   s_ptr[ -9 ]  * PredCoef[ 9 ]  +
-                   s_ptr[ -10 ] * PredCoef[ 10 ] +
-                   s_ptr[ -11 ] * PredCoef[ 11 ];
-
-        /* prediction error */
-        r_LPC[ix] = s_ptr[ 1 ] - LPC_pred;
-    }
-}
-
-/* 10th order LPC analysis filter, does not write first 10 samples */
-static OPUS_INLINE void silk_LPC_analysis_filter10_FLP(
-          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const silk_float                 s[],                /* I    Input signal                            */
-    const opus_int                   length              /* I    Length of input signal                  */
-)
-{
-    opus_int   ix;
-    silk_float LPC_pred;
-    const silk_float *s_ptr;
-
-    for( ix = 10; ix < length; ix++ ) {
-        s_ptr = &s[ix - 1];
-
-        /* short-term prediction */
-        LPC_pred = s_ptr[  0 ] * PredCoef[ 0 ]  +
-                   s_ptr[ -1 ] * PredCoef[ 1 ]  +
-                   s_ptr[ -2 ] * PredCoef[ 2 ]  +
-                   s_ptr[ -3 ] * PredCoef[ 3 ]  +
-                   s_ptr[ -4 ] * PredCoef[ 4 ]  +
-                   s_ptr[ -5 ] * PredCoef[ 5 ]  +
-                   s_ptr[ -6 ] * PredCoef[ 6 ]  +
-                   s_ptr[ -7 ] * PredCoef[ 7 ]  +
-                   s_ptr[ -8 ] * PredCoef[ 8 ]  +
-                   s_ptr[ -9 ] * PredCoef[ 9 ];
-
-        /* prediction error */
-        r_LPC[ix] = s_ptr[ 1 ] - LPC_pred;
-    }
-}
-
-/* 8th order LPC analysis filter, does not write first 8 samples */
-static OPUS_INLINE void silk_LPC_analysis_filter8_FLP(
-          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const silk_float                 s[],                /* I    Input signal                            */
-    const opus_int                   length              /* I    Length of input signal                  */
-)
-{
-    opus_int   ix;
-    silk_float LPC_pred;
-    const silk_float *s_ptr;
-
-    for( ix = 8; ix < length; ix++ ) {
-        s_ptr = &s[ix - 1];
-
-        /* short-term prediction */
-        LPC_pred = s_ptr[  0 ] * PredCoef[ 0 ]  +
-                   s_ptr[ -1 ] * PredCoef[ 1 ]  +
-                   s_ptr[ -2 ] * PredCoef[ 2 ]  +
-                   s_ptr[ -3 ] * PredCoef[ 3 ]  +
-                   s_ptr[ -4 ] * PredCoef[ 4 ]  +
-                   s_ptr[ -5 ] * PredCoef[ 5 ]  +
-                   s_ptr[ -6 ] * PredCoef[ 6 ]  +
-                   s_ptr[ -7 ] * PredCoef[ 7 ];
-
-        /* prediction error */
-        r_LPC[ix] = s_ptr[ 1 ] - LPC_pred;
-    }
-}
-
-/* 6th order LPC analysis filter, does not write first 6 samples */
-static OPUS_INLINE void silk_LPC_analysis_filter6_FLP(
-          silk_float                 r_LPC[],            /* O    LPC residual signal                     */
-    const silk_float                 PredCoef[],         /* I    LPC coefficients                        */
-    const silk_float                 s[],                /* I    Input signal                            */
-    const opus_int                   length              /* I    Length of input signal                  */
-)
-{
-    opus_int   ix;
-    silk_float LPC_pred;
-    const silk_float *s_ptr;
-
-    for( ix = 6; ix < length; ix++ ) {
-        s_ptr = &s[ix - 1];
-
-        /* short-term prediction */
-        LPC_pred = s_ptr[  0 ] * PredCoef[ 0 ]  +
-                   s_ptr[ -1 ] * PredCoef[ 1 ]  +
-                   s_ptr[ -2 ] * PredCoef[ 2 ]  +
-                   s_ptr[ -3 ] * PredCoef[ 3 ]  +
-                   s_ptr[ -4 ] * PredCoef[ 4 ]  +
-                   s_ptr[ -5 ] * PredCoef[ 5 ];
-
-        /* prediction error */
-        r_LPC[ix] = s_ptr[ 1 ] - LPC_pred;
-    }
-}
-
-/************************************************/
-/* LPC analysis filter                          */
-/* NB! State is kept internally and the         */
-/* filter always starts with zero state         */
-/* first Order output samples are set to zero   */
-/************************************************/
-void silk_LPC_analysis_filter_FLP(
-    silk_float                      r_LPC[],                            /* O    LPC residual signal                         */
-    const silk_float                PredCoef[],                         /* I    LPC coefficients                            */
-    const silk_float                s[],                                /* I    Input signal                                */
-    const opus_int                  length,                             /* I    Length of input signal                      */
-    const opus_int                  Order                               /* I    LPC order                                   */
-)
-{
-    celt_assert( Order <= length );
-
-    switch( Order ) {
-        case 6:
-            silk_LPC_analysis_filter6_FLP(  r_LPC, PredCoef, s, length );
-        break;
-
-        case 8:
-            silk_LPC_analysis_filter8_FLP(  r_LPC, PredCoef, s, length );
-        break;
-
-        case 10:
-            silk_LPC_analysis_filter10_FLP( r_LPC, PredCoef, s, length );
-        break;
-
-        case 12:
-            silk_LPC_analysis_filter12_FLP( r_LPC, PredCoef, s, length );
-        break;
-
-        case 16:
-            silk_LPC_analysis_filter16_FLP( r_LPC, PredCoef, s, length );
-        break;
-
-        default:
-            celt_assert( 0 );
-        break;
-    }
-
-    /* Set first Order output samples to zero */
-    silk_memset( r_LPC, 0, Order * sizeof( silk_float ) );
-}
-

package/opus/silk/float/LPC_inv_pred_gain_FLP.c

@@ -1,73 +0,0 @@
-/***********************************************************************
-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 "SigProc_FIX.h"
-#include "SigProc_FLP.h"
-#include "define.h"
-
-/* compute inverse of LPC prediction gain, and                          */
-/* test if LPC coefficients are stable (all poles within unit circle)   */
-/* this code is based on silk_a2k_FLP()                                 */
-silk_float silk_LPC_inverse_pred_gain_FLP(  /* O    return inverse prediction gain, energy domain               */
-    const silk_float    *A,                 /* I    prediction coefficients [order]                             */
-    opus_int32          order               /* I    prediction order                                            */
-)
-{
-    opus_int   k, n;
-    double     invGain, rc, rc_mult1, rc_mult2, tmp1, tmp2;
-    silk_float Atmp[ SILK_MAX_ORDER_LPC ];
-
-    silk_memcpy( Atmp, A, order * sizeof(silk_float) );
-
-    invGain = 1.0;
-    for( k = order - 1; k > 0; k-- ) {
-        rc = -Atmp[ k ];
-        rc_mult1 = 1.0f - rc * rc;
-        invGain *= rc_mult1;
-        if( invGain * MAX_PREDICTION_POWER_GAIN < 1.0f ) {
-            return 0.0f;
-        }
-        rc_mult2 = 1.0f / rc_mult1;
-        for( n = 0; n < (k + 1) >> 1; n++ ) {
-            tmp1 = Atmp[ n ];
-            tmp2 = Atmp[ k - n - 1 ];
-            Atmp[ n ]         = (silk_float)( ( tmp1 - tmp2 * rc ) * rc_mult2 );
-            Atmp[ k - n - 1 ] = (silk_float)( ( tmp2 - tmp1 * rc ) * rc_mult2 );
-        }
-    }
-    rc = -Atmp[ 0 ];
-    rc_mult1 = 1.0f - rc * rc;
-    invGain *= rc_mult1;
-    if( invGain * MAX_PREDICTION_POWER_GAIN < 1.0f ) {
-        return 0.0f;
-    }
-    return (silk_float)invGain;
-}

package/opus/silk/float/LTP_analysis_filter_FLP.c

@@ -1,75 +0,0 @@
-/***********************************************************************
-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 "main_FLP.h"
-
-void silk_LTP_analysis_filter_FLP(
-    silk_float                      *LTP_res,                           /* O    LTP res MAX_NB_SUBFR*(pre_lgth+subfr_lngth) */
-    const silk_float                *x,                                 /* I    Input signal, with preceding samples        */
-    const silk_float                B[ LTP_ORDER * MAX_NB_SUBFR ],      /* I    LTP coefficients for each subframe          */
-    const opus_int                  pitchL[   MAX_NB_SUBFR ],           /* I    Pitch lags                                  */
-    const silk_float                invGains[ MAX_NB_SUBFR ],           /* I    Inverse quantization gains                  */
-    const opus_int                  subfr_length,                       /* I    Length of each subframe                     */
-    const opus_int                  nb_subfr,                           /* I    number of subframes                         */
-    const opus_int                  pre_length                          /* I    Preceding samples for each subframe         */
-)
-{
-    const silk_float *x_ptr, *x_lag_ptr;
-    silk_float   Btmp[ LTP_ORDER ];
-    silk_float   *LTP_res_ptr;
-    silk_float   inv_gain;
-    opus_int     k, i, j;
-
-    x_ptr = x;
-    LTP_res_ptr = LTP_res;
-    for( k = 0; k < nb_subfr; k++ ) {
-        x_lag_ptr = x_ptr - pitchL[ k ];
-        inv_gain = invGains[ k ];
-        for( i = 0; i < LTP_ORDER; i++ ) {
-            Btmp[ i ] = B[ k * LTP_ORDER + i ];
-        }
-
-        /* LTP analysis FIR filter */
-        for( i = 0; i < subfr_length + pre_length; i++ ) {
-            LTP_res_ptr[ i ] = x_ptr[ i ];
-            /* Subtract long-term prediction */
-            for( j = 0; j < LTP_ORDER; j++ ) {
-                LTP_res_ptr[ i ] -= Btmp[ j ] * x_lag_ptr[ LTP_ORDER / 2 - j ];
-            }
-            LTP_res_ptr[ i ] *= inv_gain;
-            x_lag_ptr++;
-        }
-
-        /* Update pointers */
-        LTP_res_ptr += subfr_length + pre_length;
-        x_ptr       += subfr_length;
-    }
-}

package/opus/silk/float/LTP_scale_ctrl_FLP.c

@@ -1,58 +0,0 @@
-/***********************************************************************
-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 "main_FLP.h"
-
-void silk_LTP_scale_ctrl_FLP(
-    silk_encoder_state_FLP          *psEnc,                             /* I/O  Encoder state FLP                           */
-    silk_encoder_control_FLP        *psEncCtrl,                         /* I/O  Encoder control FLP                         */
-    opus_int                        condCoding                          /* I    The type of conditional coding to use       */
-)
-{
-    opus_int   round_loss;
-
-    if( condCoding == CODE_INDEPENDENTLY ) {
-        /* Only scale if first frame in packet */
-        round_loss = psEnc->sCmn.PacketLoss_perc * psEnc->sCmn.nFramesPerPacket;
-        if ( psEnc->sCmn.LBRR_flag ) {
-            /* LBRR reduces the effective loss. In practice, it does not square the loss because
-               losses aren't independent, but that still seems to work best. We also never go below 2%. */
-            round_loss = 2 + silk_SMULBB( round_loss, round_loss) / 100;
-        }
-        psEnc->sCmn.indices.LTP_scaleIndex = silk_SMULBB( psEncCtrl->LTPredCodGain, round_loss ) > silk_log2lin( 2900 - psEnc->sCmn.SNR_dB_Q7 );
-        psEnc->sCmn.indices.LTP_scaleIndex += silk_SMULBB( psEncCtrl->LTPredCodGain, round_loss ) > silk_log2lin( 3900 - psEnc->sCmn.SNR_dB_Q7 );
-    } else {
-        /* Default is minimum scaling */
-        psEnc->sCmn.indices.LTP_scaleIndex = 0;
-    }
-
-    psEncCtrl->LTP_scale = (silk_float)silk_LTPScales_table_Q14[ psEnc->sCmn.indices.LTP_scaleIndex ] / 16384.0f;
-}

package/opus/silk/float/SigProc_FLP.h

@@ -1,205 +0,0 @@
-/***********************************************************************
-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.
-***********************************************************************/
-
-#ifndef SILK_SIGPROC_FLP_H
-#define SILK_SIGPROC_FLP_H
-
-#include "SigProc_FIX.h"
-#include "float_cast.h"
-#include "main.h"
-#include <math.h>
-
-#ifdef  __cplusplus
-extern "C"
-{
-#endif
-
-/********************************************************************/
-/*                    SIGNAL PROCESSING FUNCTIONS                   */
-/********************************************************************/
-
-/* Chirp (bw expand) LP AR filter */
-void silk_bwexpander_FLP(
-    silk_float          *ar,                /* I/O  AR filter to be expanded (without leading 1)                */
-    const opus_int      d,                  /* I    length of ar                                                */
-    const silk_float    chirp               /* I    chirp factor (typically in range (0..1) )                   */
-);
-
-/* compute inverse of LPC prediction gain, and                          */
-/* test if LPC coefficients are stable (all poles within unit circle)   */
-/* this code is based on silk_FLP_a2k()                                 */
-silk_float silk_LPC_inverse_pred_gain_FLP(  /* O    return inverse prediction gain, energy domain               */
-    const silk_float    *A,                 /* I    prediction coefficients [order]                             */
-    opus_int32          order               /* I    prediction order                                            */
-);
-
-silk_float silk_schur_FLP(                  /* O    returns residual energy                                     */
-    silk_float          refl_coef[],        /* O    reflection coefficients (length order)                      */
-    const silk_float    auto_corr[],        /* I    autocorrelation sequence (length order+1)                   */
-    opus_int            order               /* I    order                                                       */
-);
-
-void silk_k2a_FLP(
-    silk_float          *A,                 /* O     prediction coefficients [order]                            */
-    const silk_float    *rc,                /* I     reflection coefficients [order]                            */
-    opus_int32          order               /* I     prediction order                                           */
-);
-
-/* compute autocorrelation */
-void silk_autocorrelation_FLP(
-    silk_float          *results,           /* O    result (length correlationCount)                            */
-    const silk_float    *inputData,         /* I    input data to correlate                                     */
-    opus_int            inputDataSize,      /* I    length of input                                             */
-    opus_int            correlationCount,    /* I    number of correlation taps to compute                       */
-    int                 arch
-);
-
-opus_int silk_pitch_analysis_core_FLP(      /* O    Voicing estimate: 0 voiced, 1 unvoiced                      */
-    const silk_float    *frame,             /* I    Signal of length PE_FRAME_LENGTH_MS*Fs_kHz                  */
-    opus_int            *pitch_out,         /* O    Pitch lag values [nb_subfr]                                 */
-    opus_int16          *lagIndex,          /* O    Lag Index                                                   */
-    opus_int8           *contourIndex,      /* O    Pitch contour Index                                         */
-    silk_float          *LTPCorr,           /* I/O  Normalized correlation; input: value from previous frame    */
-    opus_int            prevLag,            /* I    Last lag of previous frame; set to zero is unvoiced         */
-    const silk_float    search_thres1,      /* I    First stage threshold for lag candidates 0 - 1              */
-    const silk_float    search_thres2,      /* I    Final threshold for lag candidates 0 - 1                    */
-    const opus_int      Fs_kHz,             /* I    sample frequency (kHz)                                      */
-    const opus_int      complexity,         /* I    Complexity setting, 0-2, where 2 is highest                 */
-    const opus_int      nb_subfr,           /* I    Number of 5 ms subframes                                    */
-    int                 arch                /* I    Run-time architecture                                       */
-);
-
-void silk_insertion_sort_decreasing_FLP(
-    silk_float          *a,                 /* I/O  Unsorted / Sorted vector                                    */
-    opus_int            *idx,               /* O    Index vector for the sorted elements                        */
-    const opus_int      L,                  /* I    Vector length                                               */
-    const opus_int      K                   /* I    Number of correctly sorted positions                        */
-);
-
-/* Compute reflection coefficients from input signal */
-silk_float silk_burg_modified_FLP(          /* O    returns residual energy                                     */
-    silk_float          A[],                /* O    prediction coefficients (length order)                      */
-    const silk_float    x[],                /* I    input signal, length: nb_subfr*(D+L_sub)                    */
-    const silk_float    minInvGain,         /* I    minimum inverse prediction gain                             */
-    const opus_int      subfr_length,       /* I    input signal subframe length (incl. D preceding samples)    */
-    const opus_int      nb_subfr,           /* I    number of subframes stacked in x                            */
-    const opus_int      D,                  /* I    order                                                       */
-    int                 arch
-);
-
-/* multiply a vector by a constant */
-void silk_scale_vector_FLP(
-    silk_float          *data1,
-    silk_float          gain,
-    opus_int            dataSize
-);
-
-/* copy and multiply a vector by a constant */
-void silk_scale_copy_vector_FLP(
-    silk_float          *data_out,
-    const silk_float    *data_in,
-    silk_float          gain,
-    opus_int            dataSize
-);
-
-/* inner product of two silk_float arrays, with result as double */
-double silk_inner_product_FLP_c(
-    const silk_float    *data1,
-    const silk_float    *data2,
-    opus_int            dataSize
-);
-
-#ifndef OVERRIDE_inner_product_FLP
-#define silk_inner_product_FLP(data1, data2, dataSize, arch) ((void)arch,silk_inner_product_FLP_c(data1, data2, dataSize))
-#endif
-
-
-/* sum of squares of a silk_float array, with result as double */
-double silk_energy_FLP(
-    const silk_float    *data,
-    opus_int            dataSize
-);
-
-/********************************************************************/
-/*                                MACROS                            */
-/********************************************************************/
-
-#define PI              (3.1415926536f)
-
-#define silk_min_float( a, b )                  (((a) < (b)) ? (a) :  (b))
-#define silk_max_float( a, b )                  (((a) > (b)) ? (a) :  (b))
-#define silk_abs_float( a )                     ((silk_float)fabs(a))
-
-/* sigmoid function */
-static OPUS_INLINE silk_float silk_sigmoid( silk_float x )
-{
-    return (silk_float)(1.0 / (1.0 + exp(-x)));
-}
-
-/* floating-point to integer conversion (rounding) */
-static OPUS_INLINE opus_int32 silk_float2int( silk_float x )
-{
-    return (opus_int32)float2int( x );
-}
-
-/* floating-point to integer conversion (rounding) */
-static OPUS_INLINE void silk_float2short_array(
-    opus_int16       *out,
-    const silk_float *in,
-    opus_int32       length
-)
-{
-    opus_int32 k;
-    for( k = length - 1; k >= 0; k-- ) {
-        out[k] = silk_SAT16( (opus_int32)float2int( in[k] ) );
-    }
-}
-
-/* integer to floating-point conversion */
-static OPUS_INLINE void silk_short2float_array(
-    silk_float       *out,
-    const opus_int16 *in,
-    opus_int32       length
-)
-{
-    opus_int32 k;
-    for( k = length - 1; k >= 0; k-- ) {
-        out[k] = (silk_float)in[k];
-    }
-}
-
-/* using log2() helps the fixed-point conversion */
-static OPUS_INLINE silk_float silk_log2( double x )
-{
-    return ( silk_float )( 3.32192809488736 * log10( x ) );
-}
-
-#ifdef  __cplusplus
-}
-#endif
-
-#endif /* SILK_SIGPROC_FLP_H */