Updating Opus to release 1.1

silk/fixed/solve_LS_FIX.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 25 matching lines @@
 /*****************************/
 /* Internal function headers */
 /*****************************/
 
 typedef struct {
     opus_int32 Q36_part;
     opus_int32 Q48_part;
 } inv_D_t;
 
 /* Factorize square matrix A into LDL form */
-static inline void silk_LDL_factorize_FIX(
+static OPUS_INLINE void silk_LDL_factorize_FIX(
     opus_int32          *A,         /* I/O Pointer to Symetric Square Matrix                            */
     opus_int            M,          /* I   Size of Matrix                                               */
     opus_int32          *L_Q16,     /* I/O Pointer to Square Upper triangular Matrix                    */
     inv_D_t             *inv_D      /* I/O Pointer to vector holding inverted diagonal elements of D    */
 );
 
 /* Solve Lx = b, when L is lower triangular and has ones on the diagonal */
-static inline void silk_LS_SolveFirst_FIX(
+static OPUS_INLINE void silk_LS_SolveFirst_FIX(
     const opus_int32    *L_Q16,     /* I    Pointer to Lower Triangular Matrix                          */
     opus_int            M,          /* I    Dim of Matrix equation                                      */
     const opus_int32    *b,         /* I    b Vector                                                    */
     opus_int32          *x_Q16      /* O    x Vector                                                    */
 );
 
 /* Solve L^t*x = b, where L is lower triangular with ones on the diagonal */
-static inline void silk_LS_SolveLast_FIX(
+static OPUS_INLINE void silk_LS_SolveLast_FIX(
     const opus_int32    *L_Q16,     /* I    Pointer to Lower Triangular Matrix                          */
     const opus_int      M,          /* I    Dim of Matrix equation                                      */
     const opus_int32    *b,         /* I    b Vector                                                    */
     opus_int32          *x_Q16      /* O    x Vector                                                    */
 );
 
-static inline void silk_LS_divide_Q16_FIX(
+static OPUS_INLINE void silk_LS_divide_Q16_FIX(
     opus_int32          T[],        /* I/O  Numenator vector                                            */
     inv_D_t             *inv_D,     /* I    1 / D vector                                                */
     opus_int            M           /* I    dimension                                                   */
 );
 
 /* Solves Ax = b, assuming A is symmetric */
 void silk_solve_LDL_FIX(
     opus_int32                      *A,                                     /* I    Pointer to symetric square matrix A                                         */
     opus_int                        M,                                      /* I    Size of matrix                                                              */
     const opus_int32                *b,                                     /* I    Pointer to b vector                                                         */
@@ skipping 26 matching lines @@
     ****************************************************/
     silk_LS_divide_Q16_FIX( Y, inv_D, M );
 
     /****************************************************
     x = inv(L') * inv(D) * Y
     *****************************************************/
     silk_LS_SolveLast_FIX( L_Q16, M, Y, x_Q16 );
     RESTORE_STACK;
 }
 
-static inline void silk_LDL_factorize_FIX(
+static OPUS_INLINE void silk_LDL_factorize_FIX(
     opus_int32          *A,         /* I/O Pointer to Symetric Square Matrix                            */
     opus_int            M,          /* I   Size of Matrix                                               */
     opus_int32          *L_Q16,     /* I/O Pointer to Square Upper triangular Matrix                    */
     inv_D_t             *inv_D      /* I/O Pointer to vector holding inverted diagonal elements of D    */
 )
 {
     opus_int   i, j, k, status, loop_count;
     const opus_int32 *ptr1, *ptr2;
     opus_int32 diag_min_value, tmp_32, err;
     opus_int32 v_Q0[ MAX_MATRIX_SIZE ], D_Q0[ MAX_MATRIX_SIZE ];
@@ skipping 51 matching lines @@
 
                 /* go to next column */
                 ptr2 += M;
             }
         }
     }
 
     silk_assert( status == 0 );
 }
 
-static inline void silk_LS_divide_Q16_FIX(
+static OPUS_INLINE void silk_LS_divide_Q16_FIX(
     opus_int32          T[],        /* I/O  Numenator vector                                            */
     inv_D_t             *inv_D,     /* I    1 / D vector                                                */
     opus_int            M           /* I    dimension                                                   */
 )
 {
     opus_int   i;
     opus_int32 tmp_32;
     opus_int32 one_div_diag_Q36, one_div_diag_Q48;
 
     for( i = 0; i < M; i++ ) {
         one_div_diag_Q36 = inv_D[ i ].Q36_part;
         one_div_diag_Q48 = inv_D[ i ].Q48_part;
 
         tmp_32 = T[ i ];
         T[ i ] = silk_ADD32( silk_SMMUL( tmp_32, one_div_diag_Q48 ), silk_RSHIFT( silk_SMULWW( tmp_32, one_div_diag_Q36 ), 4 ) );
     }
 }
 
 /* Solve Lx = b, when L is lower triangular and has ones on the diagonal */
-static inline void silk_LS_SolveFirst_FIX(
+static OPUS_INLINE void silk_LS_SolveFirst_FIX(
     const opus_int32    *L_Q16,     /* I    Pointer to Lower Triangular Matrix                          */
     opus_int            M,          /* I    Dim of Matrix equation                                      */
     const opus_int32    *b,         /* I    b Vector                                                    */
     opus_int32          *x_Q16      /* O    x Vector                                                    */
 )
 {
     opus_int i, j;
     const opus_int32 *ptr32;
     opus_int32 tmp_32;
 
     for( i = 0; i < M; i++ ) {
         ptr32 = matrix_adr( L_Q16, i, 0, M );
         tmp_32 = 0;
         for( j = 0; j < i; j++ ) {
             tmp_32 = silk_SMLAWW( tmp_32, ptr32[ j ], x_Q16[ j ] );
         }
         x_Q16[ i ] = silk_SUB32( b[ i ], tmp_32 );
     }
 }
 
 /* Solve L^t*x = b, where L is lower triangular with ones on the diagonal */
-static inline void silk_LS_SolveLast_FIX(
+static OPUS_INLINE void silk_LS_SolveLast_FIX(
     const opus_int32    *L_Q16,     /* I    Pointer to Lower Triangular Matrix                          */
     const opus_int      M,          /* I    Dim of Matrix equation                                      */
     const opus_int32    *b,         /* I    b Vector                                                    */
     opus_int32          *x_Q16      /* O    x Vector                                                    */
 )
 {
     opus_int i, j;
     const opus_int32 *ptr32;
     opus_int32 tmp_32;
 
     for( i = M - 1; i >= 0; i-- ) {
         ptr32 = matrix_adr( L_Q16, 0, i, M );
         tmp_32 = 0;
         for( j = M - 1; j > i; j-- ) {
             tmp_32 = silk_SMLAWW( tmp_32, ptr32[ silk_SMULBB( j, M ) ], x_Q16[ j ] );
         }
         x_Q16[ i ] = silk_SUB32( b[ i ], tmp_32 );
     }
 }