Updating Opus to release 1.1

silk/float/SigProc_FLP.h

 /***********************************************************************
 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.
@@ skipping 76 matching lines @@
     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                                    */
+    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 */
@@ skipping 38 matching lines @@
 /*                                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 inline silk_float silk_sigmoid( silk_float x )
+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 inline opus_int32 silk_float2int( silk_float x )
+static OPUS_INLINE opus_int32 silk_float2int( silk_float x )
 {
     return (opus_int32)float2int( x );
 }
 
 /* floating-point to integer conversion (rounding) */
-static inline void silk_float2short_array(
+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 inline void silk_short2float_array(
+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 inline silk_float silk_log2( double x )
+static OPUS_INLINE silk_float silk_log2( double x )
 {
     return ( silk_float )( 3.32192809488736 * log10( x ) );
 }
 
 #ifdef  __cplusplus
 }
 #endif
 
 #endif /* SILK_SIGPROC_FLP_H */