media/audio/virtual_audio_input_stream_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 <list>
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/rand_util.h"
  11 #include "base/synchronization/waitable_event.h"
  12 #include "base/threading/thread.h"
  13 #include "media/audio/audio_io.h"
  14 #include "media/audio/simple_sources.h"
  15 #include "media/audio/virtual_audio_input_stream.h"
  16 #include "media/audio/virtual_audio_output_stream.h"
  17 #include "testing/gmock/include/gmock/gmock.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using ::testing::_;
  21 using ::testing::AtLeast;
  22 using ::testing::InvokeWithoutArgs;
  23 using ::testing::NotNull;
  24
  25 namespace media {
  26
  27 namespace {
  28
  29 const AudioParameters kParams(
  30     AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO, 8000, 8, 10);
  31
  32 class MockInputCallback : public AudioInputStream::AudioInputCallback {
  33  public:
  34   MockInputCallback()
  35       : data_pushed_(false, false) {
  36     ON_CALL(*this, OnData(_, _, _, _, _))
  37         .WillByDefault(InvokeWithoutArgs(&data_pushed_,
  38                                          &base::WaitableEvent::Signal));
  39   }
  40
  41   virtual ~MockInputCallback() {}
  42
  43   MOCK_METHOD5(OnData, void(AudioInputStream* stream, const uint8* data,
  44                             uint32 size, uint32 hardware_delay_bytes,
  45                             double volume));
  46   MOCK_METHOD1(OnClose, void(AudioInputStream* stream));
  47   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
  48
  49   void WaitForDataPushes() {
  50     for (int i = 0; i < 3; ++i) {
  51       data_pushed_.Wait();
  52     }
  53   }
  54
  55  private:
  56   base::WaitableEvent data_pushed_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(MockInputCallback);
  59 };
  60
  61 class TestAudioSource : public SineWaveAudioSource {
  62  public:
  63   TestAudioSource()
  64       : SineWaveAudioSource(
  65             kParams.channel_layout(), 200.0, kParams.sample_rate()),
  66         data_pulled_(false, false) {}
  67
  68   virtual ~TestAudioSource() {}
  69
  70   virtual int OnMoreData(AudioBus* audio_bus,
  71                          AudioBuffersState audio_buffers) OVERRIDE {
  72     const int ret = SineWaveAudioSource::OnMoreData(audio_bus, audio_buffers);
  73     data_pulled_.Signal();
  74     return ret;
  75   }
  76
  77   virtual int OnMoreIOData(AudioBus* source,
  78                            AudioBus* dest,
  79                            AudioBuffersState audio_buffers) OVERRIDE {
  80     const int ret =
  81         SineWaveAudioSource::OnMoreIOData(source, dest, audio_buffers);
  82     data_pulled_.Signal();
  83     return ret;
  84   }
  85
  86   void WaitForDataPulls() {
  87     for (int i = 0; i < 3; ++i) {
  88       data_pulled_.Wait();
  89     }
  90   }
  91
  92  private:
  93   base::WaitableEvent data_pulled_;
  94
  95   DISALLOW_COPY_AND_ASSIGN(TestAudioSource);
  96 };
  97
  98 }  // namespace
  99
 100 class VirtualAudioInputStreamTest : public testing::TestWithParam<bool> {
 101  public:
 102   VirtualAudioInputStreamTest()
 103       : audio_thread_(new base::Thread("AudioThread")),
 104         worker_thread_(new base::Thread("AudioWorkerThread")),
 105         stream_(NULL),
 106         closed_stream_(false, false) {
 107     audio_thread_->Start();
 108     audio_message_loop_ = audio_thread_->message_loop_proxy();
 109   }
 110
 111   virtual ~VirtualAudioInputStreamTest() {
 112     SyncWithAudioThread();
 113
 114     DCHECK(output_streams_.empty());
 115     DCHECK(stopped_output_streams_.empty());
 116   }
 117
 118   void Create() {
 119     const bool worker_is_separate_thread = GetParam();
 120     stream_ = new VirtualAudioInputStream(
 121         kParams, GetWorkerLoop(worker_is_separate_thread),
 122         base::Bind(&base::DeletePointer<VirtualAudioInputStream>));
 123     stream_->Open();
 124   }
 125
 126   void Start() {
 127     EXPECT_CALL(input_callback_, OnClose(_));
 128     EXPECT_CALL(input_callback_, OnData(_, NotNull(), _, _, _))
 129         .Times(AtLeast(1));
 130
 131     ASSERT_TRUE(!!stream_);
 132     stream_->Start(&input_callback_);
 133   }
 134
 135   void CreateAndStartOneOutputStream() {
 136     ASSERT_TRUE(!!stream_);
 137     AudioOutputStream* const output_stream = new VirtualAudioOutputStream(
 138         kParams,
 139         stream_,
 140         base::Bind(&base::DeletePointer<VirtualAudioOutputStream>));
 141     output_streams_.push_back(output_stream);
 142
 143     output_stream->Open();
 144     output_stream->Start(&source_);
 145   }
 146
 147   void Stop() {
 148     ASSERT_TRUE(!!stream_);
 149     stream_->Stop();
 150   }
 151
 152   void Close() {
 153     ASSERT_TRUE(!!stream_);
 154     stream_->Close();
 155     stream_ = NULL;
 156     closed_stream_.Signal();
 157   }
 158
 159   void WaitForDataToFlow() {
 160     // Wait until audio thread is idle before calling output_streams_.size().
 161     SyncWithAudioThread();
 162
 163     const int count = output_streams_.size();
 164     for (int i = 0; i < count; ++i) {
 165       source_.WaitForDataPulls();
 166     }
 167
 168     input_callback_.WaitForDataPushes();
 169   }
 170
 171   void WaitUntilClosed() {
 172     closed_stream_.Wait();
 173   }
 174
 175   void StopAndCloseOneOutputStream() {
 176     ASSERT_TRUE(!output_streams_.empty());
 177     AudioOutputStream* const output_stream = output_streams_.front();
 178     ASSERT_TRUE(!!output_stream);
 179     output_streams_.pop_front();
 180
 181     output_stream->Stop();
 182     output_stream->Close();
 183   }
 184
 185   void StopFirstOutputStream() {
 186     ASSERT_TRUE(!output_streams_.empty());
 187     AudioOutputStream* const output_stream = output_streams_.front();
 188     ASSERT_TRUE(!!output_stream);
 189     output_streams_.pop_front();
 190     output_stream->Stop();
 191     stopped_output_streams_.push_back(output_stream);
 192   }
 193
 194   void StopSomeOutputStreams() {
 195     ASSERT_LE(2, static_cast<int>(output_streams_.size()));
 196     for (int remaning = base::RandInt(1, output_streams_.size() - 1);
 197          remaning > 0; --remaning) {
 198       StopFirstOutputStream();
 199     }
 200   }
 201
 202   void RestartAllStoppedOutputStreams() {
 203     typedef std::list<AudioOutputStream*>::const_iterator ConstIter;
 204     for (ConstIter it = stopped_output_streams_.begin();
 205          it != stopped_output_streams_.end(); ++it) {
 206       (*it)->Start(&source_);
 207       output_streams_.push_back(*it);
 208     }
 209     stopped_output_streams_.clear();
 210   }
 211
 212   const scoped_refptr<base::MessageLoopProxy>& audio_message_loop() const {
 213     return audio_message_loop_;
 214   }
 215
 216   const scoped_refptr<base::MessageLoopProxy>& GetWorkerLoop(
 217       bool worker_is_separate_thread) {
 218     if (worker_is_separate_thread) {
 219       if (!worker_thread_->IsRunning()) {
 220         worker_thread_->Start();
 221         worker_message_loop_ = worker_thread_->message_loop_proxy();
 222       }
 223       return worker_message_loop_;
 224     } else {
 225       return audio_message_loop_;
 226     }
 227   }
 228
 229  private:
 230   void SyncWithAudioThread() {
 231     base::WaitableEvent done(false, false);
 232     audio_message_loop_->PostTask(
 233         FROM_HERE,
 234         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done)));
 235     done.Wait();
 236   }
 237
 238   scoped_ptr<base::Thread> audio_thread_;
 239   scoped_refptr<base::MessageLoopProxy> audio_message_loop_;
 240   scoped_ptr<base::Thread> worker_thread_;
 241   scoped_refptr<base::MessageLoopProxy> worker_message_loop_;
 242
 243   VirtualAudioInputStream* stream_;
 244   MockInputCallback input_callback_;
 245   base::WaitableEvent closed_stream_;
 246
 247   std::list<AudioOutputStream*> output_streams_;
 248   std::list<AudioOutputStream*> stopped_output_streams_;
 249   TestAudioSource source_;
 250
 251   DISALLOW_COPY_AND_ASSIGN(VirtualAudioInputStreamTest);
 252 };
 253
 254 #define RUN_ON_AUDIO_THREAD(method)  \
 255   audio_message_loop()->PostTask(  \
 256       FROM_HERE, base::Bind(&VirtualAudioInputStreamTest::method,  \
 257                             base::Unretained(this)))
 258
 259 TEST_P(VirtualAudioInputStreamTest, CreateAndClose) {
 260   RUN_ON_AUDIO_THREAD(Create);
 261   RUN_ON_AUDIO_THREAD(Close);
 262   WaitUntilClosed();
 263 }
 264
 265 TEST_P(VirtualAudioInputStreamTest, NoOutputs) {
 266   RUN_ON_AUDIO_THREAD(Create);
 267   RUN_ON_AUDIO_THREAD(Start);
 268   WaitForDataToFlow();
 269   RUN_ON_AUDIO_THREAD(Stop);
 270   RUN_ON_AUDIO_THREAD(Close);
 271   WaitUntilClosed();
 272 }
 273
 274 TEST_P(VirtualAudioInputStreamTest, SingleOutput) {
 275   RUN_ON_AUDIO_THREAD(Create);
 276   RUN_ON_AUDIO_THREAD(Start);
 277   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
 278   WaitForDataToFlow();
 279   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
 280   RUN_ON_AUDIO_THREAD(Stop);
 281   RUN_ON_AUDIO_THREAD(Close);
 282   WaitUntilClosed();
 283 }
 284
 285 TEST_P(VirtualAudioInputStreamTest, SingleOutputPausedAndRestarted) {
 286   RUN_ON_AUDIO_THREAD(Create);
 287   RUN_ON_AUDIO_THREAD(Start);
 288   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
 289   WaitForDataToFlow();
 290   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
 291   RUN_ON_AUDIO_THREAD(RestartAllStoppedOutputStreams);
 292   WaitForDataToFlow();
 293   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
 294   RUN_ON_AUDIO_THREAD(Stop);
 295   RUN_ON_AUDIO_THREAD(Close);
 296   WaitUntilClosed();
 297 }
 298
 299 TEST_P(VirtualAudioInputStreamTest, MultipleOutputs) {
 300   RUN_ON_AUDIO_THREAD(Create);
 301   RUN_ON_AUDIO_THREAD(Start);
 302   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
 303   WaitForDataToFlow();
 304   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
 305   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
 306   WaitForDataToFlow();
 307   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
 308   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
 309   WaitForDataToFlow();
 310   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
 311   RUN_ON_AUDIO_THREAD(RestartAllStoppedOutputStreams);
 312   WaitForDataToFlow();
 313   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
 314   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
 315   RUN_ON_AUDIO_THREAD(Stop);
 316   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
 317   RUN_ON_AUDIO_THREAD(Close);
 318   WaitUntilClosed();
 319 }
 320
 321 // A combination of all of the above tests with many output streams.
 322 TEST_P(VirtualAudioInputStreamTest, ComprehensiveTest) {
 323   static const int kNumOutputs = 8;
 324   static const int kHalfNumOutputs = kNumOutputs / 2;
 325   static const int kPauseIterations = 5;
 326
 327   RUN_ON_AUDIO_THREAD(Create);
 328   for (int i = 0; i < kHalfNumOutputs; ++i) {
 329     RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
 330   }
 331   RUN_ON_AUDIO_THREAD(Start);
 332   WaitForDataToFlow();
 333   for (int i = 0; i < kHalfNumOutputs; ++i) {
 334     RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
 335   }
 336   WaitForDataToFlow();
 337   for (int i = 0; i < kPauseIterations; ++i) {
 338     RUN_ON_AUDIO_THREAD(StopSomeOutputStreams);
 339     WaitForDataToFlow();
 340     RUN_ON_AUDIO_THREAD(RestartAllStoppedOutputStreams);
 341     WaitForDataToFlow();
 342   }
 343   for (int i = 0; i < kHalfNumOutputs; ++i) {
 344     RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
 345   }
 346   RUN_ON_AUDIO_THREAD(Stop);
 347   for (int i = 0; i < kHalfNumOutputs; ++i) {
 348     RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
 349   }
 350   RUN_ON_AUDIO_THREAD(Close);
 351   WaitUntilClosed();
 352 }
 353
 354 INSTANTIATE_TEST_CASE_P(SingleVersusMultithreaded,
 355                         VirtualAudioInputStreamTest,
 356                         ::testing::Values(false, true));
 357
 358 }  // namespace media