Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/codecs/isac/main/test/SwitchingSampRate/SwitchingSampRate.cc

 /*
  *  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 33 matching lines @@
   int maxBn = 56000;
 
   int bnWB = 32000;
   int bnSWB = 56000;
 
   strcpy(outFileName[0], "switchSampRate_out1.pcm");
   strcpy(outFileName[1], "switchSampRate_out2.pcm");
 
   short clientCntr;
 
-  unsigned int lenEncodedInBytes[MAX_NUM_CLIENTS];
+  size_t lenEncodedInBytes[MAX_NUM_CLIENTS];
   unsigned int lenAudioIn10ms[MAX_NUM_CLIENTS];
-  unsigned int lenEncodedInBytesTmp[MAX_NUM_CLIENTS];
+  size_t lenEncodedInBytesTmp[MAX_NUM_CLIENTS];
   unsigned int lenAudioIn10msTmp[MAX_NUM_CLIENTS];
   BottleNeckModel* packetData[MAX_NUM_CLIENTS];
 
   char versionNumber[100];
   short samplesIn10ms[MAX_NUM_CLIENTS];
   int bottleneck[MAX_NUM_CLIENTS];
 
   printf("\n\n");
   printf("____________________________________________\n\n");
   WebRtcIsac_version(versionNumber);
@@ skipping 115 matching lines @@
                             bottleneck[clientCntr], 30) < 0)
       {
         printf("Could not setup bottleneck and frame-size for client %d\n",
                clientCntr + 1);
         return -1;
       }
     }
   }
 
 
-  short streamLen;
+  size_t streamLen;
   short numSamplesRead;
-  int lenDecodedAudio;
+  size_t lenDecodedAudio;
   short senderIdx;
   short receiverIdx;
 
   printf("\n");
   short num10ms[MAX_NUM_CLIENTS];
   memset(num10ms, 0, sizeof(short)*MAX_NUM_CLIENTS);
   FILE* arrivalTimeFile1 = fopen("arrivalTime1.dat", "wb");
   FILE* arrivalTimeFile2 = fopen("arrivalTime2.dat", "wb");
   short numPrint[MAX_NUM_CLIENTS];
   memset(numPrint, 0, sizeof(short) * MAX_NUM_CLIENTS);
@@ skipping 70 matching lines @@
       //if(num10ms[senderIdx] > 6)
       //{
       //    printf("Client %d has got more than 60 ms audio and encoded no packet.\n",
       //        senderIdx);
       //    return -1;
       //}
 
       // Encode
 
 
-      streamLen = WebRtcIsac_Encode(codecInstance[senderIdx],
-                                    audioBuff10ms,
-                                    (uint8_t*)bitStream);
+      int streamLen_int = WebRtcIsac_Encode(codecInstance[senderIdx],
+                                            audioBuff10ms,
+                                            (uint8_t*)bitStream);
       int16_t ggg;
-      if (streamLen > 0) {
+      if (streamLen_int > 0) {
         if ((WebRtcIsac_ReadFrameLen(
                 codecInstance[receiverIdx],
                 reinterpret_cast<const uint8_t*>(bitStream),
                 &ggg)) < 0)
           printf("ERROR\n");
       }
 
       // Sanity check
-      if(streamLen < 0)
+      if(streamLen_int < 0)
       {
         printf(" Encoder error in client %d \n", senderIdx + 1);
         return -1;
       }
+      streamLen = static_cast<size_t>(streamLen_int);
 
 
       if(streamLen > 0)
       {
         // Packet generated; model sending through a channel, do bandwidth
         // estimation at the receiver and decode.
         lenEncodedInBytes[senderIdx] += streamLen;
         lenAudioIn10ms[senderIdx] += (unsigned int)num10ms[senderIdx];
         lenEncodedInBytesTmp[senderIdx] += streamLen;
         lenAudioIn10msTmp[senderIdx] += (unsigned int)num10ms[senderIdx];
@@ skipping 103 matching lines @@
                 reinterpret_cast<const uint8_t*>(bitStream),
                 streamLen,
                 packetData[senderIdx]->rtp_number,
                 packetData[senderIdx]->sample_count,
                 packetData[senderIdx]->arrival_time) < 0) {
           printf(" BWE Error at client %d \n", receiverIdx + 1);
           return -1;
         }
         /**/
         // Decode
-        lenDecodedAudio = WebRtcIsac_Decode(
+        int lenDecodedAudio_int = WebRtcIsac_Decode(
             codecInstance[receiverIdx],
             reinterpret_cast<const uint8_t*>(bitStream),
             streamLen,
             audioBuff60ms,
             speechType);
-        if(lenDecodedAudio < 0)
+        if(lenDecodedAudio_int < 0)
         {
           printf(" Decoder error in client %d \n", receiverIdx + 1);
           return -1;
         }
-
+        lenDecodedAudio = static_cast<size_t>(lenDecodedAudio_int);
 
         if(encoderSampRate[senderIdx] == 16000)
         {
           WebRtcSpl_UpsampleBy2(audioBuff60ms, lenDecodedAudio, resampledAudio60ms,
                                 resamplerState[receiverIdx]);
           if (fwrite(resampledAudio60ms, sizeof(short), lenDecodedAudio << 1,
                      outFile[receiverIdx]) !=
-              static_cast<size_t>(lenDecodedAudio << 1)) {
+              lenDecodedAudio << 1) {
             return -1;
           }
         }
         else
         {
           if (fwrite(audioBuff60ms, sizeof(short), lenDecodedAudio,
                      outFile[receiverIdx]) !=
-              static_cast<size_t>(lenDecodedAudio)) {
+              lenDecodedAudio) {
             return -1;
           }
         }
         num10ms[senderIdx] = 0;
       }
       //}
       //}
     }
   }
 }