iLBC: Handle a case of bad input data

webrtc/modules/audio_coding/codecs/ilbc/encode.c

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 11 matching lines @@
 #include "lpc_encode.h"
 #include "frame_classify.h"
 #include "state_search.h"
 #include "state_construct.h"
 #include "constants.h"
 #include "cb_search.h"
 #include "cb_construct.h"
 #include "index_conv_enc.h"
 #include "pack_bits.h"
 #include "hp_input.h"
+#include "webrtc/base/checks.h"
 
 #ifdef SPLIT_10MS
 #include "unpack_bits.h"
 #include "index_conv_dec.h"
 #endif
 #ifndef WEBRTC_ARCH_BIG_ENDIAN
 #include "swap_bytes.h"
 #endif
 
 /*----------------------------------------------------------------*
@@ skipping 157 matching lines @@
 
       /* encode subframes */
 
       WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index, iLBCbits_inst->gain_index,
                              &residual[start_pos+iLBCenc_inst->state_short_len],
                              mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL, diff,
                              &weightdenum[iLBCbits_inst->startIdx*(LPC_FILTERORDER+1)], 0);
 
       /* construct decoded vector */
 
-      WebRtcIlbcfix_CbConstruct(&decresidual[start_pos+iLBCenc_inst->state_short_len],
-                                iLBCbits_inst->cb_index, iLBCbits_inst->gain_index,
-                                mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL,
-                                diff
-                                );
+      RTC_CHECK(WebRtcIlbcfix_CbConstruct(
+          &decresidual[start_pos + iLBCenc_inst->state_short_len],
+          iLBCbits_inst->cb_index, iLBCbits_inst->gain_index,
+          mem + CB_MEML - ST_MEM_L_TBL, ST_MEM_L_TBL, diff));
 
     }
     else { /* put adaptive part in the beginning */
 
       /* create reversed vectors for prediction */
 
       WebRtcSpl_MemCpyReversedOrder(&reverseResidual[diff-1],
                                     &residual[(iLBCbits_inst->startIdx+1)*SUBL-STATE_LEN], diff);
 
       /* setup memory */
 
       meml_gotten = iLBCenc_inst->state_short_len;
       WebRtcSpl_MemCpyReversedOrder(&mem[CB_MEML-1], &decresidual[start_pos], meml_gotten);
       WebRtcSpl_MemSetW16(mem, 0, CB_MEML - iLBCenc_inst->state_short_len);
 
       /* encode subframes */
       WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index, iLBCbits_inst->gain_index,
                              reverseResidual, mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL, diff,
                              &weightdenum[(iLBCbits_inst->startIdx-1)*(LPC_FILTERORDER+1)],
                              0);
 
       /* construct decoded vector */
-
-      WebRtcIlbcfix_CbConstruct(reverseDecresidual,
-                                iLBCbits_inst->cb_index, iLBCbits_inst->gain_index,
-                                mem+CB_MEML-ST_MEM_L_TBL, ST_MEM_L_TBL,
-                                diff
-                                );
+      RTC_CHECK(WebRtcIlbcfix_CbConstruct(
+            reverseDecresidual, iLBCbits_inst->cb_index,
+            iLBCbits_inst->gain_index, mem + CB_MEML - ST_MEM_L_TBL,
+            ST_MEM_L_TBL, diff));
 
       /* get decoded residual from reversed vector */
 
       WebRtcSpl_MemCpyReversedOrder(&decresidual[start_pos-1], reverseDecresidual, diff);
     }
 
 #ifdef SPLIT_10MS
     iLBCenc_inst->start_pos = start_pos;
     iLBCenc_inst->diff = diff;
     iLBCenc_inst->section++;
@@ skipping 85 matching lines @@
       /* encode subframe */
 
       WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index+subcount*CB_NSTAGES,
                              iLBCbits_inst->gain_index+subcount*CB_NSTAGES,
                              &residual[(iLBCbits_inst->startIdx+1+subframe)*SUBL],
                              mem, MEM_LF_TBL, SUBL,
                              &weightdenum[(iLBCbits_inst->startIdx+1+subframe)*(LPC_FILTERORDER+1)],
                              subcount);
 
       /* construct decoded vector */
-
-      WebRtcIlbcfix_CbConstruct(&decresidual[(iLBCbits_inst->startIdx+1+subframe)*SUBL],
-                                iLBCbits_inst->cb_index+subcount*CB_NSTAGES,
-                                iLBCbits_inst->gain_index+subcount*CB_NSTAGES,
-                                mem, MEM_LF_TBL,
-                                SUBL
-                                );
+      RTC_CHECK(WebRtcIlbcfix_CbConstruct(
+            &decresidual[(iLBCbits_inst->startIdx + 1 + subframe) * SUBL],
+            iLBCbits_inst->cb_index + subcount * CB_NSTAGES,
+            iLBCbits_inst->gain_index + subcount * CB_NSTAGES, mem, MEM_LF_TBL,
+            SUBL));
 
       /* update memory */
 
       memmove(mem, mem + SUBL, (CB_MEML - SUBL) * sizeof(*mem));
       WEBRTC_SPL_MEMCPY_W16(mem+CB_MEML-SUBL,
                             &decresidual[(iLBCbits_inst->startIdx+1+subframe)*SUBL], SUBL);
 
       subcount++;
     }
   }
@@ skipping 79 matching lines @@
 
       /* encode subframe */
 
       WebRtcIlbcfix_CbSearch(iLBCenc_inst, iLBCbits_inst->cb_index+subcount*CB_NSTAGES,
                              iLBCbits_inst->gain_index+subcount*CB_NSTAGES, &reverseResidual[subframe*SUBL],
                              mem, MEM_LF_TBL, SUBL,
                              &weightdenum[(iLBCbits_inst->startIdx-2-subframe)*(LPC_FILTERORDER+1)],
                              subcount);
 
       /* construct decoded vector */
-
-      WebRtcIlbcfix_CbConstruct(&reverseDecresidual[subframe*SUBL],
-                                iLBCbits_inst->cb_index+subcount*CB_NSTAGES,
-                                iLBCbits_inst->gain_index+subcount*CB_NSTAGES,
-                                mem, MEM_LF_TBL, SUBL
-                                );
+      RTC_CHECK(WebRtcIlbcfix_CbConstruct(
+            &reverseDecresidual[subframe * SUBL],
+            iLBCbits_inst->cb_index + subcount * CB_NSTAGES,
+            iLBCbits_inst->gain_index + subcount * CB_NSTAGES, mem, MEM_LF_TBL,
+            SUBL));
 
       /* update memory */
       memmove(mem, mem + SUBL, (CB_MEML - SUBL) * sizeof(*mem));
       WEBRTC_SPL_MEMCPY_W16(mem+CB_MEML-SUBL,
                             &reverseDecresidual[subframe*SUBL], SUBL);
 
       subcount++;
 
     }
 
@@ skipping 40 matching lines @@
   }
   else
   {
     iLBCenc_inst->section++;
     WEBRTC_SPL_MEMCPY_W16 (weightdenumbuf, weightdenum,
                            SCRATCH_ENCODE_DATAVEC - SCRATCH_ENCODE_WEIGHTDENUM);
   }
 #endif
 
 }