media/audio/win/audio_unified_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 "base/basictypes.h"
   6 #include "base/command_line.h"
   7 #include "base/file_util.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/path_service.h"
  10 #include "base/test/test_timeouts.h"
  11 #include "base/time/time.h"
  12 #include "base/win/scoped_com_initializer.h"
  13 #include "media/audio/audio_io.h"
  14 #include "media/audio/audio_manager.h"
  15 #include "media/audio/audio_util.h"
  16 #include "media/audio/win/audio_unified_win.h"
  17 #include "media/audio/win/core_audio_util_win.h"
  18 #include "media/base/channel_mixer.h"
  19 #include "media/base/media_switches.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 using ::testing::_;
  24 using ::testing::AtLeast;
  25 using ::testing::Between;
  26 using ::testing::DoAll;
  27 using ::testing::NotNull;
  28 using ::testing::Return;
  29 using base::win::ScopedCOMInitializer;
  30
  31 namespace media {
  32
  33 static const size_t kMaxDeltaSamples = 1000;
  34 static const char kDeltaTimeMsFileName[] = "unified_delta_times_ms.txt";
  35
  36 // Verify that the delay estimate in the OnMoreIOData() callback is larger
  37 // than an expected minumum value.
  38 MATCHER_P(DelayGreaterThan, value, "") {
  39   return (arg.hardware_delay_bytes > value.hardware_delay_bytes);
  40 }
  41
  42 // Used to terminate a loop from a different thread than the loop belongs to.
  43 // |loop| should be a MessageLoopProxy.
  44 ACTION_P(QuitLoop, loop) {
  45   loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
  46 }
  47
  48 class MockUnifiedSourceCallback
  49     : public AudioOutputStream::AudioSourceCallback {
  50  public:
  51   MOCK_METHOD2(OnMoreData, int(AudioBus* audio_bus,
  52                                AudioBuffersState buffers_state));
  53   MOCK_METHOD3(OnMoreIOData, int(AudioBus* source,
  54                                  AudioBus* dest,
  55                                  AudioBuffersState buffers_state));
  56   MOCK_METHOD1(OnError, void(AudioOutputStream* stream));
  57 };
  58
  59 // AudioOutputStream::AudioSourceCallback implementation which enables audio
  60 // play-through. It also creates a text file that contains times between two
  61 // successive callbacks. Units are in milliseconds. This file can be used for
  62 // off-line analysis of the callback sequence.
  63 class UnifiedSourceCallback : public AudioOutputStream::AudioSourceCallback {
  64  public:
  65   explicit UnifiedSourceCallback()
  66       : previous_call_time_(base::TimeTicks::Now()),
  67         text_file_(NULL),
  68         elements_to_write_(0) {
  69     delta_times_.reset(new int[kMaxDeltaSamples]);
  70   }
  71
  72   virtual ~UnifiedSourceCallback() {
  73     base::FilePath file_name;
  74     EXPECT_TRUE(PathService::Get(base::DIR_EXE, &file_name));
  75     file_name = file_name.AppendASCII(kDeltaTimeMsFileName);
  76
  77     EXPECT_TRUE(!text_file_);
  78     text_file_ = file_util::OpenFile(file_name, "wt");
  79     DLOG_IF(ERROR, !text_file_) << "Failed to open log file.";
  80     LOG(INFO) << ">> Output file " << file_name.value() << " has been created.";
  81
  82     // Write the array which contains delta times to a text file.
  83     size_t elements_written = 0;
  84     while (elements_written < elements_to_write_) {
  85       fprintf(text_file_, "%d\n", delta_times_[elements_written]);
  86       ++elements_written;
  87     }
  88     file_util::CloseFile(text_file_);
  89   }
  90
  91   virtual int OnMoreData(AudioBus* dest,
  92                          AudioBuffersState buffers_state) {
  93     NOTREACHED();
  94     return 0;
  95   };
  96
  97   virtual int OnMoreIOData(AudioBus* source,
  98                            AudioBus* dest,
  99                            AudioBuffersState buffers_state) {
 100     // Store time between this callback and the previous callback.
 101     const base::TimeTicks now_time = base::TimeTicks::Now();
 102     const int diff = (now_time - previous_call_time_).InMilliseconds();
 103     previous_call_time_ = now_time;
 104     if (elements_to_write_ < kMaxDeltaSamples) {
 105       delta_times_[elements_to_write_] = diff;
 106       ++elements_to_write_;
 107     }
 108
 109     // Play out the recorded audio samples in loop back. Perform channel mixing
 110     // if required using a channel mixer which is created only if needed.
 111     if (source->channels() == dest->channels()) {
 112       source->CopyTo(dest);
 113     } else {
 114       // A channel mixer is required for converting audio between two different
 115       // channel layouts.
 116       if (!channel_mixer_) {
 117         // Guessing the channel layout will work OK for this unit test.
 118         // Main thing is that the number of channels is correct.
 119         ChannelLayout input_layout = GuessChannelLayout(source->channels());
 120         ChannelLayout output_layout = GuessChannelLayout(dest->channels());
 121         channel_mixer_.reset(new ChannelMixer(input_layout, output_layout));
 122         DVLOG(1) << "Remixing channel layout from " << input_layout
 123                  << " to " << output_layout << "; from "
 124                  << source->channels() << " channels to "
 125                  << dest->channels() << " channels.";
 126       }
 127       if (channel_mixer_)
 128         channel_mixer_->Transform(source, dest);
 129     }
 130     return source->frames();
 131   };
 132
 133   virtual void OnError(AudioOutputStream* stream) {
 134     NOTREACHED();
 135   }
 136
 137  private:
 138   base::TimeTicks previous_call_time_;
 139   scoped_ptr<int[]> delta_times_;
 140   FILE* text_file_;
 141   size_t elements_to_write_;
 142   scoped_ptr<ChannelMixer> channel_mixer_;
 143 };
 144
 145 // Convenience method which ensures that we fulfill all required conditions
 146 // to run unified audio tests on Windows.
 147 static bool CanRunUnifiedAudioTests(AudioManager* audio_man) {
 148   if (!CoreAudioUtil::IsSupported()) {
 149     LOG(WARNING) << "This tests requires Windows Vista or higher.";
 150     return false;
 151   }
 152
 153   if (!audio_man->HasAudioOutputDevices()) {
 154     LOG(WARNING) << "No output devices detected.";
 155     return false;
 156   }
 157
 158   if (!audio_man->HasAudioInputDevices()) {
 159     LOG(WARNING) << "No input devices detected.";
 160     return false;
 161   }
 162
 163   return true;
 164 }
 165
 166 // Convenience class which simplifies creation of a unified AudioOutputStream
 167 // object.
 168 class AudioUnifiedStreamWrapper {
 169  public:
 170   explicit AudioUnifiedStreamWrapper(AudioManager* audio_manager)
 171       : com_init_(ScopedCOMInitializer::kMTA),
 172         audio_man_(audio_manager) {
 173     // We open up both both sides (input and output) using the preferred
 174     // set of audio parameters. These parameters corresponds to the mix format
 175     // that the audio engine uses internally for processing of shared-mode
 176     // output streams.
 177     AudioParameters out_params;
 178     EXPECT_TRUE(SUCCEEDED(CoreAudioUtil::GetPreferredAudioParameters(
 179         eRender, eConsole, &out_params)));
 180
 181     // WebAudio is the only real user of unified audio and it always asks
 182     // for stereo.
 183     // TODO(henrika): extend support to other input channel layouts as well.
 184     const int kInputChannels = 2;
 185
 186     params_.Reset(out_params.format(),
 187                   out_params.channel_layout(),
 188                   out_params.channels(),
 189                   kInputChannels,
 190                   out_params.sample_rate(),
 191                   out_params.bits_per_sample(),
 192                   out_params.frames_per_buffer());
 193   }
 194
 195   ~AudioUnifiedStreamWrapper() {}
 196
 197   // Creates an AudioOutputStream object using default parameters.
 198   WASAPIUnifiedStream* Create() {
 199     return static_cast<WASAPIUnifiedStream*> (CreateOutputStream());
 200   }
 201
 202   // Creates an AudioOutputStream object using default parameters but a
 203   // specified input device.
 204   WASAPIUnifiedStream* Create(const std::string device_id) {
 205     return static_cast<WASAPIUnifiedStream*> (CreateOutputStream(device_id));
 206   }
 207
 208   AudioParameters::Format format() const { return params_.format(); }
 209   int channels() const { return params_.channels(); }
 210   int bits_per_sample() const { return params_.bits_per_sample(); }
 211   int sample_rate() const { return params_.sample_rate(); }
 212   int frames_per_buffer() const { return params_.frames_per_buffer(); }
 213   int bytes_per_buffer() const { return params_.GetBytesPerBuffer(); }
 214   int input_channels() const { return params_.input_channels(); }
 215
 216  private:
 217   AudioOutputStream* CreateOutputStream() {
 218     // Get the unique device ID of the default capture device instead of using
 219     // AudioManagerBase::kDefaultDeviceId since it provides slightly better
 220     // test coverage and will utilize the same code path as if a non default
 221     // input device was used.
 222     ScopedComPtr<IMMDevice> audio_device =
 223       CoreAudioUtil::CreateDefaultDevice(eCapture, eConsole);
 224     AudioDeviceName name;
 225     EXPECT_TRUE(SUCCEEDED(CoreAudioUtil::GetDeviceName(audio_device, &name)));
 226     const std::string& device_id = name.unique_id;
 227     EXPECT_TRUE(CoreAudioUtil::DeviceIsDefault(eCapture, eConsole, device_id));
 228
 229     // Create the unified audio I/O stream using the default input device.
 230     AudioOutputStream* aos = audio_man_->MakeAudioOutputStream(params_,
 231                                                                device_id);
 232     EXPECT_TRUE(aos);
 233     return aos;
 234   }
 235
 236   AudioOutputStream* CreateOutputStream(const std::string& device_id) {
 237     // Create the unified audio I/O stream using the specified input device.
 238     AudioOutputStream* aos = audio_man_->MakeAudioOutputStream(params_,
 239                                                                device_id);
 240     EXPECT_TRUE(aos);
 241     return aos;
 242   }
 243
 244   ScopedCOMInitializer com_init_;
 245   AudioManager* audio_man_;
 246   AudioParameters params_;
 247 };
 248
 249 // Convenience method which creates a default WASAPIUnifiedStream object.
 250 static WASAPIUnifiedStream* CreateDefaultUnifiedStream(
 251     AudioManager* audio_manager) {
 252   AudioUnifiedStreamWrapper aosw(audio_manager);
 253   return aosw.Create();
 254 }
 255
 256 // Convenience method which creates a default WASAPIUnifiedStream object but
 257 // with a specified audio input device.
 258 static WASAPIUnifiedStream* CreateDefaultUnifiedStream(
 259     AudioManager* audio_manager, const std::string& device_id) {
 260   AudioUnifiedStreamWrapper aosw(audio_manager);
 261   return aosw.Create(device_id);
 262 }
 263
 264 // Test Open(), Close() calling sequence.
 265 TEST(WASAPIUnifiedStreamTest, OpenAndClose) {
 266   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 267   if (!CanRunUnifiedAudioTests(audio_manager.get()))
 268     return;
 269
 270   WASAPIUnifiedStream* wus = CreateDefaultUnifiedStream(audio_manager.get());
 271   EXPECT_TRUE(wus->Open());
 272   wus->Close();
 273 }
 274
 275 // Test Open(), Close() calling sequence for all available capture devices.
 276 TEST(WASAPIUnifiedStreamTest, OpenAndCloseForAllInputDevices) {
 277   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 278   if (!CanRunUnifiedAudioTests(audio_manager.get()))
 279     return;
 280
 281   AudioDeviceNames device_names;
 282   audio_manager->GetAudioInputDeviceNames(&device_names);
 283   for (AudioDeviceNames::iterator i = device_names.begin();
 284        i != device_names.end(); ++i) {
 285     WASAPIUnifiedStream* wus = CreateDefaultUnifiedStream(
 286         audio_manager.get(), i->unique_id);
 287     EXPECT_TRUE(wus->Open());
 288     wus->Close();
 289   }
 290 }
 291
 292 // Test Open(), Start(), Close() calling sequence.
 293 TEST(WASAPIUnifiedStreamTest, OpenStartAndClose) {
 294   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 295   if (!CanRunUnifiedAudioTests(audio_manager.get()))
 296     return;
 297
 298   MockUnifiedSourceCallback source;
 299   AudioUnifiedStreamWrapper ausw(audio_manager.get());
 300   WASAPIUnifiedStream* wus = ausw.Create();
 301
 302   EXPECT_TRUE(wus->Open());
 303   EXPECT_CALL(source, OnError(wus))
 304       .Times(0);
 305   EXPECT_CALL(source, OnMoreIOData(NotNull(), NotNull(), _))
 306       .Times(Between(0, 1))
 307       .WillOnce(Return(ausw.frames_per_buffer()));
 308   wus->Start(&source);
 309   wus->Close();
 310 }
 311
 312 // Verify that IO callbacks starts as they should.
 313 TEST(WASAPIUnifiedStreamTest, StartLoopbackAudio) {
 314   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 315   if (!CanRunUnifiedAudioTests(audio_manager.get()))
 316     return;
 317
 318   base::MessageLoopForUI loop;
 319   MockUnifiedSourceCallback source;
 320   AudioUnifiedStreamWrapper ausw(audio_manager.get());
 321   WASAPIUnifiedStream* wus = ausw.Create();
 322
 323   // Set up expected minimum delay estimation where we use a minium delay
 324   // which is equal to the sum of render and capture sizes. We can never
 325   // reach a delay lower than this value.
 326   AudioBuffersState min_total_audio_delay(0, 2 * ausw.bytes_per_buffer());
 327
 328   EXPECT_TRUE(wus->Open());
 329   EXPECT_CALL(source, OnError(wus))
 330       .Times(0);
 331   EXPECT_CALL(source, OnMoreIOData(
 332       NotNull(), NotNull(), DelayGreaterThan(min_total_audio_delay)))
 333       .Times(AtLeast(2))
 334       .WillOnce(Return(ausw.frames_per_buffer()))
 335       .WillOnce(DoAll(
 336           QuitLoop(loop.message_loop_proxy()),
 337           Return(ausw.frames_per_buffer())));
 338   wus->Start(&source);
 339   loop.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
 340                        TestTimeouts::action_timeout());
 341   loop.Run();
 342   wus->Stop();
 343   wus->Close();
 344 }
 345
 346 // Perform a real-time test in loopback where the recorded audio is echoed
 347 // back to the speaker. This test allows the user to verify that the audio
 348 // sounds OK. A text file with name |kDeltaTimeMsFileName| is also generated.
 349 TEST(WASAPIUnifiedStreamTest, DISABLED_RealTimePlayThrough) {
 350   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
 351   if (!CanRunUnifiedAudioTests(audio_manager.get()))
 352     return;
 353
 354   base::MessageLoopForUI loop;
 355   UnifiedSourceCallback source;
 356   WASAPIUnifiedStream* wus = CreateDefaultUnifiedStream(audio_manager.get());
 357
 358   EXPECT_TRUE(wus->Open());
 359   wus->Start(&source);
 360   loop.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
 361                        base::TimeDelta::FromMilliseconds(10000));
 362   loop.Run();
 363   wus->Close();
 364 }
 365
 366 }  // namespace media