Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/codecs/isac/main/source/isac.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 489 matching lines @@
  */
 int WebRtcIsac_Encode(ISACStruct* ISAC_main_inst,
                       const int16_t* speechIn,
                       uint8_t* encoded) {
   float inFrame[FRAMESAMPLES_10ms];
   int16_t speechInLB[FRAMESAMPLES_10ms];
   int16_t speechInUB[FRAMESAMPLES_10ms];
   int streamLenLB = 0;
   int streamLenUB = 0;
   int streamLen = 0;
-  int16_t k = 0;
+  size_t k = 0;
   uint8_t garbageLen = 0;
   int32_t bottleneck = 0;
   int16_t bottleneckIdx = 0;
   int16_t jitterInfo = 0;
 
   ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
   ISACLBStruct* instLB = &(instISAC->instLB);
   ISACUBStruct* instUB = &(instISAC->instUB);
   const int16_t* speech_in_ptr = speechIn;
   int16_t resampled_buff[FRAMESAMPLES_10ms * 2];
 
   /* Check if encoder initiated. */
   if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
       BIT_MASK_ENC_INIT) {
     instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
     return -1;
   }
 
   if (instISAC->in_sample_rate_hz == 48000) {
     /* Samples in 10 ms @ 48 kHz. */
-    const int kNumInputSamples = FRAMESAMPLES_10ms * 3;
+    const size_t kNumInputSamples = FRAMESAMPLES_10ms * 3;
     /* Samples 10 ms @ 32 kHz. */
-    const int kNumOutputSamples = FRAMESAMPLES_10ms * 2;
+    const size_t kNumOutputSamples = FRAMESAMPLES_10ms * 2;
     /* Resampler divide the input into blocks of 3 samples, i.e.
      * kNumInputSamples / 3. */
-    const int kNumResamplerBlocks = FRAMESAMPLES_10ms;
+    const size_t kNumResamplerBlocks = FRAMESAMPLES_10ms;
     int32_t buffer32[FRAMESAMPLES_10ms * 3 + SIZE_RESAMPLER_STATE];
 
     /* Restore last samples from the past to the beginning of the buffer
      * and store the last samples of current frame for the next resampling. */
     for (k = 0; k < SIZE_RESAMPLER_STATE; k++) {
       buffer32[k] = instISAC->state_in_resampler[k];
       instISAC->state_in_resampler[k] = speechIn[kNumInputSamples -
                                                  SIZE_RESAMPLER_STATE + k];
     }
     for (k = 0; k < kNumInputSamples; k++) {
@@ skipping 452 matching lines @@
  *        - packet_size       : size of the packet.
  *        - rtp_seq_number    : the RTP number of the packet.
  *        - arr_ts            : the arrival time of the packet (from NetEq)
  *                              in samples.
  *
  * Return value               :  0 - Ok
  *                              -1 - Error
  */
 int16_t WebRtcIsac_UpdateBwEstimate(ISACStruct* ISAC_main_inst,
                                     const uint8_t* encoded,
-                                    int32_t packet_size,
+                                    size_t packet_size,
                                     uint16_t rtp_seq_number,
                                     uint32_t send_ts,
                                     uint32_t arr_ts) {
   ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
   Bitstr streamdata;
 #ifndef WEBRTC_ARCH_BIG_ENDIAN
   int k;
 #endif
   int16_t err;
 
@@ skipping 29 matching lines @@
   if (err < 0) {
     /* Return error code if something went wrong. */
     instISAC->errorCode = -err;
     return -1;
   }
   return 0;
 }
 
 static int Decode(ISACStruct* ISAC_main_inst,
                   const uint8_t* encoded,
-                  int16_t lenEncodedBytes,
+                  size_t lenEncodedBytes,
                   int16_t* decoded,
                   int16_t* speechType,
                   int16_t isRCUPayload) {
   /* Number of samples (480 or 960), output from decoder
      that were actually used in the encoder/decoder
      (determined on the fly). */
   int16_t numSamplesLB;
   int16_t numSamplesUB;
   int16_t speechIdx;
   float outFrame[MAX_FRAMESAMPLES];
   int16_t outFrameLB[MAX_FRAMESAMPLES];
   int16_t outFrameUB[MAX_FRAMESAMPLES];
-  int numDecodedBytesLB;
+  int numDecodedBytesLBint;
+  size_t numDecodedBytesLB;
   int numDecodedBytesUB;
-  int16_t lenEncodedLBBytes;
+  size_t lenEncodedLBBytes;
   int16_t validChecksum = 1;
   int16_t k;
   uint16_t numLayer;
-  int16_t totSizeBytes;
+  size_t totSizeBytes;
   int16_t err;
 
   ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
   ISACUBDecStruct* decInstUB = &(instISAC->instUB.ISACdecUB_obj);
   ISACLBDecStruct* decInstLB = &(instISAC->instLB.ISACdecLB_obj);
 
   /* Check if decoder initiated. */
   if ((instISAC->initFlag & BIT_MASK_DEC_INIT) !=
       BIT_MASK_DEC_INIT) {
     instISAC->errorCode = ISAC_DECODER_NOT_INITIATED;
     return -1;
   }
 
-  if (lenEncodedBytes <= 0) {
+  if (lenEncodedBytes == 0) {
     /* return error code if the packet length is null. */
     instISAC->errorCode = ISAC_EMPTY_PACKET;
     return -1;
   }
 
   /* The size of the encoded lower-band is bounded by
    * STREAM_SIZE_MAX. If a payload with the size larger than STREAM_SIZE_MAX
    * is received, it is not considered erroneous. */
   lenEncodedLBBytes = (lenEncodedBytes > STREAM_SIZE_MAX) ?
       STREAM_SIZE_MAX : lenEncodedBytes;
 
   /* Copy to lower-band bit-stream structure. */
   memcpy(instISAC->instLB.ISACdecLB_obj.bitstr_obj.stream, encoded,
          lenEncodedLBBytes);
 
   /* We need to initialize numSamplesLB to something; otherwise, in the test
      for whether we should return -1 below, the compiler might generate code
      that fools Memcheck (Valgrind) into thinking that the control flow depends
      on the uninitialized value in numSamplesLB (since WebRtcIsac_DecodeLb will
      not fill it in if it fails and returns -1). */
   numSamplesLB = 0;
 
   /* Regardless of that the current codec is setup to work in
    * wideband or super-wideband, the decoding of the lower-band
    * has to be performed. */
-  numDecodedBytesLB = WebRtcIsac_DecodeLb(&instISAC->transform_tables,
-                                          outFrame, decInstLB,
-                                          &numSamplesLB, isRCUPayload);
-
-  if ((numDecodedBytesLB < 0) || (numDecodedBytesLB > lenEncodedLBBytes) ||
+  numDecodedBytesLBint = WebRtcIsac_DecodeLb(&instISAC->transform_tables,
+                                             outFrame, decInstLB,
+                                             &numSamplesLB, isRCUPayload);
+  numDecodedBytesLB = (size_t)numDecodedBytesLBint;
+  if ((numDecodedBytesLBint < 0) ||
+      (numDecodedBytesLB > lenEncodedLBBytes) ||
       (numSamplesLB > MAX_FRAMESAMPLES)) {
     instISAC->errorCode = ISAC_LENGTH_MISMATCH;
     return -1;
   }
 
   /* Error Check, we accept multi-layer bit-stream This will limit number
    * of iterations of the while loop. Even without this the number
    * of iterations is limited. */
   numLayer = 1;
   totSizeBytes = numDecodedBytesLB;
@@ skipping 222 matching lines @@
  *
  * Output:
  *        - decoded           : The decoded vector
  *
  * Return value               : >0 - number of samples in decoded vector
  *                              -1 - Error
  */
 
 int WebRtcIsac_Decode(ISACStruct* ISAC_main_inst,
                       const uint8_t* encoded,
-                      int16_t lenEncodedBytes,
+                      size_t lenEncodedBytes,
                       int16_t* decoded,
                       int16_t* speechType) {
   int16_t isRCUPayload = 0;
   return Decode(ISAC_main_inst, encoded, lenEncodedBytes, decoded,
                 speechType, isRCUPayload);
 }
 
 /****************************************************************************
  * WebRtcIsac_DecodeRcu(...)
  *
@@ skipping 11 matching lines @@
  *      - decoded            : The decoded vector
  *
  * Return value              : >0 - number of samples in decoded vector
  *                             -1 - Error
  */
 
 
 
 int WebRtcIsac_DecodeRcu(ISACStruct* ISAC_main_inst,
                          const uint8_t* encoded,
-                         int16_t lenEncodedBytes,
+                         size_t lenEncodedBytes,
                          int16_t* decoded,
                          int16_t* speechType) {
   int16_t isRCUPayload = 1;
   return Decode(ISAC_main_inst, encoded, lenEncodedBytes, decoded,
                 speechType, isRCUPayload);
 }
 
 
 /****************************************************************************
  * WebRtcIsac_DecodePlc(...)
  *
  * This function conducts PLC for ISAC frame(s). Output speech length
  * will be a multiple of 480 samples: 480 or 960 samples,
  * depending on the  frameSize (30 or 60 ms).
  *
  * Input:
  *        - ISAC_main_inst    : ISAC instance.
  *        - noOfLostFrames    : Number of PLC frames to produce
  *
  * Output:
  *        - decoded           : The decoded vector
  *
- * Return value               : >0 - number of samples in decoded PLC vector
- *                              -1 - Error
+ * Return value               : Number of samples in decoded PLC vector
  */
-int16_t WebRtcIsac_DecodePlc(ISACStruct* ISAC_main_inst,
-                             int16_t* decoded,
-                             int16_t noOfLostFrames) {
-  int16_t numSamples = 0;
+size_t WebRtcIsac_DecodePlc(ISACStruct* ISAC_main_inst,
+                            int16_t* decoded,
+                            size_t noOfLostFrames) {
+  size_t numSamples = 0;
   ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
 
   /* Limit number of frames to two = 60 millisecond.
    * Otherwise we exceed data vectors. */
   if (noOfLostFrames > 2) {
     noOfLostFrames = 2;
   }
 
   /* Get the number of samples per frame */
   switch (instISAC->decoderSamplingRateKHz) {
@@ skipping 972 matching lines @@
 }
 
 void WebRtcIsac_SetEncSampRateInDecoder(ISACStruct* inst,
                                         int sample_rate_hz) {
   ISACMainStruct* instISAC = (ISACMainStruct*)inst;
   assert(instISAC->initFlag & BIT_MASK_DEC_INIT);
   assert(!(instISAC->initFlag & BIT_MASK_ENC_INIT));
   assert(sample_rate_hz == 16000 || sample_rate_hz == 32000);
   instISAC->encoderSamplingRateKHz = sample_rate_hz / 1000;
 }