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

webrtc/tools/agc/activity_metric.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 43 matching lines @@
 
 // Add some dither to quiet frames. This avoids the ExtractFeatures skip a
 // silence frame. Otherwise true VAD would drift with respect to the audio.
 // We only consider mono inputs.
 static void DitherSilence(AudioFrame* frame) {
   ASSERT_EQ(1, frame->num_channels_);
   const double kRmsSilence = 5;
   const double sum_squared_silence = kRmsSilence * kRmsSilence *
       frame->samples_per_channel_;
   double sum_squared = 0;
-  for (int n = 0; n < frame->samples_per_channel_; n++)
+  for (size_t n = 0; n < frame->samples_per_channel_; n++)
     sum_squared += frame->data_[n] * frame->data_[n];
   if (sum_squared <= sum_squared_silence) {
-    for (int n = 0; n < frame->samples_per_channel_; n++)
+    for (size_t n = 0; n < frame->samples_per_channel_; n++)
       frame->data_[n] = (rand() & 0xF) - 8;
   }
 }
 
 class AgcStat {
  public:
   AgcStat()
       : video_index_(0),
         activity_threshold_(kDefaultActivityThreshold),
         audio_content_(Histogram::Create(kAgcAnalWindowSamples)),
         audio_processing_(new VadAudioProc()),
         vad_(new PitchBasedVad()),
         standalone_vad_(StandaloneVad::Create()),
         audio_content_fid_(NULL) {
-    for (int n = 0; n < kMaxNumFrames; n++)
+    for (size_t n = 0; n < kMaxNumFrames; n++)
       video_vad_[n] = 0.5;
   }
 
   ~AgcStat() {
     if (audio_content_fid_ != NULL) {
       fclose(audio_content_fid_);
     }
   }
 
   void set_audio_content_file(FILE* audio_content_fid) {
@@ skipping 16 matching lines @@
                                 frame.samples_per_channel_);
     }
     if (features.num_frames > 0) {
       double p[kMaxNumFrames] = {0.5, 0.5, 0.5, 0.5};
       if (FLAGS_standalone_vad) {
         standalone_vad_->GetActivity(p, kMaxNumFrames);
       }
       // TODO(turajs) combining and limiting are used in the source files as
       // well they can be moved to utility.
       // Combine Video and stand-alone VAD.
-      for (int n = 0; n < features.num_frames; n++) {
+      for (size_t n = 0; n < features.num_frames; n++) {
         double p_active = p[n] * video_vad_[n];
         double p_passive = (1 - p[n]) * (1 - video_vad_[n]);
         p[n]  = p_active / (p_active + p_passive);
         // Limit probabilities.
         p[n] = std::min(std::max(p[n], 0.01), 0.99);
       }
       if (vad_->VoicingProbability(features, p) < 0)
         return -1;
-      for (int n = 0; n < features.num_frames; n++) {
+      for (size_t n = 0; n < features.num_frames; n++) {
         audio_content_->Update(features.rms[n], p[n]);
         double ac = audio_content_->AudioContent();
         if (audio_content_fid_ != NULL) {
           fwrite(&ac, sizeof(ac), 1, audio_content_fid_);
         }
         if (ac > kAgcAnalWindowSamples * activity_threshold_) {
           combined_vad[n] = 1;
         } else {
           combined_vad[n] = 0;
         }
       }
       video_index_ = 0;
     }
-    return features.num_frames;
+    return static_cast<int>(features.num_frames);
   }
 
   void Reset() {
     audio_content_->Reset();
   }
 
   void SetActivityThreshold(double activity_threshold) {
     activity_threshold_ = activity_threshold;
   }
 
@@ skipping 86 matching lines @@
   double p_video = 0.5;
   int total_active = 0;
   int total_passive = 0;
   int total_false_positive = 0;
   int total_missed_detection = 0;
   int onset_adaptation = 0;
   int num_onsets = 0;
   bool onset = false;
   uint8_t previous_true_vad = 0;
   int num_not_adapted = 0;
-  int true_vad_index = 0;
+  size_t true_vad_index = 0;
   bool in_false_positive_region = false;
   int total_false_positive_duration = 0;
   bool video_adapted = false;
   while (kSamplesToRead == fread(frame.data_, sizeof(int16_t),
                                  kSamplesToRead, pcm_fid)) {
     assert(true_vad_index < kMaxNumFrames);
     ASSERT_EQ(1u, fread(&true_vad[true_vad_index], sizeof(*true_vad), 1,
                         true_vad_fid))
         << "Size mismatch between True-VAD and the PCM file.\n";
     if (video_vad_fid != NULL) {
@@ skipping 25 matching lines @@
       agc_stat.Reset();
     }
     true_vad_index++;
 
     DitherSilence(&frame);
 
     ret_val = agc_stat.AddAudio(frame, p_video, agc_vad);
     ASSERT_GE(ret_val, 0);
 
     if (ret_val > 0) {
-      ASSERT_EQ(true_vad_index, ret_val);
+      ASSERT_EQ(true_vad_index, static_cast<size_t>(ret_val));
       for (int n = 0; n < ret_val; n++) {
         if (true_vad[n] == 1) {
           total_active++;
           if (previous_true_vad == 0) {
             num_onsets++;
             onset = true;
           }
           if (agc_vad[n] == 0) {
             total_missed_detection++;
             if (onset)
@@ skipping 69 matching lines @@
       " one probability per frame.\n"
       "\nUsage:\n\n"
       "activity_metric input_pcm [options]\n"
       "where 'input_pcm' is the input audio sampled at 16 kHz in 16 bits "
       "format.\n\n";
   google::SetUsageMessage(kUsage);
   google::ParseCommandLineFlags(&argc, &argv, true);
   webrtc::void_main(argc, argv);
   return 0;
 }