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

webrtc/common_audio/sparse_fir_filter_unittest.cc

 /*
  *  Copyright (c) 2015 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 13 matching lines @@
 
 template <size_t N>
 void VerifyOutput(const float (&expected_output)[N], const float (&output)[N]) {
   EXPECT_EQ(0, memcmp(expected_output, output, sizeof(output)));
 }
 
 }  // namespace
 
 TEST(SparseFIRFilterTest, FilterAsIdentity) {
   const float kCoeff = 1.f;
-  const int kNumCoeff = 1;
-  const int kSparsity = 3;
-  const int kOffset = 0;
+  const size_t kNumCoeff = 1;
+  const size_t kSparsity = 3;
+  const size_t kOffset = 0;
   float output[arraysize(kInput)];
   SparseFIRFilter filter(&kCoeff, kNumCoeff, kSparsity, kOffset);
   filter.Filter(kInput, arraysize(kInput), output);
   VerifyOutput(kInput, output);
 }
 
 TEST(SparseFIRFilterTest, SameOutputForScalarCoefficientAndDifferentSparsity) {
   const float kCoeff = 2.f;
-  const int kNumCoeff = 1;
-  const int kLowSparsity = 1;
-  const int kHighSparsity = 7;
-  const int kOffset = 0;
+  const size_t kNumCoeff = 1;
+  const size_t kLowSparsity = 1;
+  const size_t kHighSparsity = 7;
+  const size_t kOffset = 0;
   float low_sparsity_output[arraysize(kInput)];
   float high_sparsity_output[arraysize(kInput)];
   SparseFIRFilter low_sparsity_filter(&kCoeff,
                                       kNumCoeff,
                                       kLowSparsity,
                                       kOffset);
   SparseFIRFilter high_sparsity_filter(&kCoeff,
                                        kNumCoeff,
                                        kHighSparsity,
                                        kOffset);
   low_sparsity_filter.Filter(kInput, arraysize(kInput), low_sparsity_output);
   high_sparsity_filter.Filter(kInput, arraysize(kInput), high_sparsity_output);
   VerifyOutput(low_sparsity_output, high_sparsity_output);
 }
 
 TEST(SparseFIRFilterTest, FilterUsedAsScalarMultiplication) {
   const float kCoeff = 5.f;
-  const int kNumCoeff = 1;
-  const int kSparsity = 5;
-  const int kOffset = 0;
+  const size_t kNumCoeff = 1;
+  const size_t kSparsity = 5;
+  const size_t kOffset = 0;
   float output[arraysize(kInput)];
   SparseFIRFilter filter(&kCoeff, kNumCoeff, kSparsity, kOffset);
   filter.Filter(kInput, arraysize(kInput), output);
   EXPECT_FLOAT_EQ(5.f, output[0]);
   EXPECT_FLOAT_EQ(20.f, output[3]);
   EXPECT_FLOAT_EQ(25.f, output[4]);
   EXPECT_FLOAT_EQ(50.f, output[arraysize(kInput) - 1]);
 }
 
 TEST(SparseFIRFilterTest, FilterUsedAsInputShifting) {
   const float kCoeff = 1.f;
-  const int kNumCoeff = 1;
-  const int kSparsity = 1;
-  const int kOffset = 4;
+  const size_t kNumCoeff = 1;
+  const size_t kSparsity = 1;
+  const size_t kOffset = 4;
   float output[arraysize(kInput)];
   SparseFIRFilter filter(&kCoeff, kNumCoeff, kSparsity, kOffset);
   filter.Filter(kInput, arraysize(kInput), output);
   EXPECT_FLOAT_EQ(0.f, output[0]);
   EXPECT_FLOAT_EQ(0.f, output[3]);
   EXPECT_FLOAT_EQ(1.f, output[4]);
   EXPECT_FLOAT_EQ(2.f, output[5]);
   EXPECT_FLOAT_EQ(6.f, output[arraysize(kInput) - 1]);
 }
 
 TEST(SparseFIRFilterTest, FilterUsedAsArbitraryWeighting) {
-  const int kSparsity = 2;
-  const int kOffset = 1;
+  const size_t kSparsity = 2;
+  const size_t kOffset = 1;
   float output[arraysize(kInput)];
   SparseFIRFilter filter(kCoeffs, arraysize(kCoeffs), kSparsity, kOffset);
   filter.Filter(kInput, arraysize(kInput), output);
   EXPECT_FLOAT_EQ(0.f, output[0]);
   EXPECT_FLOAT_EQ(0.9f, output[3]);
   EXPECT_FLOAT_EQ(1.4f, output[4]);
   EXPECT_FLOAT_EQ(2.4f, output[5]);
   EXPECT_FLOAT_EQ(8.61f, output[arraysize(kInput) - 1]);
 }
 
 TEST(SparseFIRFilterTest, FilterInLengthLesserOrEqualToCoefficientsLength) {
-  const int kSparsity = 1;
-  const int kOffset = 0;
+  const size_t kSparsity = 1;
+  const size_t kOffset = 0;
   float output[arraysize(kInput)];
   SparseFIRFilter filter(kCoeffs, arraysize(kCoeffs), kSparsity, kOffset);
   filter.Filter(kInput, 2, output);
   EXPECT_FLOAT_EQ(0.2f, output[0]);
   EXPECT_FLOAT_EQ(0.7f, output[1]);
 }
 
 TEST(SparseFIRFilterTest, MultipleFilterCalls) {
-  const int kSparsity = 1;
-  const int kOffset = 0;
+  const size_t kSparsity = 1;
+  const size_t kOffset = 0;
   float output[arraysize(kInput)];
   SparseFIRFilter filter(kCoeffs, arraysize(kCoeffs), kSparsity, kOffset);
   filter.Filter(kInput, 2, output);
   EXPECT_FLOAT_EQ(0.2f, output[0]);
   EXPECT_FLOAT_EQ(0.7f, output[1]);
   filter.Filter(kInput, 2, output);
   EXPECT_FLOAT_EQ(1.3f, output[0]);
   EXPECT_FLOAT_EQ(2.4f, output[1]);
   filter.Filter(kInput, 2, output);
   EXPECT_FLOAT_EQ(2.81f, output[0]);
   EXPECT_FLOAT_EQ(2.62f, output[1]);
   filter.Filter(kInput, 2, output);
   EXPECT_FLOAT_EQ(2.81f, output[0]);
   EXPECT_FLOAT_EQ(2.62f, output[1]);
   filter.Filter(&kInput[3], 3, output);
   EXPECT_FLOAT_EQ(3.41f, output[0]);
   EXPECT_FLOAT_EQ(4.12f, output[1]);
   EXPECT_FLOAT_EQ(6.21f, output[2]);
   filter.Filter(&kInput[3], 3, output);
   EXPECT_FLOAT_EQ(8.12f, output[0]);
   EXPECT_FLOAT_EQ(9.14f, output[1]);
   EXPECT_FLOAT_EQ(9.45f, output[2]);
 }
 
 TEST(SparseFIRFilterTest, VerifySampleBasedVsBlockBasedFiltering) {
-  const int kSparsity = 3;
-  const int kOffset = 1;
+  const size_t kSparsity = 3;
+  const size_t kOffset = 1;
   float output_block_based[arraysize(kInput)];
   SparseFIRFilter filter_block(kCoeffs,
                                arraysize(kCoeffs),
                                kSparsity,
                                kOffset);
   filter_block.Filter(kInput, arraysize(kInput), output_block_based);
   float output_sample_based[arraysize(kInput)];
   SparseFIRFilter filter_sample(kCoeffs,
                                 arraysize(kCoeffs),
                                 kSparsity,
                                 kOffset);
   for (size_t i = 0; i < arraysize(kInput); ++i)
     filter_sample.Filter(&kInput[i], 1, &output_sample_based[i]);
   VerifyOutput(output_block_based, output_sample_based);
 }
 
 TEST(SparseFIRFilterTest, SimpleHighPassFilter) {
-  const int kSparsity = 2;
-  const int kOffset = 2;
+  const size_t kSparsity = 2;
+  const size_t kOffset = 2;
   const float kHPCoeffs[] = {1.f, -1.f};
   const float kConstantInput[] =
       {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
   float output[arraysize(kConstantInput)];
   SparseFIRFilter filter(kHPCoeffs, arraysize(kHPCoeffs), kSparsity, kOffset);
   filter.Filter(kConstantInput, arraysize(kConstantInput), output);
   EXPECT_FLOAT_EQ(0.f, output[0]);
   EXPECT_FLOAT_EQ(0.f, output[1]);
   EXPECT_FLOAT_EQ(1.f, output[2]);
   EXPECT_FLOAT_EQ(1.f, output[3]);
   for (size_t i = kSparsity + kOffset; i < arraysize(kConstantInput); ++i)
     EXPECT_FLOAT_EQ(0.f, output[i]);
 }
 
 TEST(SparseFIRFilterTest, SimpleLowPassFilter) {
-  const int kSparsity = 2;
-  const int kOffset = 2;
+  const size_t kSparsity = 2;
+  const size_t kOffset = 2;
   const float kLPCoeffs[] = {1.f, 1.f};
   const float kHighFrequencyInput[] =
       {1.f, 1.f, -1.f, -1.f, 1.f, 1.f, -1.f, -1.f, 1.f, 1.f};
   float output[arraysize(kHighFrequencyInput)];
   SparseFIRFilter filter(kLPCoeffs, arraysize(kLPCoeffs), kSparsity, kOffset);
   filter.Filter(kHighFrequencyInput, arraysize(kHighFrequencyInput), output);
   EXPECT_FLOAT_EQ(0.f, output[0]);
   EXPECT_FLOAT_EQ(0.f, output[1]);
   EXPECT_FLOAT_EQ(1.f, output[2]);
   EXPECT_FLOAT_EQ(1.f, output[3]);
   for (size_t i = kSparsity + kOffset; i < arraysize(kHighFrequencyInput); ++i)
     EXPECT_FLOAT_EQ(0.f, output[i]);
 }
 
 TEST(SparseFIRFilterTest, SameOutputWhenSwappedCoefficientsAndInput) {
-  const int kSparsity = 1;
-  const int kOffset = 0;
+  const size_t kSparsity = 1;
+  const size_t kOffset = 0;
   float output[arraysize(kCoeffs)];
   float output_swapped[arraysize(kCoeffs)];
   SparseFIRFilter filter(kCoeffs, arraysize(kCoeffs), kSparsity, kOffset);
   // Use arraysize(kCoeffs) for in_length to get same-length outputs.
   filter.Filter(kInput, arraysize(kCoeffs), output);
   SparseFIRFilter filter_swapped(kInput,
                                  arraysize(kCoeffs),
                                  kSparsity,
                                  kOffset);
   filter_swapped.Filter(kCoeffs, arraysize(kCoeffs), output_swapped);
   VerifyOutput(output, output_swapped);
 }
 
 TEST(SparseFIRFilterTest, SameOutputAsFIRFilterWhenSparsityOneAndOffsetZero) {
-  const int kSparsity = 1;
-  const int kOffset = 0;
+  const size_t kSparsity = 1;
+  const size_t kOffset = 0;
   float output[arraysize(kInput)];
   float sparse_output[arraysize(kInput)];
   rtc::scoped_ptr<FIRFilter> filter(FIRFilter::Create(kCoeffs,
                                                       arraysize(kCoeffs),
                                                       arraysize(kInput)));
   SparseFIRFilter sparse_filter(kCoeffs,
                                 arraysize(kCoeffs),
                                 kSparsity,
                                 kOffset);
   filter->Filter(kInput, arraysize(kInput), output);
   sparse_filter.Filter(kInput, arraysize(kInput), sparse_output);
   for (size_t i = 0; i < arraysize(kInput); ++i) {
     EXPECT_FLOAT_EQ(output[i], sparse_output[i]);
   }
 }
 
 }  // namespace webrtc