Updating Opus to release 1.1

silk/float/solve_LS_FLP.c

 /***********************************************************************
 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 19 matching lines @@
 #endif
 
 #include "main_FLP.h"
 #include "tuning_parameters.h"
 
 /**********************************************************************
  * LDL Factorisation. Finds the upper triangular matrix L and the diagonal
  * Matrix D (only the diagonal elements returned in a vector)such that
  * the symmetric matric A is given by A = L*D*L'.
  **********************************************************************/
-static inline void silk_LDL_FLP(
+static OPUS_INLINE void silk_LDL_FLP(
     silk_float          *A,         /* I/O  Pointer to Symetric Square Matrix                               */
     opus_int            M,          /* I    Size of Matrix                                                  */
     silk_float          *L,         /* I/O  Pointer to Square Upper triangular Matrix                       */
     silk_float          *Dinv       /* I/O  Pointer to vector holding the inverse diagonal elements of D    */
 );
 
 /**********************************************************************
  * Function to solve linear equation Ax = b, when A is a MxM lower
  * triangular matrix, with ones on the diagonal.
  **********************************************************************/
-static inline void silk_SolveWithLowerTriangularWdiagOnes_FLP(
+static OPUS_INLINE void silk_SolveWithLowerTriangularWdiagOnes_FLP(
     const silk_float    *L,         /* I    Pointer to Lower Triangular Matrix                              */
     opus_int            M,          /* I    Dim of Matrix equation                                          */
     const silk_float    *b,         /* I    b Vector                                                        */
     silk_float          *x          /* O    x Vector                                                        */
 );
 
 /**********************************************************************
  * Function to solve linear equation (A^T)x = b, when A is a MxM lower
  * triangular, with ones on the diagonal. (ie then A^T is upper triangular)
  **********************************************************************/
-static inline void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
+static OPUS_INLINE void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
     const silk_float    *L,         /* I    Pointer to Lower Triangular Matrix                              */
     opus_int            M,          /* I    Dim of Matrix equation                                          */
     const silk_float    *b,         /* I    b Vector                                                        */
     silk_float          *x          /* O    x Vector                                                        */
 );
 
 /**********************************************************************
  * Function to solve linear equation Ax = b, when A is a MxM
  * symmetric square matrix - using LDL factorisation
  **********************************************************************/
@@ skipping 29 matching lines @@
     ****************************************************/
     for( i = 0; i < M; i++ ) {
         T[ i ] = T[ i ] * Dinv[ i ];
     }
     /****************************************************
     x = inv(L') * inv(D) * T
     *****************************************************/
     silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP( &L[ 0 ][ 0 ], M, T, x );
 }
 
-static inline void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
+static OPUS_INLINE void silk_SolveWithUpperTriangularFromLowerWdiagOnes_FLP(
     const silk_float    *L,         /* I    Pointer to Lower Triangular Matrix                              */
     opus_int            M,          /* I    Dim of Matrix equation                                          */
     const silk_float    *b,         /* I    b Vector                                                        */
     silk_float          *x          /* O    x Vector                                                        */
 )
 {
     opus_int   i, j;
     silk_float temp;
     const silk_float *ptr1;
 
     for( i = M - 1; i >= 0; i-- ) {
         ptr1 =  matrix_adr( L, 0, i, M );
         temp = 0;
         for( j = M - 1; j > i ; j-- ) {
             temp += ptr1[ j * M ] * x[ j ];
         }
         temp = b[ i ] - temp;
         x[ i ] = temp;
     }
 }
 
-static inline void silk_SolveWithLowerTriangularWdiagOnes_FLP(
+static OPUS_INLINE void silk_SolveWithLowerTriangularWdiagOnes_FLP(
     const silk_float    *L,         /* I    Pointer to Lower Triangular Matrix                              */
     opus_int            M,          /* I    Dim of Matrix equation                                          */
     const silk_float    *b,         /* I    b Vector                                                        */
     silk_float          *x          /* O    x Vector                                                        */
 )
 {
     opus_int   i, j;
     silk_float temp;
     const silk_float *ptr1;
 
     for( i = 0; i < M; i++ ) {
         ptr1 =  matrix_adr( L, i, 0, M );
         temp = 0;
         for( j = 0; j < i; j++ ) {
             temp += ptr1[ j ] * x[ j ];
         }
         temp = b[ i ] - temp;
         x[ i ] = temp;
     }
 }
 
-static inline void silk_LDL_FLP(
+static OPUS_INLINE void silk_LDL_FLP(
     silk_float          *A,         /* I/O  Pointer to Symetric Square Matrix                               */
     opus_int            M,          /* I    Size of Matrix                                                  */
     silk_float          *L,         /* I/O  Pointer to Square Upper triangular Matrix                       */
     silk_float          *Dinv       /* I/O  Pointer to vector holding the inverse diagonal elements of D    */
 )
 {
     opus_int i, j, k, loop_count, err = 1;
     silk_float *ptr1, *ptr2;
     double temp, diag_min_value;
     silk_float v[ MAX_MATRIX_SIZE ], D[ MAX_MATRIX_SIZE ]; /* temp arrays*/
@@ skipping 31 matching lines @@
                     temp += ptr2[ k ] * v[ k ];
                 }
                 matrix_ptr( L, i, j, M ) = ( silk_float )( ( ptr1[ i ] - temp ) * Dinv[ j ] );
                 ptr2 += M; /* go to next column*/
             }
         }
     }
     silk_assert( err == 0 );
 }