Update a ton of audio code to use size_t more correctly and in general reduce

webrtc/modules/audio_coding/codecs/isac/fix/test/kenny.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 32 matching lines @@
 
 /* Struct for bottleneck model */
 typedef struct {
   uint32_t send_time;            /* samples */
   uint32_t arrival_time;         /* samples */
   uint32_t sample_count;         /* samples */
   uint16_t rtp_number;
 } BottleNeckModel;
 
 void get_arrival_time(int current_framesamples,   /* samples */
-                      int packet_size,            /* bytes */
+                      size_t packet_size,         /* bytes */
                       int bottleneck,             /* excluding headers; bits/s */
                       BottleNeckModel *BN_data)
 {
   const int HeaderSize = 35;
   int HeaderRate;
 
   HeaderRate = HeaderSize * 8 * FS / current_framesamples;     /* bits/s */
 
   /* everything in samples */
   BN_data->sample_count = BN_data->sample_count + current_framesamples;
@@ skipping 28 matching lines @@
   BN_data->rtp_number++;
 }
 
 int main(int argc, char* argv[])
 {
 
   char inname[100], outname[100],  outbitsname[100], bottleneck_file[100];
   FILE *inp, *outp, *f_bn, *outbits;
   int endfile;
 
-  int i, errtype, h = 0, k, packetLossPercent = 0;
+  size_t i;
+  int errtype, h = 0, k, packetLossPercent = 0;
   int16_t CodingMode;
   int16_t bottleneck;
   int framesize = 30;           /* ms */
   int cur_framesmpls, err = 0, lostPackets = 0;
 
   /* Runtime statistics */
   double starttime, runtime, length_file;
 
-  int16_t stream_len = 0;
+  int stream_len_int = 0;
+  size_t stream_len = 0;
   int16_t framecnt;
   int declen = 0;
   int16_t shortdata[FRAMESAMPLES_10ms];
   int16_t decoded[MAX_FRAMESAMPLES];
   uint16_t streamdata[500];
   int16_t speechType[1];
-  int16_t prevFrameSize = 1;
+  size_t prevFrameSize = 1;
   int16_t rateBPS = 0;
   int16_t fixedFL = 0;
   int16_t payloadSize = 0;
   int32_t payloadRate = 0;
   int setControlBWE = 0;
   int readLoss;
   FILE  *plFile = NULL;
 
   char version_number[20];
   char tmpBit[5] = ".bit";
@@ skipping 97 matching lines @@
   }
 
   /* Print version number */
   WebRtcIsacfix_version(version_number);
   printf("iSAC version %s \n\n", version_number);
 
   /* Loop over all command line arguments */
   CodingMode = 0;
   testNum = 0;
   testCE = 0;
-  for (i = 1; i + 2 < argc; i++) {
+  for (i = 1; i + 2 < static_cast<size_t>(argc); i++) {
     /* Instantaneous mode */
     if (!strcmp ("-I", argv[i])) {
       printf("\nInstantaneous BottleNeck\n");
       CodingMode = 1;
       i++;
     }
 
     /* Set (initial) bottleneck value */
     if (!strcmp ("-INITRATE", argv[i])) {
       rateBPS = atoi(argv[i + 1]);
@@ skipping 311 matching lines @@
       if (testNum == 7) {
         srand(time(NULL));
       }
 
       /* iSAC encoding */
       if (!(testNum == 3 && framecnt == 0)) {
         if (nbTest != 1) {
           short bwe;
 
           /* Encode */
-          stream_len = WebRtcIsacfix_Encode(ISAC_main_inst,
-                                            shortdata,
-                                            (uint8_t*)streamdata);
+          stream_len_int = WebRtcIsacfix_Encode(ISAC_main_inst,
+                                                shortdata,
+                                                (uint8_t*)streamdata);
 
           /* If packet is ready, and CE testing, call the different API
              functions from the internal API. */
-          if (stream_len>0) {
+          if (stream_len_int>0) {
             if (testCE == 1) {
               err = WebRtcIsacfix_ReadBwIndex(
                   reinterpret_cast<const uint8_t*>(streamdata),
-                  stream_len,
+                  static_cast<size_t>(stream_len_int),
                   &bwe);
-              stream_len = WebRtcIsacfix_GetNewBitStream(
+              stream_len_int = WebRtcIsacfix_GetNewBitStream(
                   ISAC_main_inst,
                   bwe,
                   scale,
                   reinterpret_cast<uint8_t*>(streamdata));
             } else if (testCE == 2) {
               /* transcode function not supported */
             } else if (testCE == 3) {
               /* Only for Function testing. The functions should normally
                  not be used in this way                                      */
 
               err = WebRtcIsacfix_GetDownLinkBwIndex(ISAC_main_inst, &bwe);
               /* Error Check */
               if (err < 0) {
                 errtype=WebRtcIsacfix_GetErrorCode(ISAC_main_inst);
                 printf("\nError in getSendBWE: %d.\n", errtype);
               }
 
               err = WebRtcIsacfix_UpdateUplinkBw(ISAC_main_inst, bwe);
               /* Error Check */
               if (err < 0) {
                 errtype=WebRtcIsacfix_GetErrorCode(ISAC_main_inst);
                 printf("\nError in setBWE: %d.\n", errtype);
               }
 
             }
           }
         } else {
 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
-          stream_len = WebRtcIsacfix_EncodeNb(ISAC_main_inst,
-                                              shortdata,
-                                              streamdata);
+          stream_len_int = WebRtcIsacfix_EncodeNb(ISAC_main_inst,
+                                                  shortdata,
+                                                  streamdata);
 #else
-          stream_len = -1;
+          stream_len_int = -1;
 #endif
         }
       }
       else
       {
         break;
       }
 
-      if (stream_len < 0 || err < 0) {
+      if (stream_len_int < 0 || err < 0) {
         /* exit if returned with error */
         errtype=WebRtcIsacfix_GetErrorCode(ISAC_main_inst);
         printf("\nError in encoder: %d.\n", errtype);
       } else {
+        stream_len = static_cast<size_t>(stream_len_int);
         if (fwrite(streamdata, sizeof(char), stream_len, outbits) !=
-            (size_t)stream_len) {
+            stream_len) {
           return -1;
         }
       }
 
       cur_framesmpls += FRAMESAMPLES_10ms;
 
       /* read next bottleneck rate */
       if (f_bn != NULL) {
         int aux_var;
         if (fscanf(f_bn, "%d", &aux_var) == EOF) {
@@ skipping 85 matching lines @@
         lostFrame = !lostFrame;
       } else {
         lostFrame = (rand()%100 < packetLossPercent);
       }
 
 
 
       /* iSAC decoding */
       if( lostFrame && framecnt >  0) {
         if (nbTest !=2) {
-          declen =
-              WebRtcIsacfix_DecodePlc(ISAC_main_inst, decoded, prevFrameSize);
+          declen = static_cast<int>(
+              WebRtcIsacfix_DecodePlc(ISAC_main_inst, decoded, prevFrameSize));
         } else {
 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
-          declen = WebRtcIsacfix_DecodePlcNb(
-              ISAC_main_inst, decoded, prevFrameSize);
+          declen = static_cast<int>(WebRtcIsacfix_DecodePlcNb(
+              ISAC_main_inst, decoded, prevFrameSize));
 #else
           declen = -1;
 #endif
         }
         lostPackets++;
       } else {
         if (nbTest !=2 ) {
-          short FL;
+          size_t FL;
           /* Call getFramelen, only used here for function test */
           err = WebRtcIsacfix_ReadFrameLen(
               reinterpret_cast<const uint8_t*>(streamdata), stream_len, &FL);
           declen = WebRtcIsacfix_Decode(
               ISAC_main_inst,
               reinterpret_cast<const uint8_t*>(streamdata),
               stream_len,
               decoded,
               speechType);
           /* Error check */
-          if (err < 0 || declen < 0 || FL != declen) {
+          if (err < 0 || declen < 0 || FL != static_cast<size_t>(declen)) {
             errtype=WebRtcIsacfix_GetErrorCode(ISAC_main_inst);
             printf("\nError in decode_B/or getFrameLen: %d.\n", errtype);
           }
-          prevFrameSize = declen/480;
+          prevFrameSize = static_cast<size_t>(declen/480);
 
         } else {
 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED
           declen = WebRtcIsacfix_DecodeNb( ISAC_main_inst, streamdata,
                                            stream_len, decoded, speechType );
 #else
           declen = -1;
 #endif
-          prevFrameSize = static_cast<int16_t>(declen / 240);
+          prevFrameSize = static_cast<size_t>(declen / 240);
         }
       }
 
       if (declen <= 0) {
         /* exit if returned with error */
         errtype=WebRtcIsacfix_GetErrorCode(ISAC_main_inst);
         printf("\nError in decoder: %d.\n", errtype);
       }
 
       /* Write decoded speech frame to file */
       if (fwrite(decoded, sizeof(int16_t),
                  declen, outp) != (size_t)declen) {
         return -1;
       }
       //   fprintf( ratefile, "%f \n", stream_len / ( ((double)declen)/
       // ((double)FS) ) * 8 );
     } else {
       lostPackets++;
     }
     framecnt++;
 
     totalsmpls += declen;
-    totalbits += 8 * stream_len;
+    totalbits += static_cast<int>(8 * stream_len);
 
     /* Error test number 10, garbage data */
     if (testNum == 10) {
       if ( (seedfile = fopen(SEED_FILE, "a+t") ) == NULL ) {
         printf( "Error: Could not open file %s\n", SEED_FILE);
       }
       else {
         fprintf(seedfile, "ok\n\n");
         fclose(seedfile);
       }
@@ skipping 23 matching lines @@
   fclose(inp);
   fclose(outp);
   fclose(outbits);
 
   if ( testCE == 1) {
     WebRtcIsacfix_FreeInternal(ISAC_main_inst);
   }
   WebRtcIsacfix_Free(ISAC_main_inst);
   return 0;
 }