Fix the maximum native sample rate in AudioProcessing

webrtc/voice_engine/utility_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 "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/common_audio/resampler/include/push_resampler.h"
 #include "webrtc/modules/interface/module_common_types.h"
 #include "webrtc/voice_engine/utility.h"
 #include "webrtc/voice_engine/voice_engine_defines.h"
 
 namespace webrtc {
 namespace voe {
 namespace {
 
-enum FunctionToTest {
-  TestRemixAndResample,
-  TestDownConvertToCodecFormat
-};
-
 class UtilityTest : public ::testing::Test {
  protected:
   UtilityTest() {
     src_frame_.sample_rate_hz_ = 16000;
     src_frame_.samples_per_channel_ = src_frame_.sample_rate_hz_ / 100;
     src_frame_.num_channels_ = 1;
     dst_frame_.CopyFrom(src_frame_);
     golden_frame_.CopyFrom(src_frame_);
   }
 
-  void RunResampleTest(int src_channels, int src_sample_rate_hz,
-                       int dst_channels, int dst_sample_rate_hz,
-                       FunctionToTest function);
+  void RunResampleTest(int src_channels,
+                       int src_sample_rate_hz,
+                       int dst_channels,
+                       int dst_sample_rate_hz);
 
   PushResampler<int16_t> resampler_;
   AudioFrame src_frame_;
   AudioFrame dst_frame_;
   AudioFrame golden_frame_;
 };
 
 // Sets the signal value to increase by |data| with every sample. Floats are
 // used so non-integer values result in rounding error, but not an accumulating
 // error.
@@ skipping 71 matching lines @@
   VerifyParams(ref_frame, test_frame);
   for (size_t i = 0;
        i < ref_frame.samples_per_channel_ * ref_frame.num_channels_; i++) {
     EXPECT_EQ(ref_frame.data_[i], test_frame.data_[i]);
   }
 }
 
 void UtilityTest::RunResampleTest(int src_channels,
                                   int src_sample_rate_hz,
                                   int dst_channels,
-                                  int dst_sample_rate_hz,
-                                  FunctionToTest function) {
+                                  int dst_sample_rate_hz) {
   PushResampler<int16_t> resampler;  // Create a new one with every test.
   const int16_t kSrcLeft = 30;  // Shouldn't overflow for any used sample rate.
   const int16_t kSrcRight = 15;
   const float resampling_factor = (1.0 * src_sample_rate_hz) /
       dst_sample_rate_hz;
   const float dst_left = resampling_factor * kSrcLeft;
   const float dst_right = resampling_factor * kSrcRight;
   const float dst_mono = (dst_left + dst_right) / 2;
   if (src_channels == 1)
     SetMonoFrame(&src_frame_, kSrcLeft, src_sample_rate_hz);
@@ skipping 16 matching lines @@
 
   // The sinc resampler has a known delay, which we compute here. Multiplying by
   // two gives us a crude maximum for any resampling, as the old resampler
   // typically (but not always) has lower delay.
   static const size_t kInputKernelDelaySamples = 16;
   const size_t max_delay = static_cast<size_t>(
       static_cast<double>(dst_sample_rate_hz) / src_sample_rate_hz *
       kInputKernelDelaySamples * dst_channels * 2);
   printf("(%d, %d Hz) -> (%d, %d Hz) ",  // SNR reported on the same line later.
       src_channels, src_sample_rate_hz, dst_channels, dst_sample_rate_hz);
-  if (function == TestRemixAndResample) {
-    RemixAndResample(src_frame_, &resampler, &dst_frame_);
-  } else {
-    int16_t mono_buffer[kMaxMonoDataSizeSamples];
-    DownConvertToCodecFormat(src_frame_.data_,
-                             src_frame_.samples_per_channel_,
-                             src_frame_.num_channels_,
-                             src_frame_.sample_rate_hz_,
-                             dst_frame_.num_channels_,
-                             dst_frame_.sample_rate_hz_,
-                             mono_buffer,
-                             &resampler,
-                             &dst_frame_);
-  }
+  RemixAndResample(src_frame_, &resampler, &dst_frame_);
 
   if (src_sample_rate_hz == 96000 && dst_sample_rate_hz == 8000) {
     // The sinc resampler gives poor SNR at this extreme conversion, but we
     // expect to see this rarely in practice.
     EXPECT_GT(ComputeSNR(golden_frame_, dst_frame_, max_delay), 14.0f);
   } else {
     EXPECT_GT(ComputeSNR(golden_frame_, dst_frame_, max_delay), 46.0f);
   }
 }
 
@@ skipping 30 matching lines @@
 TEST_F(UtilityTest, RemixAndResampleSucceeds) {
   const int kSampleRates[] = {8000, 16000, 32000, 44100, 48000, 96000};
   const int kSampleRatesSize = sizeof(kSampleRates) / sizeof(*kSampleRates);
   const int kChannels[] = {1, 2};
   const int kChannelsSize = sizeof(kChannels) / sizeof(*kChannels);
   for (int src_rate = 0; src_rate < kSampleRatesSize; src_rate++) {
     for (int dst_rate = 0; dst_rate < kSampleRatesSize; dst_rate++) {
       for (int src_channel = 0; src_channel < kChannelsSize; src_channel++) {
         for (int dst_channel = 0; dst_channel < kChannelsSize; dst_channel++) {
           RunResampleTest(kChannels[src_channel], kSampleRates[src_rate],
-                          kChannels[dst_channel], kSampleRates[dst_rate],
-                          TestRemixAndResample);
+                          kChannels[dst_channel], kSampleRates[dst_rate]);
         }
       }
     }
-  }
-}
-
-TEST_F(UtilityTest, ConvertToCodecFormatSucceeds) {
-  const int kSampleRates[] = {8000, 16000, 32000, 44100, 48000, 96000};
-  const int kSampleRatesSize = sizeof(kSampleRates) / sizeof(*kSampleRates);
-  const int kChannels[] = {1, 2};
-  const int kChannelsSize = sizeof(kChannels) / sizeof(*kChannels);
-  for (int src_rate = 0; src_rate < kSampleRatesSize; src_rate++) {
-    for (int dst_rate = 0; dst_rate < kSampleRatesSize; dst_rate++) {
-      for (int src_channel = 0; src_channel < kChannelsSize; src_channel++) {
-        for (int dst_channel = 0; dst_channel < kChannelsSize; dst_channel++) {
-          if (dst_rate <= src_rate && dst_channel <= src_channel) {
-            RunResampleTest(kChannels[src_channel], kSampleRates[src_rate],
-                            kChannels[src_channel], kSampleRates[dst_rate],
-                            TestDownConvertToCodecFormat);
-          }
-        }
-      }
-    }
   }
 }
 
 }  // namespace
 }  // namespace voe
 }  // namespace webrtc