Add basic resample support to WASAPIAudioInputStream.

media/audio/win/audio_low_latency_input_win_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/win/audio_low_latency_input_win.h"
 
-#include <windows.h>
 #include <mmsystem.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <windows.h>
 
 #include <memory>
 
 #include "base/environment.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 36 matching lines @@
   FakeAudioInputCallback()
       : num_received_audio_frames_(0),
         data_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                     base::WaitableEvent::InitialState::NOT_SIGNALED),
         error_(false) {}
 
   bool error() const { return error_; }
   int num_received_audio_frames() const { return num_received_audio_frames_; }
 
   // Waits until OnData() is called on another thread.
-  void WaitForData() {
-    data_event_.Wait();
-  }
+  void WaitForData() { data_event_.Wait(); }
 
   void OnData(AudioInputStream* stream,
               const AudioBus* src,
               uint32_t hardware_delay_bytes,
               double volume) override {
     EXPECT_GE(hardware_delay_bytes, 0u);
     EXPECT_LT(hardware_delay_bytes, 0xFFFFu);  // Arbitrarily picked.
     num_received_audio_frames_ += src->frames();
     data_event_.Signal();
   }
 
-  void OnError(AudioInputStream* stream) override {
-    error_ = true;
-  }
+  void OnError(AudioInputStream* stream) override { error_ = true; }
 
  private:
   int num_received_audio_frames_;
   base::WaitableEvent data_event_;
   bool error_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAudioInputCallback);
 };
 
 // This audio sink implementation should be used for manual tests only since
@@ skipping 76 matching lines @@
 class AudioInputStreamWrapper {
  public:
   explicit AudioInputStreamWrapper(AudioManager* audio_manager)
       : audio_man_(audio_manager) {
     EXPECT_TRUE(SUCCEEDED(CoreAudioUtil::GetPreferredAudioParameters(
         AudioDeviceDescription::kDefaultDeviceId, false, &default_params_)));
     EXPECT_EQ(format(), AudioParameters::AUDIO_PCM_LOW_LATENCY);
     frames_per_buffer_ = default_params_.frames_per_buffer();
   }
 
+  AudioInputStreamWrapper(AudioManager* audio_manager,
+                          const AudioParameters& default_params)
+      : audio_man_(audio_manager), default_params_(default_params) {
+    EXPECT_EQ(format(), AudioParameters::AUDIO_PCM_LOW_LATENCY);
+    frames_per_buffer_ = default_params_.frames_per_buffer();
+  }
+
   ~AudioInputStreamWrapper() {}
 
   // Creates AudioInputStream object using default parameters.
-  AudioInputStream* Create() {
-    return CreateInputStream();
-  }
+  AudioInputStream* Create() { return CreateInputStream(); }
 
   // Creates AudioInputStream object using non-default parameters where the
   // frame size is modified.
   AudioInputStream* Create(int frames_per_buffer) {
     frames_per_buffer_ = frames_per_buffer;
     return CreateInputStream();
   }
 
   AudioParameters::Format format() const { return default_params_.format(); }
   int channels() const {
@@ skipping 22 matching lines @@
 // Convenience method which creates a default AudioInputStream object.
 static AudioInputStream* CreateDefaultAudioInputStream(
     AudioManager* audio_manager) {
   AudioInputStreamWrapper aisw(audio_manager);
   AudioInputStream* ais = aisw.Create();
   return ais;
 }
 
 class ScopedAudioInputStream {
  public:
-  explicit ScopedAudioInputStream(AudioInputStream* stream)
-      : stream_(stream) {}
+  explicit ScopedAudioInputStream(AudioInputStream* stream) : stream_(stream) {}
 
   ~ScopedAudioInputStream() {
     if (stream_)
       stream_->Close();
   }
 
   void Close() {
     if (stream_)
       stream_->Close();
     stream_ = NULL;
   }
 
-  AudioInputStream* operator->() {
-    return stream_;
-  }
+  AudioInputStream* operator->() { return stream_; }
 
   AudioInputStream* get() const { return stream_; }
 
   void Reset(AudioInputStream* new_stream) {
     Close();
     stream_ = new_stream;
   }
 
  private:
   AudioInputStream* stream_;
@@ skipping 142 matching lines @@
   // Store current packet size (to be used in the subsequent tests).
   int frames_per_buffer_10ms = aisw.frames_per_buffer();
 
   ais.Close();
 
   // 20 ms packet size.
 
   count = 0;
   ais.Reset(aisw.Create(2 * frames_per_buffer_10ms));
   EXPECT_TRUE(ais->Open());
-  bytes_per_packet = aisw.channels() * aisw.frames_per_buffer() *
-      (aisw.bits_per_sample() / 8);
+  bytes_per_packet =
+      aisw.channels() * aisw.frames_per_buffer() * (aisw.bits_per_sample() / 8);
 
   {
     base::RunLoop run_loop;
     EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _))
         .Times(AtLeast(10))
         .WillRepeatedly(
             CheckCountAndPostQuitTask(&count, 10, message_loop_.task_runner(),
                                       run_loop.QuitWhenIdleClosure()));
     ais->Start(&sink);
     run_loop.Run();
     ais->Stop();
     ais.Close();
   }
 
   // 5 ms packet size.
 
   count = 0;
   ais.Reset(aisw.Create(frames_per_buffer_10ms / 2));
   EXPECT_TRUE(ais->Open());
-  bytes_per_packet = aisw.channels() * aisw.frames_per_buffer() *
-    (aisw.bits_per_sample() / 8);
+  bytes_per_packet =
+      aisw.channels() * aisw.frames_per_buffer() * (aisw.bits_per_sample() / 8);
 
   {
     base::RunLoop run_loop;
     EXPECT_CALL(sink, OnData(ais.get(), NotNull(), _, _))
         .Times(AtLeast(10))
         .WillRepeatedly(
             CheckCountAndPostQuitTask(&count, 10, message_loop_.task_runner(),
                                       run_loop.QuitWhenIdleClosure()));
     ais->Start(&sink);
     run_loop.Run();
@@ skipping 36 matching lines @@
 // By default, GTest will print out YOU HAVE 1 DISABLED TEST.
 // To include disabled tests in test execution, just invoke the test program
 // with --gtest_also_run_disabled_tests or set the GTEST_ALSO_RUN_DISABLED_TESTS
 // environment variable to a value greater than 0.
 TEST_F(WinAudioInputTest, DISABLED_WASAPIAudioInputStreamRecordToFile) {
   ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager_.get()));
 
   // Name of the output PCM file containing captured data. The output file
   // will be stored in the directory containing 'media_unittests.exe'.
   // Example of full name: \src\build\Debug\out_stereo_10sec.pcm.
-  const char* file_name = "out_stereo_10sec.pcm";
+  const char* file_name = "out_10sec.pcm";
 
   AudioInputStreamWrapper aisw(audio_manager_.get());
   ScopedAudioInputStream ais(aisw.Create());
-  EXPECT_TRUE(ais->Open());
+  ASSERT_TRUE(ais->Open());
 
   VLOG(0) << ">> Sample rate: " << aisw.sample_rate() << " [Hz]";
   WriteToFileAudioSink file_sink(file_name, aisw.bits_per_sample());
   VLOG(0) << ">> Speak into the default microphone while recording.";
   ais->Start(&file_sink);
   base::PlatformThread::Sleep(TestTimeouts::action_timeout());
   ais->Stop();
   VLOG(0) << ">> Recording has stopped.";
   ais.Close();
 }
 
+TEST_F(WinAudioInputTest, DISABLED_WASAPIAudioInputStreamResampleToFile) {
+  ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndInputDevices(audio_manager_.get()));
+
+  // This is basically the same test as WASAPIAudioInputStreamRecordToFile
+  // except it forces use of a different sample rate than is preferred by
+  // the hardware.  This functionality is offered while we still have code
+  // that doesn't ask the lower levels for what the preferred audio parameters
+  // are (and previously depended on the old Wave API to do this automatically).
+
+  AudioParameters params;
+  ASSERT_TRUE(SUCCEEDED(CoreAudioUtil::GetPreferredAudioParameters(
+      AudioDeviceDescription::kDefaultDeviceId, false, &params)));
+
+  VLOG(0) << ">> Hardware sample rate: " << params.sample_rate() << " [Hz]";
+
+  params.set_sample_rate(params.sample_rate() == 48000 ? 44100 : 48000);
+  params.set_frames_per_buffer(params.sample_rate() / 100);
+
+  static const char kFileName[] = "out_10sec_resampled.pcm";
+
+  AudioInputStreamWrapper aisw(audio_manager_.get(), params);
+  ScopedAudioInputStream ais(aisw.Create());
+  ASSERT_TRUE(ais->Open());
+
+  VLOG(0) << ">> Resampled rate will be: " << aisw.sample_rate() << " [Hz]";
+  WriteToFileAudioSink file_sink(kFileName, aisw.bits_per_sample());
+  VLOG(0) << ">> Speak into the default microphone while recording.";
+  ais->Start(&file_sink);
+  base::PlatformThread::Sleep(TestTimeouts::action_timeout());
+  ais->Stop();
+  VLOG(0) << ">> Recording has stopped.";
+  ais.Close();
+}
+
 }  // namespace media