media/audio/win/audio_low_latency_input_win_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <windows.h>
   6 #include <mmsystem.h>
   7
   8 #include "base/basictypes.h"
   9 #include "base/environment.h"
  10 #include "base/file_util.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/path_service.h"
  14 #include "base/test/test_timeouts.h"
  15 #include "base/win/scoped_com_initializer.h"
  16 #include "media/audio/audio_io.h"
  17 #include "media/audio/audio_manager_base.h"
  18 #include "media/audio/win/audio_low_latency_input_win.h"
  19 #include "media/audio/win/core_audio_util_win.h"
  20 #include "media/base/seekable_buffer.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 using base::win::ScopedCOMInitializer;
  25 using ::testing::_;
  26 using ::testing::AnyNumber;
  27 using ::testing::AtLeast;
  28 using ::testing::Gt;
  29 using ::testing::NotNull;
  30
  31 namespace media {
  32
  33 ACTION_P3(CheckCountAndPostQuitTask, count, limit, loop) {
  34   if (++*count >= limit) {
  35     loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
  36   }
  37 }
  38
  39 class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
  40  public:
  41   MOCK_METHOD5(OnData, void(AudioInputStream* stream,
  42                             const uint8* src, uint32 size,
  43                             uint32 hardware_delay_bytes, double volume));
  44   MOCK_METHOD1(OnClose, void(AudioInputStream* stream));
  45   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
  46 };
  47
  48 class FakeAudioInputCallback : public AudioInputStream::AudioInputCallback {
  49  public:
  50   FakeAudioInputCallback()
  51     : closed_(false),
  52       error_(false),
  53       data_event_(false, false) {
  54   }
  55
  56   const std::vector<uint8>& received_data() const { return received_data_; }
  57   bool closed() const { return closed_; }
  58   bool error() const { return error_; }
  59
  60   // Waits until OnData() is called on another thread.
  61   void WaitForData() {
  62     data_event_.Wait();
  63   }
  64
  65   virtual void OnData(AudioInputStream* stream,
  66                       const uint8* src, uint32 size,
  67                       uint32 hardware_delay_bytes, double volume) OVERRIDE {
  68     received_data_.insert(received_data_.end(), src, src + size);
  69     data_event_.Signal();
  70   }
  71
  72   virtual void OnClose(AudioInputStream* stream) OVERRIDE {
  73     closed_ = true;
  74   }
  75
  76   virtual void OnError(AudioInputStream* stream) OVERRIDE {
  77     error_ = true;
  78   }
  79
  80  private:
  81   std::vector<uint8> received_data_;
  82   base::WaitableEvent data_event_;
  83   bool closed_;
  84   bool error_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(FakeAudioInputCallback);
  87 };
  88
  89 // This audio sink implementation should be used for manual tests only since
  90 // the recorded data is stored on a raw binary data file.
  91 class WriteToFileAudioSink : public AudioInputStream::AudioInputCallback {
  92  public:
  93   // Allocate space for ~10 seconds of data @ 48kHz in stereo:
  94   // 2 bytes per sample, 2 channels, 10ms @ 48kHz, 10 seconds <=> 1920000 bytes.
  95   static const size_t kMaxBufferSize = 2 * 2 * 480 * 100 * 10;
  96
  97   explicit WriteToFileAudioSink(const char* file_name)
  98       : buffer_(0, kMaxBufferSize),
  99         bytes_to_write_(0) {
 100     base::FilePath file_path;
 101     EXPECT_TRUE(PathService::Get(base::DIR_EXE, &file_path));
 102     file_path = file_path.AppendASCII(file_name);
 103     binary_file_ = file_util::OpenFile(file_path, "wb");
 104     DLOG_IF(ERROR, !binary_file_) << "Failed to open binary PCM data file.";
 105     LOG(INFO) << ">> Output file: " << file_path.value()
 106               << " has been created.";
 107   }
 108
 109   virtual ~WriteToFileAudioSink() {
 110     size_t bytes_written = 0;
 111     while (bytes_written < bytes_to_write_) {
 112       const uint8* chunk;
 113       int chunk_size;
 114
 115       // Stop writing if no more data is available.
 116       if (!buffer_.GetCurrentChunk(&chunk, &chunk_size))
 117         break;
 118
 119       // Write recorded data chunk to the file and prepare for next chunk.
 120       fwrite(chunk, 1, chunk_size, binary_file_);
 121       buffer_.Seek(chunk_size);
 122       bytes_written += chunk_size;
 123     }
 124     file_util::CloseFile(binary_file_);
 125   }
 126
 127   // AudioInputStream::AudioInputCallback implementation.
 128   virtual void OnData(AudioInputStream* stream,
 129                       const uint8* src,
 130                       uint32 size,
 131                       uint32 hardware_delay_bytes,
 132                       double volume) {
 133     // Store data data in a temporary buffer to avoid making blocking
 134     // fwrite() calls in the audio callback. The complete buffer will be
 135     // written to file in the destructor.
 136     if (buffer_.Append(src, size)) {
 137       bytes_to_write_ += size;
 138     }
 139   }
 140
 141   virtual void OnClose(AudioInputStream* stream) {}
 142   virtual void OnError(AudioInputStream* stream) {}
 143
 144  private:
 145   media::SeekableBuffer buffer_;
 146   FILE* binary_file_;
 147   size_t bytes_to_write_;
 148 };
 149
 150 // Convenience method which ensures that we are not running on the build
 151 // bots and that at least one valid input device can be found. We also
 152 // verify that we are not running on XP since the low-latency (WASAPI-
 153 // based) version requires Windows Vista or higher.
 154 static bool CanRunAudioTests(AudioManager* audio_man) {
 155   if (!CoreAudioUtil::IsSupported()) {
 156     LOG(WARNING) << "This tests requires Windows Vista or higher.";
 157     return false;
 158   }
 159   // TODO(henrika): note that we use Wave today to query the number of
 160   // existing input devices.
 161   bool input = audio_man->HasAudioInputDevices();
 162   LOG_IF(WARNING, !input) << "No input device detected.";
 163   return input;
 164 }
 165
 166 // Convenience method which creates a default AudioInputStream object but
 167 // also allows the user to modify the default settings.
 168 class AudioInputStreamWrapper {
 169  public:
 170   explicit AudioInputStreamWrapper(AudioManager* audio_manager)
 171       : com_init_(ScopedCOMInitializer::kMTA),
 172         audio_man_(audio_manager),
 173         format_(AudioParameters::AUDIO_PCM_LOW_LATENCY),
 174         channel_layout_(CHANNEL_LAYOUT_STEREO),
 175         bits_per_sample_(16) {
 176     // Use native/mixing sample rate and 10ms frame size as default.
 177     sample_rate_ = static_cast<int>(
 178         WASAPIAudioInputStream::HardwareSampleRate(
 179             AudioManagerBase::kDefaultDeviceId));
 180     samples_per_packet_ = sample_rate_ / 100;
 181   }
 182
 183   ~AudioInputStreamWrapper() {}
 184
 185   // Creates AudioInputStream object using default parameters.
 186   AudioInputStream* Create() {
 187     return CreateInputStream();
 188   }
 189
 190   // Creates AudioInputStream object using non-default parameters where the
 191   // frame size is modified.
 192   AudioInputStream* Create(int samples_per_packet) {
 193     samples_per_packet_ = samples_per_packet;
 194     return CreateInputStream();
 195   }
 196
 197   AudioParameters::Format format() const { return format_; }
 198   int channels() const {
 199     return ChannelLayoutToChannelCount(channel_layout_);
 200   }
 201   int bits_per_sample() const { return bits_per_sample_; }
 202   int sample_rate() const { return sample_rate_; }
 203   int samples_per_packet() const { return samples_per_packet_; }
 204
 205  private:
 206   AudioInputStream* CreateInputStream() {
 207     AudioInputStream* ais = audio_man_->MakeAudioInputStream(
 208         AudioParameters(format_, channel_layout_, sample_rate_,
 209                         bits_per_sample_, samples_per_packet_),
 210                         AudioManagerBase::kDefaultDeviceId);
 211     EXPECT_TRUE(ais);
 212     return ais;
 213   }
 214
 215   ScopedCOMInitializer com_init_;
 216   AudioManager* audio_man_;
 217   AudioParameters::Format format_;
 218   ChannelLayout channel_layout_;
 219   int bits_per_sample_;
 220   int sample_rate_;
 221   int samples_per_packet_;
 222 };
 223
 224 // Convenience method which creates a default AudioInputStream object.
 225 static AudioInputStream* CreateDefaultAudioInputStream(
 226     AudioManager* audio_manager) {
 227   AudioInputStreamWrapper aisw(audio_manager);
 228   AudioInputStream* ais = aisw.Create();
 229   return ais;
 230 }
 231
 232 class ScopedAudioInputStream {
 233  public:
 234   explicit ScopedAudioInputStream(AudioInputStream* stream)
 235       : stream_(stream) {}
 236
 237   ~ScopedAudioInputStream() {
 238     if (stream_)
 239       stream_->Close();
 240   }
 241
 242   void Close() {
 243     if (stream_)
 244       stream_->Close();
 245     stream_ = NULL;
 246   }
 247
 248   AudioInputStream* operator->() {
 249     return stream_;
 250   }
 251
 252   AudioInputStream* get() const { return stream_; }
 253
 254   void Reset(AudioInputStream* new_stream) {
 255     Close();
 256     stream_ = new_stream;
 257   }
 258
 259  private:
 260   AudioInputStream* stream_;
 261
 262   DISALLOW_COPY_AND_ASSIGN(ScopedAudioInputStream);
 263 };
 264
 265 // Verify that we can retrieve the current hardware/mixing sample rate
 266 // for all available input devices.
 267 TEST(WinAudioInputTest, WASAPIAudioInputStreamHardwareSampleRate) {
 268   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 269   if (!CanRunAudioTests(audio_manager.get()))
 270     return;
 271
 272   ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
 273
 274   // Retrieve a list of all available input devices.
 275   media::AudioDeviceNames device_names;
 276   audio_manager->GetAudioInputDeviceNames(&device_names);
 277
 278   // Scan all available input devices and repeat the same test for all of them.
 279   for (media::AudioDeviceNames::const_iterator it = device_names.begin();
 280        it != device_names.end(); ++it) {
 281     // Retrieve the hardware sample rate given a specified audio input device.
 282     // TODO(tommi): ensure that we don't have to cast here.
 283     int fs = static_cast<int>(WASAPIAudioInputStream::HardwareSampleRate(
 284         it->unique_id));
 285     EXPECT_GE(fs, 0);
 286   }
 287 }
 288
 289 // Test Create(), Close() calling sequence.
 290 TEST(WinAudioInputTest, WASAPIAudioInputStreamCreateAndClose) {
 291   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 292   if (!CanRunAudioTests(audio_manager.get()))
 293     return;
 294   ScopedAudioInputStream ais(
 295       CreateDefaultAudioInputStream(audio_manager.get()));
 296   ais.Close();
 297 }
 298
 299 // Test Open(), Close() calling sequence.
 300 TEST(WinAudioInputTest, WASAPIAudioInputStreamOpenAndClose) {
 301   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 302   if (!CanRunAudioTests(audio_manager.get()))
 303     return;
 304   ScopedAudioInputStream ais(
 305       CreateDefaultAudioInputStream(audio_manager.get()));
 306   EXPECT_TRUE(ais->Open());
 307   ais.Close();
 308 }
 309
 310 // Test Open(), Start(), Close() calling sequence.
 311 TEST(WinAudioInputTest, WASAPIAudioInputStreamOpenStartAndClose) {
 312   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 313   if (!CanRunAudioTests(audio_manager.get()))
 314     return;
 315   ScopedAudioInputStream ais(
 316       CreateDefaultAudioInputStream(audio_manager.get()));
 317   EXPECT_TRUE(ais->Open());
 318   MockAudioInputCallback sink;
 319   ais->Start(&sink);
 320   EXPECT_CALL(sink, OnClose(ais.get()))
 321       .Times(1);
 322   ais.Close();
 323 }
 324
 325 // Test Open(), Start(), Stop(), Close() calling sequence.
 326 TEST(WinAudioInputTest, WASAPIAudioInputStreamOpenStartStopAndClose) {
 327   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 328   if (!CanRunAudioTests(audio_manager.get()))
 329     return;
 330   ScopedAudioInputStream ais(
 331       CreateDefaultAudioInputStream(audio_manager.get()));
 332   EXPECT_TRUE(ais->Open());
 333   MockAudioInputCallback sink;
 334   ais->Start(&sink);
 335   ais->Stop();
 336   EXPECT_CALL(sink, OnClose(ais.get()))
 337       .Times(1);
 338   ais.Close();
 339 }
 340
 341 // Test some additional calling sequences.
 342 TEST(WinAudioInputTest, WASAPIAudioInputStreamMiscCallingSequences) {
 343   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 344   if (!CanRunAudioTests(audio_manager.get()))
 345     return;
 346   ScopedAudioInputStream ais(
 347       CreateDefaultAudioInputStream(audio_manager.get()));
 348   WASAPIAudioInputStream* wais =
 349       static_cast<WASAPIAudioInputStream*>(ais.get());
 350
 351   // Open(), Open() should fail the second time.
 352   EXPECT_TRUE(ais->Open());
 353   EXPECT_FALSE(ais->Open());
 354
 355   MockAudioInputCallback sink;
 356
 357   // Start(), Start() is a valid calling sequence (second call does nothing).
 358   ais->Start(&sink);
 359   EXPECT_TRUE(wais->started());
 360   ais->Start(&sink);
 361   EXPECT_TRUE(wais->started());
 362
 363   // Stop(), Stop() is a valid calling sequence (second call does nothing).
 364   ais->Stop();
 365   EXPECT_FALSE(wais->started());
 366   ais->Stop();
 367   EXPECT_FALSE(wais->started());
 368
 369   EXPECT_CALL(sink, OnClose(ais.get()))
 370     .Times(1);
 371   ais.Close();
 372 }
 373
 374 TEST(WinAudioInputTest, WASAPIAudioInputStreamTestPacketSizes) {
 375   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 376   if (!CanRunAudioTests(audio_manager.get()))
 377     return;
 378
 379   int count = 0;
 380   base::MessageLoopForUI loop;
 381
 382   // 10 ms packet size.
 383
 384   // Create default WASAPI input stream which records in stereo using
 385   // the shared mixing rate. The default buffer size is 10ms.
 386   AudioInputStreamWrapper aisw(audio_manager.get());
 387   ScopedAudioInputStream ais(aisw.Create());
 388   EXPECT_TRUE(ais->Open());
 389
 390   MockAudioInputCallback sink;
 391
 392   // Derive the expected size in bytes of each recorded packet.
 393   uint32 bytes_per_packet = aisw.channels() * aisw.samples_per_packet() *
 394       (aisw.bits_per_sample() / 8);
 395
 396   // We use 10ms packets and will run the test until ten packets are received.
 397   // All should contain valid packets of the same size and a valid delay
 398   // estimate.
 399   EXPECT_CALL(sink, OnData(
 400       ais.get(), NotNull(), bytes_per_packet, Gt(bytes_per_packet), _))
 401       .Times(AtLeast(10))
 402       .WillRepeatedly(CheckCountAndPostQuitTask(&count, 10, &loop));
 403   ais->Start(&sink);
 404   loop.Run();
 405   ais->Stop();
 406
 407   // Store current packet size (to be used in the subsequent tests).
 408   int samples_per_packet_10ms = aisw.samples_per_packet();
 409
 410   EXPECT_CALL(sink, OnClose(ais.get()))
 411       .Times(1);
 412   ais.Close();
 413
 414   // 20 ms packet size.
 415
 416   count = 0;
 417   ais.Reset(aisw.Create(2 * samples_per_packet_10ms));
 418   EXPECT_TRUE(ais->Open());
 419   bytes_per_packet = aisw.channels() * aisw.samples_per_packet() *
 420       (aisw.bits_per_sample() / 8);
 421
 422   EXPECT_CALL(sink, OnData(
 423       ais.get(), NotNull(), bytes_per_packet, Gt(bytes_per_packet), _))
 424       .Times(AtLeast(10))
 425       .WillRepeatedly(CheckCountAndPostQuitTask(&count, 10, &loop));
 426   ais->Start(&sink);
 427   loop.Run();
 428   ais->Stop();
 429
 430   EXPECT_CALL(sink, OnClose(ais.get()))
 431       .Times(1);
 432   ais.Close();
 433
 434   // 5 ms packet size.
 435
 436   count = 0;
 437   ais.Reset(aisw.Create(samples_per_packet_10ms / 2));
 438   EXPECT_TRUE(ais->Open());
 439   bytes_per_packet = aisw.channels() * aisw.samples_per_packet() *
 440     (aisw.bits_per_sample() / 8);
 441
 442   EXPECT_CALL(sink, OnData(
 443       ais.get(), NotNull(), bytes_per_packet, Gt(bytes_per_packet), _))
 444       .Times(AtLeast(10))
 445       .WillRepeatedly(CheckCountAndPostQuitTask(&count, 10, &loop));
 446   ais->Start(&sink);
 447   loop.Run();
 448   ais->Stop();
 449
 450   EXPECT_CALL(sink, OnClose(ais.get()))
 451       .Times(1);
 452   ais.Close();
 453 }
 454
 455 // Test that we can capture loopback stream.
 456 TEST(WinAudioInputTest, WASAPIAudioInputStreamLoopback) {
 457   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 458   if (!audio_manager->HasAudioOutputDevices() || !CoreAudioUtil::IsSupported())
 459     return;
 460
 461   AudioParameters params = audio_manager->GetInputStreamParameters(
 462       AudioManagerBase::kLoopbackInputDeviceId);
 463
 464   AudioParameters output_params =
 465       audio_manager->GetOutputStreamParameters(std::string());
 466   EXPECT_EQ(params.sample_rate(), output_params.sample_rate());
 467   EXPECT_EQ(params.channel_layout(), output_params.channel_layout());
 468
 469   ScopedAudioInputStream stream(audio_manager->MakeAudioInputStream(
 470       params, AudioManagerBase::kLoopbackInputDeviceId));
 471   ASSERT_TRUE(stream->Open());
 472   FakeAudioInputCallback sink;
 473   stream->Start(&sink);
 474   ASSERT_FALSE(sink.error());
 475
 476   sink.WaitForData();
 477   stream.Close();
 478
 479   EXPECT_FALSE(sink.received_data().empty());
 480   EXPECT_TRUE(sink.closed());
 481   EXPECT_FALSE(sink.error());
 482 }
 483
 484 // This test is intended for manual tests and should only be enabled
 485 // when it is required to store the captured data on a local file.
 486 // By default, GTest will print out YOU HAVE 1 DISABLED TEST.
 487 // To include disabled tests in test execution, just invoke the test program
 488 // with --gtest_also_run_disabled_tests or set the GTEST_ALSO_RUN_DISABLED_TESTS
 489 // environment variable to a value greater than 0.
 490 TEST(WinAudioInputTest, DISABLED_WASAPIAudioInputStreamRecordToFile) {
 491   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 492   if (!CanRunAudioTests(audio_manager.get()))
 493     return;
 494
 495   // Name of the output PCM file containing captured data. The output file
 496   // will be stored in the directory containing 'media_unittests.exe'.
 497   // Example of full name: \src\build\Debug\out_stereo_10sec.pcm.
 498   const char* file_name = "out_stereo_10sec.pcm";
 499
 500   AudioInputStreamWrapper aisw(audio_manager.get());
 501   ScopedAudioInputStream ais(aisw.Create());
 502   EXPECT_TRUE(ais->Open());
 503
 504   LOG(INFO) << ">> Sample rate: " << aisw.sample_rate() << " [Hz]";
 505   WriteToFileAudioSink file_sink(file_name);
 506   LOG(INFO) << ">> Speak into the default microphone while recording.";
 507   ais->Start(&file_sink);
 508   base::PlatformThread::Sleep(TestTimeouts::action_timeout());
 509   ais->Stop();
 510   LOG(INFO) << ">> Recording has stopped.";
 511   ais.Close();
 512 }
 513
 514 }  // namespace media