Misc. small cleanups

webrtc/modules/audio_processing/test/audio_processing_unittest.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.
  */
 
 #include <math.h>
 #include <stdio.h>
 #include <algorithm>
 #include <limits>
 #include <queue>
 
+#include "webrtc/base/arraysize.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_audio/include/audio_util.h"
 #include "webrtc/common_audio/resampler/include/push_resampler.h"
 #include "webrtc/common_audio/resampler/push_sinc_resampler.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/beamformer/mock_nonlinear_beamformer.h"
 #include "webrtc/modules/audio_processing/common.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/audio_processing/test/protobuf_utils.h"
 #include "webrtc/modules/audio_processing/test/test_utils.h"
@@ skipping 16 matching lines @@
 // TODO(ekmeyerson): Switch to using StreamConfig and ProcessingConfig where
 // applicable.
 
 // TODO(bjornv): This is not feasible until the functionality has been
 // re-implemented; see comment at the bottom of this file. For now, the user has
 // to hard code the |write_ref_data| value.
 // When false, this will compare the output data with the results stored to
 // file. This is the typical case. When the file should be updated, it can
 // be set to true with the command-line switch --write_ref_data.
 bool write_ref_data = false;
-const int kChannels[] = {1, 2};
-const size_t kChannelsSize = sizeof(kChannels) / sizeof(*kChannels);
-
+const google::protobuf::int32 kChannels[] = {1, 2};

[hlundin-webrtc, 2016/01/07 10:57:06]

Why?

[hlundin-webrtc, 2016/01/07 11:00:06]

OK, I see why. Never mind.

 const int kSampleRates[] = {8000, 16000, 32000, 48000};
-const size_t kSampleRatesSize = sizeof(kSampleRates) / sizeof(*kSampleRates);
 
 #if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)
 // AECM doesn't support super-wb.
 const int kProcessSampleRates[] = {8000, 16000};
 #elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
 const int kProcessSampleRates[] = {8000, 16000, 32000, 48000};
 #endif
-const size_t kProcessSampleRatesSize = sizeof(kProcessSampleRates) /
-    sizeof(*kProcessSampleRates);
 
 enum StreamDirection { kForward = 0, kReverse };
 
 void ConvertToFloat(const int16_t* int_data, ChannelBuffer<float>* cb) {
   ChannelBuffer<int16_t> cb_int(cb->num_frames(),
                                 cb->num_channels());
   Deinterleave(int_data,
                cb->num_frames(),
                cb->num_channels(),
                cb_int.channels());
@@ skipping 13 matching lines @@
   switch (layout) {
     case AudioProcessing::kMono:
       return 1;
     case AudioProcessing::kMonoAndKeyboard:
     case AudioProcessing::kStereo:
       return 2;
     case AudioProcessing::kStereoAndKeyboard:
       return 3;
   }
   assert(false);
-  return -1;
+  return 0;
 }
 
 int TruncateToMultipleOf10(int value) {
   return (value / 10) * 10;
 }
 
 void MixStereoToMono(const float* stereo, float* mono,
-                     int samples_per_channel) {
-  for (int i = 0; i < samples_per_channel; ++i)
+                     size_t samples_per_channel) {
+  for (size_t i = 0; i < samples_per_channel; ++i)
     mono[i] = (stereo[i * 2] + stereo[i * 2 + 1]) / 2;
 }
 
 void MixStereoToMono(const int16_t* stereo, int16_t* mono,
-                     int samples_per_channel) {
-  for (int i = 0; i < samples_per_channel; ++i)
+                     size_t samples_per_channel) {
+  for (size_t i = 0; i < samples_per_channel; ++i)
     mono[i] = (stereo[i * 2] + stereo[i * 2 + 1]) >> 1;
 }
 
-void CopyLeftToRightChannel(int16_t* stereo, int samples_per_channel) {
-  for (int i = 0; i < samples_per_channel; i++) {
+void CopyLeftToRightChannel(int16_t* stereo, size_t samples_per_channel) {
+  for (size_t i = 0; i < samples_per_channel; i++) {
     stereo[i * 2 + 1] = stereo[i * 2];
   }
 }
 
-void VerifyChannelsAreEqual(int16_t* stereo, int samples_per_channel) {
-  for (int i = 0; i < samples_per_channel; i++) {
+void VerifyChannelsAreEqual(int16_t* stereo, size_t samples_per_channel) {
+  for (size_t i = 0; i < samples_per_channel; i++) {
     EXPECT_EQ(stereo[i * 2 + 1], stereo[i * 2]);
   }
 }
 
 void SetFrameTo(AudioFrame* frame, int16_t value) {
   for (size_t i = 0; i < frame->samples_per_channel_ * frame->num_channels_;
        ++i) {
     frame->data_[i] = value;
   }
 }
@@ skipping 52 matching lines @@
   EXPECT_NOERR(ap->voice_detection()->Enable(true));
 }
 
 // These functions are only used by ApmTest.Process.
 template <class T>
 T AbsValue(T a) {
   return a > 0 ? a: -a;
 }
 
 int16_t MaxAudioFrame(const AudioFrame& frame) {
-  const int length = frame.samples_per_channel_ * frame.num_channels_;
+  const size_t length = frame.samples_per_channel_ * frame.num_channels_;
   int16_t max_data = AbsValue(frame.data_[0]);
-  for (int i = 1; i < length; i++) {
+  for (size_t i = 1; i < length; i++) {
     max_data = std::max(max_data, AbsValue(frame.data_[i]));
   }
 
   return max_data;
 }
 
 #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
 void TestStats(const AudioProcessing::Statistic& test,
                const audioproc::Test::Statistic& reference) {
   EXPECT_EQ(reference.instant(), test.instant);
@@ skipping 680 matching lines @@
     }
   }
 }
 
 TEST_F(ApmTest, SampleRatesInt) {
   // Testing invalid sample rates
   SetContainerFormat(10000, 2, frame_, &float_cb_);
   EXPECT_EQ(apm_->kBadSampleRateError, ProcessStreamChooser(kIntFormat));
   // Testing valid sample rates
   int fs[] = {8000, 16000, 32000, 48000};
-  for (size_t i = 0; i < sizeof(fs) / sizeof(*fs); i++) {
+  for (size_t i = 0; i < arraysize(fs); i++) {
     SetContainerFormat(fs[i], 2, frame_, &float_cb_);
     EXPECT_NOERR(ProcessStreamChooser(kIntFormat));
   }
 }
 
 TEST_F(ApmTest, EchoCancellation) {
   EXPECT_EQ(apm_->kNoError,
             apm_->echo_cancellation()->enable_drift_compensation(true));
   EXPECT_TRUE(apm_->echo_cancellation()->is_drift_compensation_enabled());
   EXPECT_EQ(apm_->kNoError,
             apm_->echo_cancellation()->enable_drift_compensation(false));
   EXPECT_FALSE(apm_->echo_cancellation()->is_drift_compensation_enabled());
 
   EchoCancellation::SuppressionLevel level[] = {
     EchoCancellation::kLowSuppression,
     EchoCancellation::kModerateSuppression,
     EchoCancellation::kHighSuppression,
   };
-  for (size_t i = 0; i < sizeof(level)/sizeof(*level); i++) {
+  for (size_t i = 0; i < arraysize(level); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->echo_cancellation()->set_suppression_level(level[i]));
     EXPECT_EQ(level[i],
         apm_->echo_cancellation()->suppression_level());
   }
 
   EchoCancellation::Metrics metrics;
   EXPECT_EQ(apm_->kNotEnabledError,
             apm_->echo_cancellation()->GetMetrics(&metrics));
 
@@ skipping 56 matching lines @@
   // buffer is 66 ms in 8 kHz.
   //
   // It is known that for 16 kHz (and 32 kHz) sampling frequency there is an
   // additional stuffing of 8 ms on the fly, but it seems to have no impact on
   // delay estimation. This should be noted though. In case of test failure,
   // this could be the cause.
   const int kSystemDelayMs = 66;
   // Test a couple of corner cases and verify that the estimated delay is
   // within a valid region (set to +-1.5 blocks). Note that these cases are
   // sampling frequency dependent.
-  for (size_t i = 0; i < kProcessSampleRatesSize; i++) {
+  for (size_t i = 0; i < arraysize(kProcessSampleRates); i++) {
     Init(kProcessSampleRates[i],
          kProcessSampleRates[i],
          kProcessSampleRates[i],
          2,
          2,
          2,
          false);
     // Sampling frequency dependent variables.
     const int num_ms_per_block =
         std::max(4, static_cast<int>(640 / frame_->samples_per_channel_));
@@ skipping 51 matching lines @@
   EXPECT_TRUE(apm_->echo_control_mobile()->is_enabled());
 
   // Toggle routing modes
   EchoControlMobile::RoutingMode mode[] = {
       EchoControlMobile::kQuietEarpieceOrHeadset,
       EchoControlMobile::kEarpiece,
       EchoControlMobile::kLoudEarpiece,
       EchoControlMobile::kSpeakerphone,
       EchoControlMobile::kLoudSpeakerphone,
   };
-  for (size_t i = 0; i < sizeof(mode)/sizeof(*mode); i++) {
+  for (size_t i = 0; i < arraysize(mode); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->echo_control_mobile()->set_routing_mode(mode[i]));
     EXPECT_EQ(mode[i],
         apm_->echo_control_mobile()->routing_mode());
   }
   // Turn comfort noise off/on
   EXPECT_EQ(apm_->kNoError,
       apm_->echo_control_mobile()->enable_comfort_noise(false));
   EXPECT_FALSE(apm_->echo_control_mobile()->is_comfort_noise_enabled());
   EXPECT_EQ(apm_->kNoError,
@@ skipping 44 matching lines @@
   // Testing gain modes
   EXPECT_EQ(apm_->kNoError,
       apm_->gain_control()->set_mode(
       apm_->gain_control()->mode()));
 
   GainControl::Mode mode[] = {
     GainControl::kAdaptiveAnalog,
     GainControl::kAdaptiveDigital,
     GainControl::kFixedDigital
   };
-  for (size_t i = 0; i < sizeof(mode)/sizeof(*mode); i++) {
+  for (size_t i = 0; i < arraysize(mode); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->gain_control()->set_mode(mode[i]));
     EXPECT_EQ(mode[i], apm_->gain_control()->mode());
   }
   // Testing invalid target levels
   EXPECT_EQ(apm_->kBadParameterError,
       apm_->gain_control()->set_target_level_dbfs(-3));
   EXPECT_EQ(apm_->kBadParameterError,
       apm_->gain_control()->set_target_level_dbfs(-40));
   // Testing valid target levels
   EXPECT_EQ(apm_->kNoError,
       apm_->gain_control()->set_target_level_dbfs(
       apm_->gain_control()->target_level_dbfs()));
 
   int level_dbfs[] = {0, 6, 31};
-  for (size_t i = 0; i < sizeof(level_dbfs)/sizeof(*level_dbfs); i++) {
+  for (size_t i = 0; i < arraysize(level_dbfs); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->gain_control()->set_target_level_dbfs(level_dbfs[i]));
     EXPECT_EQ(level_dbfs[i], apm_->gain_control()->target_level_dbfs());
   }
 
   // Testing invalid compression gains
   EXPECT_EQ(apm_->kBadParameterError,
       apm_->gain_control()->set_compression_gain_db(-1));
   EXPECT_EQ(apm_->kBadParameterError,
       apm_->gain_control()->set_compression_gain_db(100));
 
   // Testing valid compression gains
   EXPECT_EQ(apm_->kNoError,
       apm_->gain_control()->set_compression_gain_db(
       apm_->gain_control()->compression_gain_db()));
 
   int gain_db[] = {0, 10, 90};
-  for (size_t i = 0; i < sizeof(gain_db)/sizeof(*gain_db); i++) {
+  for (size_t i = 0; i < arraysize(gain_db); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->gain_control()->set_compression_gain_db(gain_db[i]));
     EXPECT_EQ(gain_db[i], apm_->gain_control()->compression_gain_db());
   }
 
   // Testing limiter off/on
   EXPECT_EQ(apm_->kNoError, apm_->gain_control()->enable_limiter(false));
   EXPECT_FALSE(apm_->gain_control()->is_limiter_enabled());
   EXPECT_EQ(apm_->kNoError, apm_->gain_control()->enable_limiter(true));
   EXPECT_TRUE(apm_->gain_control()->is_limiter_enabled());
@@ skipping 10 matching lines @@
   EXPECT_EQ(apm_->kBadParameterError,
       apm_->gain_control()->set_analog_level_limits(512, 255));
 
   // Testing valid level limits
   EXPECT_EQ(apm_->kNoError,
       apm_->gain_control()->set_analog_level_limits(
       apm_->gain_control()->analog_level_minimum(),
       apm_->gain_control()->analog_level_maximum()));
 
   int min_level[] = {0, 255, 1024};
-  for (size_t i = 0; i < sizeof(min_level)/sizeof(*min_level); i++) {
+  for (size_t i = 0; i < arraysize(min_level); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->gain_control()->set_analog_level_limits(min_level[i], 1024));
     EXPECT_EQ(min_level[i], apm_->gain_control()->analog_level_minimum());
   }
 
   int max_level[] = {0, 1024, 65535};
-  for (size_t i = 0; i < sizeof(min_level)/sizeof(*min_level); i++) {
+  for (size_t i = 0; i < arraysize(min_level); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->gain_control()->set_analog_level_limits(0, max_level[i]));
     EXPECT_EQ(max_level[i], apm_->gain_control()->analog_level_maximum());
   }
 
   // TODO(ajm): stream_is_saturated() and stream_analog_level()
 
   // Turn AGC off
   EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(false));
   EXPECT_FALSE(apm_->gain_control()->is_enabled());
@@ skipping 18 matching lines @@
     out_analog_level = apm_->gain_control()->stream_analog_level();
   }
 
   // Ensure the AGC is still able to reach the maximum.
   EXPECT_EQ(255, out_analog_level);
 }
 
 // Verifies that despite volume slider quantization, the AGC can continue to
 // increase its volume.
 TEST_F(ApmTest, QuantizedVolumeDoesNotGetStuck) {
-  for (size_t i = 0; i < kSampleRatesSize; ++i) {
+  for (size_t i = 0; i < arraysize(kSampleRates); ++i) {
     RunQuantizedVolumeDoesNotGetStuckTest(kSampleRates[i]);
   }
 }
 
 void ApmTest::RunManualVolumeChangeIsPossibleTest(int sample_rate) {
   Init(sample_rate, sample_rate, sample_rate, 2, 2, 2, false);
   EXPECT_EQ(apm_->kNoError,
             apm_->gain_control()->set_mode(GainControl::kAdaptiveAnalog));
   EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
 
@@ skipping 24 matching lines @@
     EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
     out_analog_level = apm_->gain_control()->stream_analog_level();
     // Check that AGC respected the manually adjusted volume.
     EXPECT_LT(out_analog_level, highest_level_reached);
   }
   // Check that the volume was still raised.
   EXPECT_GT(out_analog_level, 100);
 }
 
 TEST_F(ApmTest, ManualVolumeChangeIsPossible) {
-  for (size_t i = 0; i < kSampleRatesSize; ++i) {
+  for (size_t i = 0; i < arraysize(kSampleRates); ++i) {
     RunManualVolumeChangeIsPossibleTest(kSampleRates[i]);
   }
 }
 
 #if !defined(WEBRTC_ANDROID) && !defined(WEBRTC_IOS)
 TEST_F(ApmTest, AgcOnlyAdaptsWhenTargetSignalIsPresent) {
   const int kSampleRateHz = 16000;
-  const int kSamplesPerChannel =
-      AudioProcessing::kChunkSizeMs * kSampleRateHz / 1000;
+  const size_t kSamplesPerChannel =
+      static_cast<size_t>(AudioProcessing::kChunkSizeMs * kSampleRateHz / 1000);
   const int kNumInputChannels = 2;
   const int kNumOutputChannels = 1;
-  const int kNumChunks = 700;
+  const size_t kNumChunks = 700;
   const float kScaleFactor = 0.25f;
   Config config;
   std::vector<webrtc::Point> geometry;
   geometry.push_back(webrtc::Point(0.f, 0.f, 0.f));
   geometry.push_back(webrtc::Point(0.05f, 0.f, 0.f));
   config.Set<Beamforming>(new Beamforming(true, geometry));
   testing::NiceMock<MockNonlinearBeamformer>* beamformer =
       new testing::NiceMock<MockNonlinearBeamformer>(geometry);
   rtc::scoped_ptr<AudioProcessing> apm(
       AudioProcessing::Create(config, beamformer));
   EXPECT_EQ(kNoErr, apm->gain_control()->Enable(true));
   ChannelBuffer<float> src_buf(kSamplesPerChannel, kNumInputChannels);
   ChannelBuffer<float> dest_buf(kSamplesPerChannel, kNumOutputChannels);
-  const int max_length = kSamplesPerChannel * std::max(kNumInputChannels,
-                                                       kNumOutputChannels);
+  const size_t max_length = kSamplesPerChannel * std::max(kNumInputChannels,
+                                                          kNumOutputChannels);
   rtc::scoped_ptr<int16_t[]> int_data(new int16_t[max_length]);
   rtc::scoped_ptr<float[]> float_data(new float[max_length]);
   std::string filename = ResourceFilePath("far", kSampleRateHz);
   FILE* far_file = fopen(filename.c_str(), "rb");
   ASSERT_TRUE(far_file != NULL) << "Could not open file " << filename << "\n";
   const int kDefaultVolume = apm->gain_control()->stream_analog_level();
   const int kDefaultCompressionGain =
       apm->gain_control()->compression_gain_db();
   bool is_target = false;
   EXPECT_CALL(*beamformer, is_target_present())
       .WillRepeatedly(testing::ReturnPointee(&is_target));
-  for (int i = 0; i < kNumChunks; ++i) {
+  for (size_t i = 0; i < kNumChunks; ++i) {
     ASSERT_TRUE(ReadChunk(far_file,
                           int_data.get(),
                           float_data.get(),
                           &src_buf));
     for (int j = 0; j < kNumInputChannels; ++j) {
-      for (int k = 0; k < kSamplesPerChannel; ++k) {
+      for (size_t k = 0; k < kSamplesPerChannel; ++k) {
         src_buf.channels()[j][k] *= kScaleFactor;
       }
     }
     EXPECT_EQ(kNoErr,
               apm->ProcessStream(src_buf.channels(),
                                  src_buf.num_frames(),
                                  kSampleRateHz,
                                  LayoutFromChannels(src_buf.num_channels()),
                                  kSampleRateHz,
                                  LayoutFromChannels(dest_buf.num_channels()),
                                  dest_buf.channels()));
   }
   EXPECT_EQ(kDefaultVolume,
             apm->gain_control()->stream_analog_level());
   EXPECT_EQ(kDefaultCompressionGain,
             apm->gain_control()->compression_gain_db());
   rewind(far_file);
   is_target = true;
-  for (int i = 0; i < kNumChunks; ++i) {
+  for (size_t i = 0; i < kNumChunks; ++i) {
     ASSERT_TRUE(ReadChunk(far_file,
                           int_data.get(),
                           float_data.get(),
                           &src_buf));
     for (int j = 0; j < kNumInputChannels; ++j) {
-      for (int k = 0; k < kSamplesPerChannel; ++k) {
+      for (size_t k = 0; k < kSamplesPerChannel; ++k) {
         src_buf.channels()[j][k] *= kScaleFactor;
       }
     }
     EXPECT_EQ(kNoErr,
               apm->ProcessStream(src_buf.channels(),
                                  src_buf.num_frames(),
                                  kSampleRateHz,
                                  LayoutFromChannels(src_buf.num_channels()),
                                  kSampleRateHz,
                                  LayoutFromChannels(dest_buf.num_channels()),
                                  dest_buf.channels()));
   }
   EXPECT_LT(kDefaultVolume,
             apm->gain_control()->stream_analog_level());
   EXPECT_LT(kDefaultCompressionGain,
             apm->gain_control()->compression_gain_db());
   ASSERT_EQ(0, fclose(far_file));
 }
 #endif
 
 TEST_F(ApmTest, NoiseSuppression) {
   // Test valid suppression levels.
   NoiseSuppression::Level level[] = {
     NoiseSuppression::kLow,
     NoiseSuppression::kModerate,
     NoiseSuppression::kHigh,
     NoiseSuppression::kVeryHigh
   };
-  for (size_t i = 0; i < sizeof(level)/sizeof(*level); i++) {
+  for (size_t i = 0; i < arraysize(level); i++) {
     EXPECT_EQ(apm_->kNoError,
         apm_->noise_suppression()->set_level(level[i]));
     EXPECT_EQ(level[i], apm_->noise_suppression()->level());
   }
 
   // Turn NS on/off
   EXPECT_EQ(apm_->kNoError, apm_->noise_suppression()->Enable(true));
   EXPECT_TRUE(apm_->noise_suppression()->is_enabled());
   EXPECT_EQ(apm_->kNoError, apm_->noise_suppression()->Enable(false));
   EXPECT_FALSE(apm_->noise_suppression()->is_enabled());
@@ skipping 81 matching lines @@
             apm_->voice_detection()->set_stream_has_voice(false));
   EXPECT_FALSE(apm_->voice_detection()->stream_has_voice());
 
   // Test valid likelihoods
   VoiceDetection::Likelihood likelihood[] = {
       VoiceDetection::kVeryLowLikelihood,
       VoiceDetection::kLowLikelihood,
       VoiceDetection::kModerateLikelihood,
       VoiceDetection::kHighLikelihood
   };
-  for (size_t i = 0; i < sizeof(likelihood)/sizeof(*likelihood); i++) {
+  for (size_t i = 0; i < arraysize(likelihood); i++) {
     EXPECT_EQ(apm_->kNoError,
               apm_->voice_detection()->set_likelihood(likelihood[i]));
     EXPECT_EQ(likelihood[i], apm_->voice_detection()->likelihood());
   }
 
   /* TODO(bjornv): Enable once VAD supports other frame lengths than 10 ms
   // Test invalid frame sizes
   EXPECT_EQ(apm_->kBadParameterError,
       apm_->voice_detection()->set_frame_size_ms(12));
 
@@ skipping 11 matching lines @@
   EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(false));
   EXPECT_FALSE(apm_->voice_detection()->is_enabled());
 
   // Test that AudioFrame activity is maintained when VAD is disabled.
   EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(false));
   AudioFrame::VADActivity activity[] = {
       AudioFrame::kVadActive,
       AudioFrame::kVadPassive,
       AudioFrame::kVadUnknown
   };
-  for (size_t i = 0; i < sizeof(activity)/sizeof(*activity); i++) {
+  for (size_t i = 0; i < arraysize(activity); i++) {
     frame_->vad_activity_ = activity[i];
     EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
     EXPECT_EQ(activity[i], frame_->vad_activity_);
   }
 
   // Test that AudioFrame activity is set when VAD is enabled.
   EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(true));
   frame_->vad_activity_ = AudioFrame::kVadUnknown;
   EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
   EXPECT_NE(AudioFrame::kVadUnknown, frame_->vad_activity_);
 
   // TODO(bjornv): Add tests for streamed voice; stream_has_voice()
 }
 
 TEST_F(ApmTest, AllProcessingDisabledByDefault) {
   EXPECT_FALSE(apm_->echo_cancellation()->is_enabled());
   EXPECT_FALSE(apm_->echo_control_mobile()->is_enabled());
   EXPECT_FALSE(apm_->gain_control()->is_enabled());
   EXPECT_FALSE(apm_->high_pass_filter()->is_enabled());
   EXPECT_FALSE(apm_->level_estimator()->is_enabled());
   EXPECT_FALSE(apm_->noise_suppression()->is_enabled());
   EXPECT_FALSE(apm_->voice_detection()->is_enabled());
 }
 
 TEST_F(ApmTest, NoProcessingWhenAllComponentsDisabled) {
-  for (size_t i = 0; i < kSampleRatesSize; i++) {
+  for (size_t i = 0; i < arraysize(kSampleRates); i++) {
     Init(kSampleRates[i], kSampleRates[i], kSampleRates[i], 2, 2, 2, false);
     SetFrameTo(frame_, 1000, 2000);
     AudioFrame frame_copy;
     frame_copy.CopyFrom(*frame_);
     for (int j = 0; j < 1000; j++) {
       EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
       EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));
       EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(frame_));
       EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));
     }
@@ skipping 31 matching lines @@
                                           output_stream, &rev_dest_channels));
 
   for (size_t i = 0; i < kSamples; ++i) {
     EXPECT_EQ(src[i], rev_dest[i]);
   }
 }
 
 TEST_F(ApmTest, IdenticalInputChannelsResultInIdenticalOutputChannels) {
   EnableAllComponents();
 
-  for (size_t i = 0; i < kProcessSampleRatesSize; i++) {
+  for (size_t i = 0; i < arraysize(kProcessSampleRates); i++) {
     Init(kProcessSampleRates[i],
          kProcessSampleRates[i],
          kProcessSampleRates[i],
          2,
          2,
          2,
          false);
     int analog_level = 127;
     ASSERT_EQ(0, feof(far_file_));
     ASSERT_EQ(0, feof(near_file_));
@@ skipping 318 matching lines @@
     printf("Running test %d of %d...\n", i + 1, ref_data.test_size());
 
     audioproc::Test* test = ref_data.mutable_test(i);
     // TODO(ajm): Restore downmixing test cases.
     if (test->num_input_channels() != test->num_output_channels())
       continue;
 
     const int num_render_channels = test->num_reverse_channels();
     const int num_input_channels = test->num_input_channels();
     const int num_output_channels = test->num_output_channels();
-    const int samples_per_channel = test->sample_rate() *
-        AudioProcessing::kChunkSizeMs / 1000;
+    const size_t samples_per_channel = static_cast<size_t>(
+        test->sample_rate() * AudioProcessing::kChunkSizeMs / 1000);
 
     Init(test->sample_rate(), test->sample_rate(), test->sample_rate(),
          num_input_channels, num_output_channels, num_render_channels, true);
     Init(fapm.get());
 
     ChannelBuffer<int16_t> output_cb(samples_per_channel, num_input_channels);
     ChannelBuffer<int16_t> output_int16(samples_per_channel,
                                         num_input_channels);
 
     int analog_level = 127;
@@ skipping 71 matching lines @@
 // of enabled components.
 
 TEST_F(ApmTest, Process) {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
   audioproc::OutputData ref_data;
 
   if (!write_ref_data) {
     OpenFileAndReadMessage(ref_filename_, &ref_data);
   } else {
     // Write the desired tests to the protobuf reference file.
-    for (size_t i = 0; i < kChannelsSize; i++) {
-      for (size_t j = 0; j < kChannelsSize; j++) {
-        for (size_t l = 0; l < kProcessSampleRatesSize; l++) {
+    for (size_t i = 0; i < arraysize(kChannels); i++) {
+      for (size_t j = 0; j < arraysize(kChannels); j++) {
+        for (size_t l = 0; l < arraysize(kProcessSampleRates); l++) {
           audioproc::Test* test = ref_data.add_test();
           test->set_num_reverse_channels(kChannels[i]);
           test->set_num_input_channels(kChannels[j]);
           test->set_num_output_channels(kChannels[j]);
           test->set_sample_rate(kProcessSampleRates[l]);
           test->set_use_aec_extended_filter(false);
         }
       }
     }
 #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
@@ skipping 206 matching lines @@
 TEST_F(ApmTest, NoErrorsWithKeyboardChannel) {
   struct ChannelFormat {
     AudioProcessing::ChannelLayout in_layout;
     AudioProcessing::ChannelLayout out_layout;
   };
   ChannelFormat cf[] = {
     {AudioProcessing::kMonoAndKeyboard, AudioProcessing::kMono},
     {AudioProcessing::kStereoAndKeyboard, AudioProcessing::kMono},
     {AudioProcessing::kStereoAndKeyboard, AudioProcessing::kStereo},
   };
-  size_t channel_format_size = sizeof(cf) / sizeof(*cf);
 
   rtc::scoped_ptr<AudioProcessing> ap(AudioProcessing::Create());
   // Enable one component just to ensure some processing takes place.
   ap->noise_suppression()->Enable(true);
-  for (size_t i = 0; i < channel_format_size; ++i) {
+  for (size_t i = 0; i < arraysize(cf); ++i) {
     const int in_rate = 44100;
     const int out_rate = 48000;
     ChannelBuffer<float> in_cb(SamplesFromRate(in_rate),
                                TotalChannelsFromLayout(cf[i].in_layout));
     ChannelBuffer<float> out_cb(SamplesFromRate(out_rate),
                                 ChannelsFromLayout(cf[i].out_layout));
 
     // Run over a few chunks.
     for (int j = 0; j < 10; ++j) {
       EXPECT_NOERR(ap->ProcessStream(
           in_cb.channels(),
           in_cb.num_frames(),
           in_rate,
           cf[i].in_layout,
           out_rate,
           cf[i].out_layout,
           out_cb.channels()));
     }
   }
 }
 
 // Compares the reference and test arrays over a region around the expected
 // delay. Finds the highest SNR in that region and adds the variance and squared
 // error results to the supplied accumulators.
 void UpdateBestSNR(const float* ref,
                    const float* test,
-                   int length,
+                   size_t length,
                    int expected_delay,
                    double* variance_acc,
                    double* sq_error_acc) {
   double best_snr = std::numeric_limits<double>::min();
   double best_variance = 0;
   double best_sq_error = 0;
   // Search over a region of eight samples around the expected delay.
   for (int delay = std::max(expected_delay - 4, 0); delay <= expected_delay + 4;
        ++delay) {
     double sq_error = 0;
     double variance = 0;
-    for (int i = 0; i < length - delay; ++i) {
+    for (size_t i = 0; i < length - delay; ++i) {
       double error = test[i + delay] - ref[i];
       sq_error += error * error;
       variance += ref[i] * ref[i];
     }
 
     if (sq_error == 0) {
       *variance_acc += variance;
       return;
     }
     double snr = variance / sq_error;
@@ skipping 31 matching lines @@
         reverse_input_rate_(std::tr1::get<2>(GetParam())),
         reverse_output_rate_(std::tr1::get<3>(GetParam())),
         expected_snr_(std::tr1::get<4>(GetParam())),
         expected_reverse_snr_(std::tr1::get<5>(GetParam())) {}
 
   virtual ~AudioProcessingTest() {}
 
   static void SetUpTestCase() {
     // Create all needed output reference files.
     const int kNativeRates[] = {8000, 16000, 32000, 48000};
-    const size_t kNativeRatesSize =
-        sizeof(kNativeRates) / sizeof(*kNativeRates);
     const int kNumChannels[] = {1, 2};
-    const size_t kNumChannelsSize =
-        sizeof(kNumChannels) / sizeof(*kNumChannels);
-    for (size_t i = 0; i < kNativeRatesSize; ++i) {
-      for (size_t j = 0; j < kNumChannelsSize; ++j) {
-        for (size_t k = 0; k < kNumChannelsSize; ++k) {
+    for (size_t i = 0; i < arraysize(kNativeRates); ++i) {
+      for (size_t j = 0; j < arraysize(kNumChannels); ++j) {
+        for (size_t k = 0; k < arraysize(kNumChannels); ++k) {
           // The reference files always have matching input and output channels.
           ProcessFormat(kNativeRates[i], kNativeRates[i], kNativeRates[i],
                         kNativeRates[i], kNumChannels[j], kNumChannels[j],
                         kNumChannels[k], kNumChannels[k], "ref");
         }
       }
     }
   }
 
   static void TearDownTestCase() {
@@ skipping 78 matching lines @@
           fwd_cb.num_frames(),
           input_rate,
           LayoutFromChannels(num_input_channels),
           output_rate,
           LayoutFromChannels(num_output_channels),
           out_cb.channels()));
 
       // Dump forward output to file.
       Interleave(out_cb.channels(), out_cb.num_frames(), out_cb.num_channels(),
                  float_data.get());
-      int out_length = out_cb.num_channels() * out_cb.num_frames();
+      size_t out_length = out_cb.num_channels() * out_cb.num_frames();
 
-      ASSERT_EQ(static_cast<size_t>(out_length),
+      ASSERT_EQ(out_length,
                 fwrite(float_data.get(), sizeof(float_data[0]),
                        out_length, out_file));
 
       // Dump reverse output to file.
       Interleave(rev_out_cb.channels(), rev_out_cb.num_frames(),
                  rev_out_cb.num_channels(), float_data.get());
-      int rev_out_length = rev_out_cb.num_channels() * rev_out_cb.num_frames();
+      size_t rev_out_length =
+          rev_out_cb.num_channels() * rev_out_cb.num_frames();
 
-      ASSERT_EQ(static_cast<size_t>(rev_out_length),
+      ASSERT_EQ(rev_out_length,
                 fwrite(float_data.get(), sizeof(float_data[0]), rev_out_length,
                        rev_out_file));
 
       analog_level = ap->gain_control()->stream_analog_level();
     }
     fclose(far_file);
     fclose(near_file);
     fclose(out_file);
     fclose(rev_out_file);
   }
@@ skipping 15 matching lines @@
     int num_reverse_output;
   };
   ChannelFormat cf[] = {
       {1, 1, 1, 1},
       {1, 1, 2, 1},
       {2, 1, 1, 1},
       {2, 1, 2, 1},
       {2, 2, 1, 1},
       {2, 2, 2, 2},
   };
-  size_t channel_format_size = sizeof(cf) / sizeof(*cf);
 
-  for (size_t i = 0; i < channel_format_size; ++i) {
+  for (size_t i = 0; i < arraysize(cf); ++i) {
     ProcessFormat(input_rate_, output_rate_, reverse_input_rate_,
                   reverse_output_rate_, cf[i].num_input, cf[i].num_output,
                   cf[i].num_reverse_input, cf[i].num_reverse_output, "out");
 
     // Verify output for both directions.
     std::vector<StreamDirection> stream_directions;
     stream_directions.push_back(kForward);
     stream_directions.push_back(kReverse);
     for (StreamDirection file_direction : stream_directions) {
       const int in_rate = file_direction ? reverse_input_rate_ : input_rate_;
@@ skipping 29 matching lines @@
       // The reference files always have matching input and output channels.
       FILE* ref_file = fopen(
           OutputFilePath("ref", ref_rate, ref_rate, ref_rate, ref_rate,
                          cf[i].num_output, cf[i].num_output,
                          cf[i].num_reverse_output, cf[i].num_reverse_output,
                          file_direction).c_str(),
           "rb");
       ASSERT_TRUE(out_file != NULL);
       ASSERT_TRUE(ref_file != NULL);
 
-      const int ref_length = SamplesFromRate(ref_rate) * out_num;
-      const int out_length = SamplesFromRate(out_rate) * out_num;
+      const size_t ref_length = SamplesFromRate(ref_rate) * out_num;
+      const size_t out_length = SamplesFromRate(out_rate) * out_num;
       // Data from the reference file.
       rtc::scoped_ptr<float[]> ref_data(new float[ref_length]);
       // Data from the output file.
       rtc::scoped_ptr<float[]> out_data(new float[out_length]);
       // Data from the resampled output, in case the reference and output rates
       // don't match.
       rtc::scoped_ptr<float[]> cmp_data(new float[ref_length]);
 
       PushResampler<float> resampler;
       resampler.InitializeIfNeeded(out_rate, ref_rate, out_num);
@@ skipping 19 matching lines @@
           floor(expected_delay_sec * ref_rate + 0.5f) * out_num;
 
       double variance = 0;
       double sq_error = 0;
       while (fread(out_data.get(), sizeof(out_data[0]), out_length, out_file) &&
              fread(ref_data.get(), sizeof(ref_data[0]), ref_length, ref_file)) {
         float* out_ptr = out_data.get();
         if (out_rate != ref_rate) {
           // Resample the output back to its internal processing rate if
           // necssary.
-          ASSERT_EQ(ref_length, resampler.Resample(out_ptr, out_length,
-                                                   cmp_data.get(), ref_length));
+          ASSERT_EQ(ref_length,
+                    static_cast<size_t>(resampler.Resample(
+                        out_ptr, out_length, cmp_data.get(), ref_length)));
           out_ptr = cmp_data.get();
         }
 
         // Update the |sq_error| and |variance| accumulators with the highest
         // SNR of reference vs output.
         UpdateBestSNR(ref_data.get(), out_ptr, ref_length, expected_delay,
                       &variance, &sq_error);
       }
 
       std::cout << "(" << input_rate_ << ", " << output_rate_ << ", "
@@ skipping 126 matching lines @@
                     std::tr1::make_tuple(16000, 32000, 48000, 32000, 25, 35),
                     std::tr1::make_tuple(16000, 32000, 32000, 32000, 25, 0),
                     std::tr1::make_tuple(16000, 32000, 16000, 32000, 25, 20),
                     std::tr1::make_tuple(16000, 16000, 48000, 16000, 35, 20),
                     std::tr1::make_tuple(16000, 16000, 32000, 16000, 40, 20),
                     std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));
 #endif
 
 }  // namespace
 }  // namespace webrtc