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"
+#include "base/strings/stringprintf.h"
 #include "base/test/test_timeouts.h"
 #include "base/win/scoped_com_initializer.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_unittest_util.h"
 #include "media/audio/win/core_audio_util_win.h"
 #include "media/base/seekable_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 26 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
 // the recorded data is stored on a raw binary data file.
 class WriteToFileAudioSink : public AudioInputStream::AudioInputCallback {
  public:
   // Allocate space for ~10 seconds of data @ 48kHz in stereo:
   // 2 bytes per sample, 2 channels, 10ms @ 48kHz, 10 seconds <=> 1920000 bytes.
   static const size_t kMaxBufferSize = 2 * 2 * 480 * 100 * 10;
 
   explicit WriteToFileAudioSink(const char* file_name, int bits_per_sample)
       : bits_per_sample_(bits_per_sample),
         buffer_(0, kMaxBufferSize),
         bytes_to_write_(0) {
     base::FilePath file_path;
     EXPECT_TRUE(PathService::Get(base::DIR_EXE, &file_path));
     file_path = file_path.AppendASCII(file_name);
     binary_file_ = base::OpenFile(file_path, "wb");
     DLOG_IF(ERROR, !binary_file_) << "Failed to open binary PCM data file.";
     VLOG(0) << ">> Output file: " << file_path.value() << " has been created.";
-    VLOG(0) << "bits_per_sample_:" << bits_per_sample_;
+    VLOG(0) << ">> bits_per_sample_:" << bits_per_sample_;
   }
 
   ~WriteToFileAudioSink() override {
     size_t bytes_written = 0;
     while (bytes_written < bytes_to_write_) {
       const uint8_t* chunk;
       int chunk_size;
 
       // Stop writing if no more data is available.
       if (!buffer_.GetCurrentChunk(&chunk, &chunk_size))
@@ skipping 48 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).
+
+  struct TestData {
+    const int rate;
+    const int frames;
+    ChannelLayout layout;
+  } tests[] = {
+      {8000, 80, CHANNEL_LAYOUT_MONO},
+      {8000, 80, CHANNEL_LAYOUT_STEREO},
+      {44100, 441, CHANNEL_LAYOUT_MONO},
+      {44100, 1024, CHANNEL_LAYOUT_STEREO},
+  };
+
+  for (const auto& test : tests) {
+    AudioParameters params;
+    ASSERT_TRUE(SUCCEEDED(CoreAudioUtil::GetPreferredAudioParameters(
+        AudioDeviceDescription::kDefaultDeviceId, false, &params)));
+
+    VLOG(0) << ">> Hardware sample rate: " << params.sample_rate() << " [Hz]";
+    VLOG(0) << ">> Hardware channel layout: "
+            << ChannelLayoutToString(params.channel_layout());
+
+    // Pick a somewhat difficult sample rate to convert too.
+    // If the sample rate is 8kHz, 16kHz, 32kHz, 48kHz etc, we convert to
+    // 44.1kHz.
+    // Otherwise (e.g. 44.1kHz, 22.05kHz etc) we convert to 48kHz.
+    const int hw_sample_rate = params.sample_rate();
+    params.Reset(params.format(), test.layout, test.rate,
+                 params.bits_per_sample(), test.frames);
+
+    std::string file_name(base::StringPrintf(
+        "resampled_10sec_%i_to_%i_%s.pcm", hw_sample_rate, params.sample_rate(),
+        ChannelLayoutToString(params.channel_layout())));
+
+    AudioInputStreamWrapper aisw(audio_manager_.get(), params);
+    ScopedAudioInputStream ais(aisw.Create());
+    ASSERT_TRUE(ais->Open());
+
+    VLOG(0) << ">> Resampled rate will be: " << aisw.sample_rate() << " [Hz]";
+    VLOG(0) << ">> New layout will be: "
+            << ChannelLayoutToString(params.channel_layout());
+    WriteToFileAudioSink file_sink(file_name.c_str(), aisw.bits_per_sample());
+    VLOG(0) << ">> Speak into the default microphone while recording.";
+    ais->Start(&file_sink);
+    base::PlatformThread::Sleep(TestTimeouts::action_timeout());
+    // base::PlatformThread::Sleep(base::TimeDelta::FromMinutes(10));
+    ais->Stop();
+    VLOG(0) << ">> Recording has stopped.";
+    ais.Close();
+  }
+}
+
 }  // namespace media