Fix NEON optimizations buffer read overrun
[opus.git] / silk / encode_indices.c
index 6d8e82a..4bcbc33 100644 (file)
@@ -1,28 +1,28 @@
 /***********************************************************************
 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
 Redistribution and use in source and binary forms, with or without
-modification, (subject to the limitations in the disclaimer below)
-are permitted provided that the following conditions are met:
+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 Skype Limited, nor the names of specific
-contributors, may be used to endorse or promote products derived from
-this software without specific prior written permission.
-NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
-BY THIS LICENSE. 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.
+- 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
@@ -33,28 +33,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* Encode side-information parameters to payload */
 void silk_encode_indices(
-    silk_encoder_state          *psEncC,            /* I/O  Encoder state                               */
-    ec_enc                      *psRangeEnc,        /* I/O  Compressor data structure                   */
-    opus_int                     FrameIndex,         /* I    Frame number                                */
-    opus_int                     encode_LBRR         /* I    Flag indicating LBRR data is being encoded  */
+    silk_encoder_state          *psEncC,                        /* I/O  Encoder state                               */
+    ec_enc                      *psRangeEnc,                    /* I/O  Compressor data structure                   */
+    opus_int                    FrameIndex,                     /* I    Frame number                                */
+    opus_int                    encode_LBRR,                    /* I    Flag indicating LBRR data is being encoded  */
+    opus_int                    condCoding                      /* I    The type of conditional coding to use       */
 )
 {
-    opus_int   i, k, condCoding, typeOffset;
+    opus_int   i, k, typeOffset;
     opus_int   encode_absolute_lagIndex, delta_lagIndex;
     opus_int16 ec_ix[ MAX_LPC_ORDER ];
     opus_uint8 pred_Q8[ MAX_LPC_ORDER ];
     const SideInfoIndices *psIndices;
-#if SAVE_ALL_INTERNAL_DATA
-    opus_int nBytes_lagIndex, nBytes_contourIndex, nBytes_LTP;
-    opus_int nBytes_after, nBytes_before;
-#endif
-
-    /* Use conditional coding if previous frame available */
-    if( FrameIndex > 0 && ( encode_LBRR == 0 || psEncC->LBRR_flags[ FrameIndex - 1 ] == 1 ) ) {
-        condCoding = 1;
-    } else {
-        condCoding = 0;
-    }
 
     if( encode_LBRR ) {
          psIndices = &psEncC->indices_LBRR[ FrameIndex ];
@@ -66,8 +56,8 @@ void silk_encode_indices(
     /* Encode signal type and quantizer offset */
     /*******************************************/
     typeOffset = 2 * psIndices->signalType + psIndices->quantOffsetType;
-    silk_assert( typeOffset >= 0 && typeOffset < 6 );
-    silk_assert( encode_LBRR == 0 || typeOffset >= 2 );
+    celt_assert( typeOffset >= 0 && typeOffset < 6 );
+    celt_assert( encode_LBRR == 0 || typeOffset >= 2 );
     if( encode_LBRR || typeOffset >= 2 ) {
         ec_enc_icdf( psRangeEnc, typeOffset - 2, silk_type_offset_VAD_iCDF, 8 );
     } else {
@@ -77,11 +67,8 @@ void silk_encode_indices(
     /****************/
     /* Encode gains */
     /****************/
-#ifdef SAVE_ALL_INTERNAL_DATA
-    nBytes_before = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-#endif
     /* first subframe */
-    if( condCoding ) {
+    if( condCoding == CODE_CONDITIONALLY ) {
         /* conditional coding */
         silk_assert( psIndices->GainsIndices[ 0 ] >= 0 && psIndices->GainsIndices[ 0 ] < MAX_DELTA_GAIN_QUANT - MIN_DELTA_GAIN_QUANT + 1 );
         ec_enc_icdf( psRangeEnc, psIndices->GainsIndices[ 0 ], silk_delta_gain_iCDF, 8 );
@@ -98,21 +85,12 @@ void silk_encode_indices(
         ec_enc_icdf( psRangeEnc, psIndices->GainsIndices[ i ], silk_delta_gain_iCDF, 8 );
     }
 
-#ifdef SAVE_ALL_INTERNAL_DATA
-    nBytes_after = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-    nBytes_after -= nBytes_before; /* bytes just added*/
-    DEBUG_STORE_DATA( nBytes_gains.dat, &nBytes_after, sizeof( opus_int ) );
-#endif
-
     /****************/
     /* Encode NLSFs */
     /****************/
-#ifdef SAVE_ALL_INTERNAL_DATA
-    nBytes_before = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-#endif
     ec_enc_icdf( psRangeEnc, psIndices->NLSFIndices[ 0 ], &psEncC->psNLSF_CB->CB1_iCDF[ ( psIndices->signalType >> 1 ) * psEncC->psNLSF_CB->nVectors ], 8 );
     silk_NLSF_unpack( ec_ix, pred_Q8, psEncC->psNLSF_CB, psIndices->NLSFIndices[ 0 ] );
-    silk_assert( psEncC->psNLSF_CB->order == psEncC->predictLPCOrder );
+    celt_assert( psEncC->psNLSF_CB->order == psEncC->predictLPCOrder );
     for( i = 0; i < psEncC->psNLSF_CB->order; i++ ) {
         if( psIndices->NLSFIndices[ i+1 ] >= NLSF_QUANT_MAX_AMPLITUDE ) {
             ec_enc_icdf( psRangeEnc, 2 * NLSF_QUANT_MAX_AMPLITUDE, &psEncC->psNLSF_CB->ec_iCDF[ ec_ix[ i ] ], 8 );
@@ -131,24 +109,14 @@ void silk_encode_indices(
         ec_enc_icdf( psRangeEnc, psIndices->NLSFInterpCoef_Q2, silk_NLSF_interpolation_factor_iCDF, 8 );
     }
 
-#ifdef SAVE_ALL_INTERNAL_DATA
-    DEBUG_STORE_DATA( lsf_interpol.dat, &psIndices->NLSFInterpCoef_Q2, sizeof(int) );
-    nBytes_after = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-    nBytes_after -= nBytes_before; /* bytes just added*/
-    DEBUG_STORE_DATA( nBytes_LSF.dat, &nBytes_after, sizeof( opus_int ) );
-#endif
-
     if( psIndices->signalType == TYPE_VOICED )
     {
         /*********************/
         /* Encode pitch lags */
         /*********************/
-#ifdef SAVE_ALL_INTERNAL_DATA
-        nBytes_before = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-#endif
         /* lag index */
         encode_absolute_lagIndex = 1;
-        if( condCoding && psEncC->ec_prevSignalType == TYPE_VOICED ) {
+        if( condCoding == CODE_CONDITIONALLY && psEncC->ec_prevSignalType == TYPE_VOICED ) {
             /* Delta Encoding */
             delta_lagIndex = psIndices->lagIndex - psEncC->ec_prevLagIndex;
             if( delta_lagIndex < -8 || delta_lagIndex > 11 ) {
@@ -172,14 +140,6 @@ void silk_encode_indices(
         }
         psEncC->ec_prevLagIndex = psIndices->lagIndex;
 
-#ifdef SAVE_ALL_INTERNAL_DATA
-        nBytes_after = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-        nBytes_lagIndex = nBytes_after - nBytes_before; /* bytes just added*/
-#endif
-
-#ifdef SAVE_ALL_INTERNAL_DATA
-        nBytes_before = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-#endif
         /* Countour index */
         silk_assert(   psIndices->contourIndex  >= 0 );
         silk_assert( ( psIndices->contourIndex < 34 && psEncC->fs_kHz  > 8 && psEncC->nb_subfr == 4 ) ||
@@ -187,18 +147,10 @@ void silk_encode_indices(
                     ( psIndices->contourIndex < 12 && psEncC->fs_kHz  > 8 && psEncC->nb_subfr == 2 ) ||
                     ( psIndices->contourIndex <  3 && psEncC->fs_kHz == 8 && psEncC->nb_subfr == 2 ) );
         ec_enc_icdf( psRangeEnc, psIndices->contourIndex, psEncC->pitch_contour_iCDF, 8 );
-#ifdef SAVE_ALL_INTERNAL_DATA
-        nBytes_after = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-        nBytes_contourIndex = nBytes_after - nBytes_before; /* bytes just added*/
-#endif
 
         /********************/
         /* Encode LTP gains */
         /********************/
-#ifdef SAVE_ALL_INTERNAL_DATA
-        nBytes_before = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-#endif
-
         /* PERIndex value */
         silk_assert( psIndices->PERIndex >= 0 && psIndices->PERIndex < 3 );
         ec_enc_icdf( psRangeEnc, psIndices->PERIndex, silk_LTP_per_index_iCDF, 8 );
@@ -212,35 +164,15 @@ void silk_encode_indices(
         /**********************/
         /* Encode LTP scaling */
         /**********************/
-        if( !condCoding ) {
+        if( condCoding == CODE_INDEPENDENTLY ) {
             silk_assert( psIndices->LTP_scaleIndex >= 0 && psIndices->LTP_scaleIndex < 3 );
             ec_enc_icdf( psRangeEnc, psIndices->LTP_scaleIndex, silk_LTPscale_iCDF, 8 );
         }
         silk_assert( !condCoding || psIndices->LTP_scaleIndex == 0 );
-
-#ifdef SAVE_ALL_INTERNAL_DATA
-        nBytes_after = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-        nBytes_LTP = nBytes_after - nBytes_before; /* bytes just added*/
-#endif
-    }
-#ifdef SAVE_ALL_INTERNAL_DATA
-    else {
-        /* Unvoiced speech*/
-        nBytes_lagIndex     = 0;
-        nBytes_contourIndex = 0;
-        nBytes_LTP          = 0;
     }
-    DEBUG_STORE_DATA( nBytes_lagIndex.dat,      &nBytes_lagIndex,       sizeof( opus_int ) );
-    DEBUG_STORE_DATA( nBytes_contourIndex.dat,  &nBytes_contourIndex,   sizeof( opus_int ) );
-    DEBUG_STORE_DATA( nBytes_LTP.dat,           &nBytes_LTP,            sizeof( opus_int ) );
-#endif
 
     psEncC->ec_prevSignalType = psIndices->signalType;
 
-#ifdef SAVE_ALL_INTERNAL_DATA
-    nBytes_before = silk_RSHIFT( ec_tell( psRangeEnc ) + 7, 3 );
-#endif
-
     /***************/
     /* Encode seed */
     /***************/