Home | History | Annotate | Download | only in android 
      1 // Copyright 2013 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/android/build_info.h"
      6 #include "base/basictypes.h"
      7 #include "base/files/file_util.h"
      8 #include "base/memory/scoped_ptr.h"
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/path_service.h"
     11 #include "base/run_loop.h"
     12 #include "base/strings/stringprintf.h"
     13 #include "base/synchronization/lock.h"
     14 #include "base/synchronization/waitable_event.h"
     15 #include "base/test/test_timeouts.h"
     16 #include "base/time/time.h"
     17 #include "build/build_config.h"
     18 #include "media/audio/android/audio_manager_android.h"
     19 #include "media/audio/audio_io.h"
     20 #include "media/audio/audio_manager_base.h"
     21 #include "media/audio/mock_audio_source_callback.h"
     22 #include "media/base/decoder_buffer.h"
     23 #include "media/base/seekable_buffer.h"
     24 #include "media/base/test_data_util.h"
     25 #include "testing/gmock/include/gmock/gmock.h"
     26 #include "testing/gtest/include/gtest/gtest.h"
     27 
     28 using ::testing::_;
     29 using ::testing::AtLeast;
     30 using ::testing::DoAll;
     31 using ::testing::Invoke;
     32 using ::testing::NotNull;
     33 using ::testing::Return;
     34 
     35 namespace media {
     36 
     37 ACTION_P3(CheckCountAndPostQuitTask, count, limit, loop) {
     38   if (++*count >= limit) {
     39     loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
     40   }
     41 }
     42 
     43 static const char kSpeechFile_16b_s_48k[] = "speech_16b_stereo_48kHz.raw";
     44 static const char kSpeechFile_16b_m_48k[] = "speech_16b_mono_48kHz.raw";
     45 static const char kSpeechFile_16b_s_44k[] = "speech_16b_stereo_44kHz.raw";
     46 static const char kSpeechFile_16b_m_44k[] = "speech_16b_mono_44kHz.raw";
     47 
     48 static const float kCallbackTestTimeMs = 2000.0;
     49 static const int kBitsPerSample = 16;
     50 static const int kBytesPerSample = kBitsPerSample / 8;
     51 
     52 // Converts AudioParameters::Format enumerator to readable string.
     53 static std::string FormatToString(AudioParameters::Format format) {
     54   switch (format) {
     55     case AudioParameters::AUDIO_PCM_LINEAR:
     56       return std::string("AUDIO_PCM_LINEAR");
     57     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
     58       return std::string("AUDIO_PCM_LOW_LATENCY");
     59     case AudioParameters::AUDIO_FAKE:
     60       return std::string("AUDIO_FAKE");
     61     case AudioParameters::AUDIO_LAST_FORMAT:
     62       return std::string("AUDIO_LAST_FORMAT");
     63     default:
     64       return std::string();
     65   }
     66 }
     67 
     68 // Converts ChannelLayout enumerator to readable string. Does not include
     69 // multi-channel cases since these layouts are not supported on Android.
     70 static std::string LayoutToString(ChannelLayout channel_layout) {
     71   switch (channel_layout) {
     72     case CHANNEL_LAYOUT_NONE:
     73       return std::string("CHANNEL_LAYOUT_NONE");
     74     case CHANNEL_LAYOUT_MONO:
     75       return std::string("CHANNEL_LAYOUT_MONO");
     76     case CHANNEL_LAYOUT_STEREO:
     77       return std::string("CHANNEL_LAYOUT_STEREO");
     78     case CHANNEL_LAYOUT_UNSUPPORTED:
     79     default:
     80       return std::string("CHANNEL_LAYOUT_UNSUPPORTED");
     81   }
     82 }
     83 
     84 static double ExpectedTimeBetweenCallbacks(AudioParameters params) {
     85   return (base::TimeDelta::FromMicroseconds(
     86               params.frames_per_buffer() * base::Time::kMicrosecondsPerSecond /
     87               static_cast<double>(params.sample_rate()))).InMillisecondsF();
     88 }
     89 
     90 // Helper method which verifies that the device list starts with a valid
     91 // default device name followed by non-default device names.
     92 static void CheckDeviceNames(const AudioDeviceNames& device_names) {
     93   VLOG(2) << "Got " << device_names.size() << " audio devices.";
     94   if (device_names.empty()) {
     95     // Log a warning so we can see the status on the build bots.  No need to
     96     // break the test though since this does successfully test the code and
     97     // some failure cases.
     98     LOG(WARNING) << "No input devices detected";
     99     return;
    100   }
    101 
    102   AudioDeviceNames::const_iterator it = device_names.begin();
    103 
    104   // The first device in the list should always be the default device.
    105   EXPECT_EQ(std::string(AudioManagerBase::kDefaultDeviceName),
    106             it->device_name);
    107   EXPECT_EQ(std::string(AudioManagerBase::kDefaultDeviceId), it->unique_id);
    108   ++it;
    109 
    110   // Other devices should have non-empty name and id and should not contain
    111   // default name or id.
    112   while (it != device_names.end()) {
    113     EXPECT_FALSE(it->device_name.empty());
    114     EXPECT_FALSE(it->unique_id.empty());
    115     VLOG(2) << "Device ID(" << it->unique_id
    116             << "), label: " << it->device_name;
    117     EXPECT_NE(std::string(AudioManagerBase::kDefaultDeviceName),
    118               it->device_name);
    119     EXPECT_NE(std::string(AudioManagerBase::kDefaultDeviceId),
    120               it->unique_id);
    121     ++it;
    122   }
    123 }
    124 
    125 // We clear the data bus to ensure that the test does not cause noise.
    126 static int RealOnMoreData(AudioBus* dest, AudioBuffersState buffers_state) {
    127   dest->Zero();
    128   return dest->frames();
    129 }
    130 
    131 std::ostream& operator<<(std::ostream& os, const AudioParameters& params) {
    132   using namespace std;
    133   os << endl << "format: " << FormatToString(params.format()) << endl
    134      << "channel layout: " << LayoutToString(params.channel_layout()) << endl
    135      << "sample rate: " << params.sample_rate() << endl
    136      << "bits per sample: " << params.bits_per_sample() << endl
    137      << "frames per buffer: " << params.frames_per_buffer() << endl
    138      << "channels: " << params.channels() << endl
    139      << "bytes per buffer: " << params.GetBytesPerBuffer() << endl
    140      << "bytes per second: " << params.GetBytesPerSecond() << endl
    141      << "bytes per frame: " << params.GetBytesPerFrame() << endl
    142      << "chunk size in ms: " << ExpectedTimeBetweenCallbacks(params) << endl
    143      << "echo_canceller: "
    144      << (params.effects() & AudioParameters::ECHO_CANCELLER);
    145   return os;
    146 }
    147 
    148 // Gmock implementation of AudioInputStream::AudioInputCallback.
    149 class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
    150  public:
    151   MOCK_METHOD4(OnData,
    152                void(AudioInputStream* stream,
    153                     const AudioBus* src,
    154                     uint32 hardware_delay_bytes,
    155                     double volume));
    156   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
    157 };
    158 
    159 // Implements AudioOutputStream::AudioSourceCallback and provides audio data
    160 // by reading from a data file.
    161 class FileAudioSource : public AudioOutputStream::AudioSourceCallback {
    162  public:
    163   explicit FileAudioSource(base::WaitableEvent* event, const std::string& name)
    164       : event_(event), pos_(0) {
    165     // Reads a test file from media/test/data directory and stores it in
    166     // a DecoderBuffer.
    167     file_ = ReadTestDataFile(name);
    168 
    169     // Log the name of the file which is used as input for this test.
    170     base::FilePath file_path = GetTestDataFilePath(name);
    171     VLOG(0) << "Reading from file: " << file_path.value().c_str();
    172   }
    173 
    174   virtual ~FileAudioSource() {}
    175 
    176   // AudioOutputStream::AudioSourceCallback implementation.
    177 
    178   // Use samples read from a data file and fill up the audio buffer
    179   // provided to us in the callback.
    180   virtual int OnMoreData(AudioBus* audio_bus,
    181                          AudioBuffersState buffers_state) OVERRIDE {
    182     bool stop_playing = false;
    183     int max_size =
    184         audio_bus->frames() * audio_bus->channels() * kBytesPerSample;
    185 
    186     // Adjust data size and prepare for end signal if file has ended.
    187     if (pos_ + max_size > file_size()) {
    188       stop_playing = true;
    189       max_size = file_size() - pos_;
    190     }
    191 
    192     // File data is stored as interleaved 16-bit values. Copy data samples from
    193     // the file and deinterleave to match the audio bus format.
    194     // FromInterleaved() will zero out any unfilled frames when there is not
    195     // sufficient data remaining in the file to fill up the complete frame.
    196     int frames = max_size / (audio_bus->channels() * kBytesPerSample);
    197     if (max_size) {
    198       audio_bus->FromInterleaved(file_->data() + pos_, frames, kBytesPerSample);
    199       pos_ += max_size;
    200     }
    201 
    202     // Set event to ensure that the test can stop when the file has ended.
    203     if (stop_playing)
    204       event_->Signal();
    205 
    206     return frames;
    207   }
    208 
    209   virtual void OnError(AudioOutputStream* stream) OVERRIDE {}
    210 
    211   int file_size() { return file_->data_size(); }
    212 
    213  private:
    214   base::WaitableEvent* event_;
    215   int pos_;
    216   scoped_refptr<DecoderBuffer> file_;
    217 
    218   DISALLOW_COPY_AND_ASSIGN(FileAudioSource);
    219 };
    220 
    221 // Implements AudioInputStream::AudioInputCallback and writes the recorded
    222 // audio data to a local output file. Note that this implementation should
    223 // only be used for manually invoked and evaluated tests, hence the created
    224 // file will not be destroyed after the test is done since the intention is
    225 // that it shall be available for off-line analysis.
    226 class FileAudioSink : public AudioInputStream::AudioInputCallback {
    227  public:
    228   explicit FileAudioSink(base::WaitableEvent* event,
    229                          const AudioParameters& params,
    230                          const std::string& file_name)
    231       : event_(event), params_(params) {
    232     // Allocate space for ~10 seconds of data.
    233     const int kMaxBufferSize = 10 * params.GetBytesPerSecond();
    234     buffer_.reset(new media::SeekableBuffer(0, kMaxBufferSize));
    235 
    236     // Open up the binary file which will be written to in the destructor.
    237     base::FilePath file_path;
    238     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
    239     file_path = file_path.AppendASCII(file_name.c_str());
    240     binary_file_ = base::OpenFile(file_path, "wb");
    241     DLOG_IF(ERROR, !binary_file_) << "Failed to open binary PCM data file.";
    242     VLOG(0) << "Writing to file: " << file_path.value().c_str();
    243   }
    244 
    245   virtual ~FileAudioSink() {
    246     int bytes_written = 0;
    247     while (bytes_written < buffer_->forward_capacity()) {
    248       const uint8* chunk;
    249       int chunk_size;
    250 
    251       // Stop writing if no more data is available.
    252       if (!buffer_->GetCurrentChunk(&chunk, &chunk_size))
    253         break;
    254 
    255       // Write recorded data chunk to the file and prepare for next chunk.
    256       // TODO(henrika): use file_util:: instead.
    257       fwrite(chunk, 1, chunk_size, binary_file_);
    258       buffer_->Seek(chunk_size);
    259       bytes_written += chunk_size;
    260     }
    261     base::CloseFile(binary_file_);
    262   }
    263 
    264   // AudioInputStream::AudioInputCallback implementation.
    265   virtual void OnData(AudioInputStream* stream,
    266                       const AudioBus* src,
    267                       uint32 hardware_delay_bytes,
    268                       double volume) OVERRIDE {
    269     const int num_samples = src->frames() * src->channels();
    270     scoped_ptr<int16> interleaved(new int16[num_samples]);
    271     const int bytes_per_sample = sizeof(*interleaved);
    272     src->ToInterleaved(src->frames(), bytes_per_sample, interleaved.get());
    273 
    274     // Store data data in a temporary buffer to avoid making blocking
    275     // fwrite() calls in the audio callback. The complete buffer will be
    276     // written to file in the destructor.
    277     const int size = bytes_per_sample * num_samples;
    278     if (!buffer_->Append((const uint8*)interleaved.get(), size))
    279       event_->Signal();
    280   }
    281 
    282   virtual void OnError(AudioInputStream* stream) OVERRIDE {}
    283 
    284  private:
    285   base::WaitableEvent* event_;
    286   AudioParameters params_;
    287   scoped_ptr<media::SeekableBuffer> buffer_;
    288   FILE* binary_file_;
    289 
    290   DISALLOW_COPY_AND_ASSIGN(FileAudioSink);
    291 };
    292 
    293 // Implements AudioInputCallback and AudioSourceCallback to support full
    294 // duplex audio where captured samples are played out in loopback after
    295 // reading from a temporary FIFO storage.
    296 class FullDuplexAudioSinkSource
    297     : public AudioInputStream::AudioInputCallback,
    298       public AudioOutputStream::AudioSourceCallback {
    299  public:
    300   explicit FullDuplexAudioSinkSource(const AudioParameters& params)
    301       : params_(params),
    302         previous_time_(base::TimeTicks::Now()),
    303         started_(false) {
    304     // Start with a reasonably small FIFO size. It will be increased
    305     // dynamically during the test if required.
    306     fifo_.reset(new media::SeekableBuffer(0, 2 * params.GetBytesPerBuffer()));
    307     buffer_.reset(new uint8[params_.GetBytesPerBuffer()]);
    308   }
    309 
    310   virtual ~FullDuplexAudioSinkSource() {}
    311 
    312   // AudioInputStream::AudioInputCallback implementation
    313   virtual void OnData(AudioInputStream* stream,
    314                       const AudioBus* src,
    315                       uint32 hardware_delay_bytes,
    316                       double volume) OVERRIDE {
    317     const base::TimeTicks now_time = base::TimeTicks::Now();
    318     const int diff = (now_time - previous_time_).InMilliseconds();
    319 
    320     EXPECT_EQ(params_.bits_per_sample(), 16);
    321     const int num_samples = src->frames() * src->channels();
    322     scoped_ptr<int16> interleaved(new int16[num_samples]);
    323     const int bytes_per_sample = sizeof(*interleaved);
    324     src->ToInterleaved(src->frames(), bytes_per_sample, interleaved.get());
    325     const int size = bytes_per_sample * num_samples;
    326 
    327     base::AutoLock lock(lock_);
    328     if (diff > 1000) {
    329       started_ = true;
    330       previous_time_ = now_time;
    331 
    332       // Log out the extra delay added by the FIFO. This is a best effort
    333       // estimate. We might be +- 10ms off here.
    334       int extra_fifo_delay =
    335           static_cast<int>(BytesToMilliseconds(fifo_->forward_bytes() + size));
    336       DVLOG(1) << extra_fifo_delay;
    337     }
    338 
    339     // We add an initial delay of ~1 second before loopback starts to ensure
    340     // a stable callback sequence and to avoid initial bursts which might add
    341     // to the extra FIFO delay.
    342     if (!started_)
    343       return;
    344 
    345     // Append new data to the FIFO and extend the size if the max capacity
    346     // was exceeded. Flush the FIFO when extended just in case.
    347     if (!fifo_->Append((const uint8*)interleaved.get(), size)) {
    348       fifo_->set_forward_capacity(2 * fifo_->forward_capacity());
    349       fifo_->Clear();
    350     }
    351   }
    352 
    353   virtual void OnError(AudioInputStream* stream) OVERRIDE {}
    354 
    355   // AudioOutputStream::AudioSourceCallback implementation
    356   virtual int OnMoreData(AudioBus* dest,
    357                          AudioBuffersState buffers_state) OVERRIDE {
    358     const int size_in_bytes =
    359         (params_.bits_per_sample() / 8) * dest->frames() * dest->channels();
    360     EXPECT_EQ(size_in_bytes, params_.GetBytesPerBuffer());
    361 
    362     base::AutoLock lock(lock_);
    363 
    364     // We add an initial delay of ~1 second before loopback starts to ensure
    365     // a stable callback sequences and to avoid initial bursts which might add
    366     // to the extra FIFO delay.
    367     if (!started_) {
    368       dest->Zero();
    369       return dest->frames();
    370     }
    371 
    372     // Fill up destination with zeros if the FIFO does not contain enough
    373     // data to fulfill the request.
    374     if (fifo_->forward_bytes() < size_in_bytes) {
    375       dest->Zero();
    376     } else {
    377       fifo_->Read(buffer_.get(), size_in_bytes);
    378       dest->FromInterleaved(
    379           buffer_.get(), dest->frames(), params_.bits_per_sample() / 8);
    380     }
    381 
    382     return dest->frames();
    383   }
    384 
    385   virtual void OnError(AudioOutputStream* stream) OVERRIDE {}
    386 
    387  private:
    388   // Converts from bytes to milliseconds given number of bytes and existing
    389   // audio parameters.
    390   double BytesToMilliseconds(int bytes) const {
    391     const int frames = bytes / params_.GetBytesPerFrame();
    392     return (base::TimeDelta::FromMicroseconds(
    393                 frames * base::Time::kMicrosecondsPerSecond /
    394                 static_cast<double>(params_.sample_rate()))).InMillisecondsF();
    395   }
    396 
    397   AudioParameters params_;
    398   base::TimeTicks previous_time_;
    399   base::Lock lock_;
    400   scoped_ptr<media::SeekableBuffer> fifo_;
    401   scoped_ptr<uint8[]> buffer_;
    402   bool started_;
    403 
    404   DISALLOW_COPY_AND_ASSIGN(FullDuplexAudioSinkSource);
    405 };
    406 
    407 // Test fixture class for tests which only exercise the output path.
    408 class AudioAndroidOutputTest : public testing::Test {
    409  public:
    410   AudioAndroidOutputTest()
    411       : loop_(new base::MessageLoopForUI()),
    412         audio_manager_(AudioManager::CreateForTesting()),
    413         audio_output_stream_(NULL) {
    414   }
    415 
    416   virtual ~AudioAndroidOutputTest() {
    417   }
    418 
    419  protected:
    420   AudioManager* audio_manager() { return audio_manager_.get(); }
    421   base::MessageLoopForUI* loop() { return loop_.get(); }
    422   const AudioParameters& audio_output_parameters() {
    423     return audio_output_parameters_;
    424   }
    425 
    426   // Synchronously runs the provided callback/closure on the audio thread.
    427   void RunOnAudioThread(const base::Closure& closure) {
    428     if (!audio_manager()->GetTaskRunner()->BelongsToCurrentThread()) {
    429       base::WaitableEvent event(false, false);
    430       audio_manager()->GetTaskRunner()->PostTask(
    431           FROM_HERE,
    432           base::Bind(&AudioAndroidOutputTest::RunOnAudioThreadImpl,
    433                      base::Unretained(this),
    434                      closure,
    435                      &event));
    436       event.Wait();
    437     } else {
    438       closure.Run();
    439     }
    440   }
    441 
    442   void RunOnAudioThreadImpl(const base::Closure& closure,
    443                             base::WaitableEvent* event) {
    444     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    445     closure.Run();
    446     event->Signal();
    447   }
    448 
    449   void GetDefaultOutputStreamParametersOnAudioThread() {
    450     RunOnAudioThread(
    451         base::Bind(&AudioAndroidOutputTest::GetDefaultOutputStreamParameters,
    452                    base::Unretained(this)));
    453   }
    454 
    455   void MakeAudioOutputStreamOnAudioThread(const AudioParameters& params) {
    456     RunOnAudioThread(
    457         base::Bind(&AudioAndroidOutputTest::MakeOutputStream,
    458                    base::Unretained(this),
    459                    params));
    460   }
    461 
    462   void OpenAndCloseAudioOutputStreamOnAudioThread() {
    463     RunOnAudioThread(
    464         base::Bind(&AudioAndroidOutputTest::OpenAndClose,
    465                    base::Unretained(this)));
    466   }
    467 
    468   void OpenAndStartAudioOutputStreamOnAudioThread(
    469       AudioOutputStream::AudioSourceCallback* source) {
    470     RunOnAudioThread(
    471         base::Bind(&AudioAndroidOutputTest::OpenAndStart,
    472                    base::Unretained(this),
    473                    source));
    474   }
    475 
    476   void StopAndCloseAudioOutputStreamOnAudioThread() {
    477     RunOnAudioThread(
    478         base::Bind(&AudioAndroidOutputTest::StopAndClose,
    479                    base::Unretained(this)));
    480   }
    481 
    482   double AverageTimeBetweenCallbacks(int num_callbacks) const {
    483     return ((end_time_ - start_time_) / static_cast<double>(num_callbacks - 1))
    484         .InMillisecondsF();
    485   }
    486 
    487   void StartOutputStreamCallbacks(const AudioParameters& params) {
    488     double expected_time_between_callbacks_ms =
    489         ExpectedTimeBetweenCallbacks(params);
    490     const int num_callbacks =
    491         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
    492     MakeAudioOutputStreamOnAudioThread(params);
    493 
    494     int count = 0;
    495     MockAudioSourceCallback source;
    496 
    497     EXPECT_CALL(source, OnMoreData(NotNull(), _))
    498         .Times(AtLeast(num_callbacks))
    499         .WillRepeatedly(
    500              DoAll(CheckCountAndPostQuitTask(&count, num_callbacks, loop()),
    501                    Invoke(RealOnMoreData)));
    502     EXPECT_CALL(source, OnError(audio_output_stream_)).Times(0);
    503 
    504     OpenAndStartAudioOutputStreamOnAudioThread(&source);
    505 
    506     start_time_ = base::TimeTicks::Now();
    507     loop()->Run();
    508     end_time_ = base::TimeTicks::Now();
    509 
    510     StopAndCloseAudioOutputStreamOnAudioThread();
    511 
    512     double average_time_between_callbacks_ms =
    513         AverageTimeBetweenCallbacks(num_callbacks);
    514     VLOG(0) << "expected time between callbacks: "
    515             << expected_time_between_callbacks_ms << " ms";
    516     VLOG(0) << "average time between callbacks: "
    517             << average_time_between_callbacks_ms << " ms";
    518     EXPECT_GE(average_time_between_callbacks_ms,
    519               0.70 * expected_time_between_callbacks_ms);
    520     EXPECT_LE(average_time_between_callbacks_ms,
    521               1.50 * expected_time_between_callbacks_ms);
    522   }
    523 
    524   void GetDefaultOutputStreamParameters() {
    525     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    526     audio_output_parameters_ =
    527         audio_manager()->GetDefaultOutputStreamParameters();
    528     EXPECT_TRUE(audio_output_parameters_.IsValid());
    529   }
    530 
    531   void MakeOutputStream(const AudioParameters& params) {
    532     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    533     audio_output_stream_ = audio_manager()->MakeAudioOutputStream(
    534         params, std::string());
    535     EXPECT_TRUE(audio_output_stream_);
    536   }
    537 
    538   void OpenAndClose() {
    539     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    540     EXPECT_TRUE(audio_output_stream_->Open());
    541     audio_output_stream_->Close();
    542     audio_output_stream_ = NULL;
    543   }
    544 
    545   void OpenAndStart(AudioOutputStream::AudioSourceCallback* source) {
    546     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    547     EXPECT_TRUE(audio_output_stream_->Open());
    548     audio_output_stream_->Start(source);
    549   }
    550 
    551   void StopAndClose() {
    552     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    553     audio_output_stream_->Stop();
    554     audio_output_stream_->Close();
    555     audio_output_stream_ = NULL;
    556   }
    557 
    558   scoped_ptr<base::MessageLoopForUI> loop_;
    559   scoped_ptr<AudioManager> audio_manager_;
    560   AudioParameters audio_output_parameters_;
    561   AudioOutputStream* audio_output_stream_;
    562   base::TimeTicks start_time_;
    563   base::TimeTicks end_time_;
    564 
    565  private:
    566   DISALLOW_COPY_AND_ASSIGN(AudioAndroidOutputTest);
    567 };
    568 
    569 // AudioRecordInputStream should only be created on Jelly Bean and higher. This
    570 // ensures we only test against the AudioRecord path when that is satisfied.
    571 std::vector<bool> RunAudioRecordInputPathTests() {
    572   std::vector<bool> tests;
    573   tests.push_back(false);
    574   if (base::android::BuildInfo::GetInstance()->sdk_int() >= 16)
    575     tests.push_back(true);
    576   return tests;
    577 }
    578 
    579 // Test fixture class for tests which exercise the input path, or both input and
    580 // output paths. It is value-parameterized to test against both the Java
    581 // AudioRecord (when true) and native OpenSLES (when false) input paths.
    582 class AudioAndroidInputTest : public AudioAndroidOutputTest,
    583                               public testing::WithParamInterface<bool> {
    584  public:
    585   AudioAndroidInputTest() : audio_input_stream_(NULL) {}
    586 
    587  protected:
    588   const AudioParameters& audio_input_parameters() {
    589     return audio_input_parameters_;
    590   }
    591 
    592   AudioParameters GetInputStreamParameters() {
    593     GetDefaultInputStreamParametersOnAudioThread();
    594 
    595     // Override the platform effects setting to use the AudioRecord or OpenSLES
    596     // path as requested.
    597     int effects = GetParam() ? AudioParameters::ECHO_CANCELLER :
    598                                AudioParameters::NO_EFFECTS;
    599     AudioParameters params(audio_input_parameters().format(),
    600                            audio_input_parameters().channel_layout(),
    601                            audio_input_parameters().sample_rate(),
    602                            audio_input_parameters().bits_per_sample(),
    603                            audio_input_parameters().frames_per_buffer(),
    604                            effects);
    605     return params;
    606   }
    607 
    608   void GetDefaultInputStreamParametersOnAudioThread() {
    609      RunOnAudioThread(
    610         base::Bind(&AudioAndroidInputTest::GetDefaultInputStreamParameters,
    611                    base::Unretained(this)));
    612   }
    613 
    614   void MakeAudioInputStreamOnAudioThread(const AudioParameters& params) {
    615     RunOnAudioThread(
    616         base::Bind(&AudioAndroidInputTest::MakeInputStream,
    617                    base::Unretained(this),
    618                    params));
    619   }
    620 
    621   void OpenAndCloseAudioInputStreamOnAudioThread() {
    622     RunOnAudioThread(
    623         base::Bind(&AudioAndroidInputTest::OpenAndClose,
    624                    base::Unretained(this)));
    625   }
    626 
    627   void OpenAndStartAudioInputStreamOnAudioThread(
    628       AudioInputStream::AudioInputCallback* sink) {
    629     RunOnAudioThread(
    630         base::Bind(&AudioAndroidInputTest::OpenAndStart,
    631                    base::Unretained(this),
    632                    sink));
    633   }
    634 
    635   void StopAndCloseAudioInputStreamOnAudioThread() {
    636     RunOnAudioThread(
    637         base::Bind(&AudioAndroidInputTest::StopAndClose,
    638                    base::Unretained(this)));
    639   }
    640 
    641   void StartInputStreamCallbacks(const AudioParameters& params) {
    642     double expected_time_between_callbacks_ms =
    643         ExpectedTimeBetweenCallbacks(params);
    644     const int num_callbacks =
    645         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
    646 
    647     MakeAudioInputStreamOnAudioThread(params);
    648 
    649     int count = 0;
    650     MockAudioInputCallback sink;
    651 
    652     EXPECT_CALL(sink, OnData(audio_input_stream_, NotNull(), _, _))
    653         .Times(AtLeast(num_callbacks))
    654         .WillRepeatedly(
    655             CheckCountAndPostQuitTask(&count, num_callbacks, loop()));
    656     EXPECT_CALL(sink, OnError(audio_input_stream_)).Times(0);
    657 
    658     OpenAndStartAudioInputStreamOnAudioThread(&sink);
    659 
    660     start_time_ = base::TimeTicks::Now();
    661     loop()->Run();
    662     end_time_ = base::TimeTicks::Now();
    663 
    664     StopAndCloseAudioInputStreamOnAudioThread();
    665 
    666     double average_time_between_callbacks_ms =
    667         AverageTimeBetweenCallbacks(num_callbacks);
    668     VLOG(0) << "expected time between callbacks: "
    669             << expected_time_between_callbacks_ms << " ms";
    670     VLOG(0) << "average time between callbacks: "
    671             << average_time_between_callbacks_ms << " ms";
    672     EXPECT_GE(average_time_between_callbacks_ms,
    673               0.70 * expected_time_between_callbacks_ms);
    674     EXPECT_LE(average_time_between_callbacks_ms,
    675               1.30 * expected_time_between_callbacks_ms);
    676   }
    677 
    678   void GetDefaultInputStreamParameters() {
    679     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    680     audio_input_parameters_ = audio_manager()->GetInputStreamParameters(
    681         AudioManagerBase::kDefaultDeviceId);
    682   }
    683 
    684   void MakeInputStream(const AudioParameters& params) {
    685     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    686     audio_input_stream_ = audio_manager()->MakeAudioInputStream(
    687         params, AudioManagerBase::kDefaultDeviceId);
    688     EXPECT_TRUE(audio_input_stream_);
    689   }
    690 
    691   void OpenAndClose() {
    692     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    693     EXPECT_TRUE(audio_input_stream_->Open());
    694     audio_input_stream_->Close();
    695     audio_input_stream_ = NULL;
    696   }
    697 
    698   void OpenAndStart(AudioInputStream::AudioInputCallback* sink) {
    699     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    700     EXPECT_TRUE(audio_input_stream_->Open());
    701     audio_input_stream_->Start(sink);
    702   }
    703 
    704   void StopAndClose() {
    705     DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
    706     audio_input_stream_->Stop();
    707     audio_input_stream_->Close();
    708     audio_input_stream_ = NULL;
    709   }
    710 
    711   AudioInputStream* audio_input_stream_;
    712   AudioParameters audio_input_parameters_;
    713 
    714  private:
    715   DISALLOW_COPY_AND_ASSIGN(AudioAndroidInputTest);
    716 };
    717 
    718 // Get the default audio input parameters and log the result.
    719 TEST_P(AudioAndroidInputTest, GetDefaultInputStreamParameters) {
    720   // We don't go through AudioAndroidInputTest::GetInputStreamParameters() here
    721   // so that we can log the real (non-overridden) values of the effects.
    722   GetDefaultInputStreamParametersOnAudioThread();
    723   EXPECT_TRUE(audio_input_parameters().IsValid());
    724   VLOG(1) << audio_input_parameters();
    725 }
    726 
    727 // Get the default audio output parameters and log the result.
    728 TEST_F(AudioAndroidOutputTest, GetDefaultOutputStreamParameters) {
    729   GetDefaultOutputStreamParametersOnAudioThread();
    730   VLOG(1) << audio_output_parameters();
    731 }
    732 
    733 // Verify input device enumeration.
    734 TEST_F(AudioAndroidInputTest, GetAudioInputDeviceNames) {
    735   if (!audio_manager()->HasAudioInputDevices())
    736     return;
    737   AudioDeviceNames devices;
    738   RunOnAudioThread(
    739       base::Bind(&AudioManager::GetAudioInputDeviceNames,
    740                  base::Unretained(audio_manager()),
    741                  &devices));
    742   CheckDeviceNames(devices);
    743 }
    744 
    745 // Verify output device enumeration.
    746 TEST_F(AudioAndroidOutputTest, GetAudioOutputDeviceNames) {
    747   if (!audio_manager()->HasAudioOutputDevices())
    748     return;
    749   AudioDeviceNames devices;
    750   RunOnAudioThread(
    751       base::Bind(&AudioManager::GetAudioOutputDeviceNames,
    752                  base::Unretained(audio_manager()),
    753                  &devices));
    754   CheckDeviceNames(devices);
    755 }
    756 
    757 // Ensure that a default input stream can be created and closed.
    758 TEST_P(AudioAndroidInputTest, CreateAndCloseInputStream) {
    759   AudioParameters params = GetInputStreamParameters();
    760   MakeAudioInputStreamOnAudioThread(params);
    761   RunOnAudioThread(
    762       base::Bind(&AudioInputStream::Close,
    763                  base::Unretained(audio_input_stream_)));
    764 }
    765 
    766 // Ensure that a default output stream can be created and closed.
    767 // TODO(henrika): should we also verify that this API changes the audio mode
    768 // to communication mode, and calls RegisterHeadsetReceiver, the first time
    769 // it is called?
    770 TEST_F(AudioAndroidOutputTest, CreateAndCloseOutputStream) {
    771   GetDefaultOutputStreamParametersOnAudioThread();
    772   MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
    773   RunOnAudioThread(
    774       base::Bind(&AudioOutputStream::Close,
    775                  base::Unretained(audio_output_stream_)));
    776 }
    777 
    778 // Ensure that a default input stream can be opened and closed.
    779 TEST_P(AudioAndroidInputTest, OpenAndCloseInputStream) {
    780   AudioParameters params = GetInputStreamParameters();
    781   MakeAudioInputStreamOnAudioThread(params);
    782   OpenAndCloseAudioInputStreamOnAudioThread();
    783 }
    784 
    785 // Ensure that a default output stream can be opened and closed.
    786 TEST_F(AudioAndroidOutputTest, OpenAndCloseOutputStream) {
    787   GetDefaultOutputStreamParametersOnAudioThread();
    788   MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
    789   OpenAndCloseAudioOutputStreamOnAudioThread();
    790 }
    791 
    792 // Start input streaming using default input parameters and ensure that the
    793 // callback sequence is sane.
    794 TEST_P(AudioAndroidInputTest, DISABLED_StartInputStreamCallbacks) {
    795   AudioParameters native_params = GetInputStreamParameters();
    796   StartInputStreamCallbacks(native_params);
    797 }
    798 
    799 // Start input streaming using non default input parameters and ensure that the
    800 // callback sequence is sane. The only change we make in this test is to select
    801 // a 10ms buffer size instead of the default size.
    802 TEST_P(AudioAndroidInputTest,
    803        DISABLED_StartInputStreamCallbacksNonDefaultParameters) {
    804   AudioParameters native_params = GetInputStreamParameters();
    805   AudioParameters params(native_params.format(),
    806                          native_params.channel_layout(),
    807                          native_params.sample_rate(),
    808                          native_params.bits_per_sample(),
    809                          native_params.sample_rate() / 100,
    810                          native_params.effects());
    811   StartInputStreamCallbacks(params);
    812 }
    813 
    814 
    815 #if defined(__aarch64__)
    816 // Disable StartOutputStreamCallbacks and
    817 // StartOutputStreamCallbacksNonDefaultParameters on Arm64: crbug.com/418029
    818 #define MAYBE_StartOutputStreamCallbacks DISABLED_StartOutputStreamCallbacks
    819 #define MAYBE_StartOutputStreamCallbacksNonDefaultParameters  \
    820     DISABLED_StartOutputStreamCallbacksNonDefaultParameters
    821 #else
    822 #define MAYBE_StartOutputStreamCallbacks StartOutputStreamCallbacks
    823 #define MAYBE_StartOutputStreamCallbacksNonDefaultParameters  \
    824     StartOutputStreamCallbacksNonDefaultParameters
    825 #endif
    826 
    827 
    828 // Start output streaming using default output parameters and ensure that the
    829 // callback sequence is sane.
    830 TEST_F(AudioAndroidOutputTest, MAYBE_StartOutputStreamCallbacks) {
    831   GetDefaultOutputStreamParametersOnAudioThread();
    832   StartOutputStreamCallbacks(audio_output_parameters());
    833 }
    834 
    835 // Start output streaming using non default output parameters and ensure that
    836 // the callback sequence is sane. The only change we make in this test is to
    837 // select a 10ms buffer size instead of the default size and to open up the
    838 // device in mono.
    839 // TODO(henrika): possibly add support for more variations.
    840 TEST_F(AudioAndroidOutputTest,
    841        MAYBE_StartOutputStreamCallbacksNonDefaultParameters) {
    842   GetDefaultOutputStreamParametersOnAudioThread();
    843   AudioParameters params(audio_output_parameters().format(),
    844                          CHANNEL_LAYOUT_MONO,
    845                          audio_output_parameters().sample_rate(),
    846                          audio_output_parameters().bits_per_sample(),
    847                          audio_output_parameters().sample_rate() / 100);
    848   StartOutputStreamCallbacks(params);
    849 }
    850 
    851 // Play out a PCM file segment in real time and allow the user to verify that
    852 // the rendered audio sounds OK.
    853 // NOTE: this test requires user interaction and is not designed to run as an
    854 // automatized test on bots.
    855 TEST_F(AudioAndroidOutputTest, DISABLED_RunOutputStreamWithFileAsSource) {
    856   GetDefaultOutputStreamParametersOnAudioThread();
    857   VLOG(1) << audio_output_parameters();
    858   MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
    859 
    860   std::string file_name;
    861   const AudioParameters params = audio_output_parameters();
    862   if (params.sample_rate() == 48000 && params.channels() == 2) {
    863     file_name = kSpeechFile_16b_s_48k;
    864   } else if (params.sample_rate() == 48000 && params.channels() == 1) {
    865     file_name = kSpeechFile_16b_m_48k;
    866   } else if (params.sample_rate() == 44100 && params.channels() == 2) {
    867     file_name = kSpeechFile_16b_s_44k;
    868   } else if (params.sample_rate() == 44100 && params.channels() == 1) {
    869     file_name = kSpeechFile_16b_m_44k;
    870   } else {
    871     FAIL() << "This test supports 44.1kHz and 48kHz mono/stereo only.";
    872     return;
    873   }
    874 
    875   base::WaitableEvent event(false, false);
    876   FileAudioSource source(&event, file_name);
    877 
    878   OpenAndStartAudioOutputStreamOnAudioThread(&source);
    879   VLOG(0) << ">> Verify that the file is played out correctly...";
    880   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
    881   StopAndCloseAudioOutputStreamOnAudioThread();
    882 }
    883 
    884 // Start input streaming and run it for ten seconds while recording to a
    885 // local audio file.
    886 // NOTE: this test requires user interaction and is not designed to run as an
    887 // automatized test on bots.
    888 TEST_P(AudioAndroidInputTest, DISABLED_RunSimplexInputStreamWithFileAsSink) {
    889   AudioParameters params = GetInputStreamParameters();
    890   VLOG(1) << params;
    891   MakeAudioInputStreamOnAudioThread(params);
    892 
    893   std::string file_name = base::StringPrintf("out_simplex_%d_%d_%d.pcm",
    894                                              params.sample_rate(),
    895                                              params.frames_per_buffer(),
    896                                              params.channels());
    897 
    898   base::WaitableEvent event(false, false);
    899   FileAudioSink sink(&event, params, file_name);
    900 
    901   OpenAndStartAudioInputStreamOnAudioThread(&sink);
    902   VLOG(0) << ">> Speak into the microphone to record audio...";
    903   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
    904   StopAndCloseAudioInputStreamOnAudioThread();
    905 }
    906 
    907 // Same test as RunSimplexInputStreamWithFileAsSink but this time output
    908 // streaming is active as well (reads zeros only).
    909 // NOTE: this test requires user interaction and is not designed to run as an
    910 // automatized test on bots.
    911 TEST_P(AudioAndroidInputTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
    912   AudioParameters in_params = GetInputStreamParameters();
    913   VLOG(1) << in_params;
    914   MakeAudioInputStreamOnAudioThread(in_params);
    915 
    916   GetDefaultOutputStreamParametersOnAudioThread();
    917   VLOG(1) << audio_output_parameters();
    918   MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
    919 
    920   std::string file_name = base::StringPrintf("out_duplex_%d_%d_%d.pcm",
    921                                              in_params.sample_rate(),
    922                                              in_params.frames_per_buffer(),
    923                                              in_params.channels());
    924 
    925   base::WaitableEvent event(false, false);
    926   FileAudioSink sink(&event, in_params, file_name);
    927   MockAudioSourceCallback source;
    928 
    929   EXPECT_CALL(source, OnMoreData(NotNull(), _))
    930       .WillRepeatedly(Invoke(RealOnMoreData));
    931   EXPECT_CALL(source, OnError(audio_output_stream_)).Times(0);
    932 
    933   OpenAndStartAudioInputStreamOnAudioThread(&sink);
    934   OpenAndStartAudioOutputStreamOnAudioThread(&source);
    935   VLOG(0) << ">> Speak into the microphone to record audio";
    936   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
    937   StopAndCloseAudioOutputStreamOnAudioThread();
    938   StopAndCloseAudioInputStreamOnAudioThread();
    939 }
    940 
    941 // Start audio in both directions while feeding captured data into a FIFO so
    942 // it can be read directly (in loopback) by the render side. A small extra
    943 // delay will be added by the FIFO and an estimate of this delay will be
    944 // printed out during the test.
    945 // NOTE: this test requires user interaction and is not designed to run as an
    946 // automatized test on bots.
    947 TEST_P(AudioAndroidInputTest,
    948        DISABLED_RunSymmetricInputAndOutputStreamsInFullDuplex) {
    949   // Get native audio parameters for the input side.
    950   AudioParameters default_input_params = GetInputStreamParameters();
    951 
    952   // Modify the parameters so that both input and output can use the same
    953   // parameters by selecting 10ms as buffer size. This will also ensure that
    954   // the output stream will be a mono stream since mono is default for input
    955   // audio on Android.
    956   AudioParameters io_params(default_input_params.format(),
    957                             default_input_params.channel_layout(),
    958                             ChannelLayoutToChannelCount(
    959                                 default_input_params.channel_layout()),
    960                             default_input_params.sample_rate(),
    961                             default_input_params.bits_per_sample(),
    962                             default_input_params.sample_rate() / 100,
    963                             default_input_params.effects());
    964   VLOG(1) << io_params;
    965 
    966   // Create input and output streams using the common audio parameters.
    967   MakeAudioInputStreamOnAudioThread(io_params);
    968   MakeAudioOutputStreamOnAudioThread(io_params);
    969 
    970   FullDuplexAudioSinkSource full_duplex(io_params);
    971 
    972   // Start a full duplex audio session and print out estimates of the extra
    973   // delay we should expect from the FIFO. If real-time delay measurements are
    974   // performed, the result should be reduced by this extra delay since it is
    975   // something that has been added by the test.
    976   OpenAndStartAudioInputStreamOnAudioThread(&full_duplex);
    977   OpenAndStartAudioOutputStreamOnAudioThread(&full_duplex);
    978   VLOG(1) << "HINT: an estimate of the extra FIFO delay will be updated "
    979           << "once per second during this test.";
    980   VLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
    981   fflush(stdout);
    982   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
    983   printf("\n");
    984   StopAndCloseAudioOutputStreamOnAudioThread();
    985   StopAndCloseAudioInputStreamOnAudioThread();
    986 }
    987 
    988 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
    989     testing::ValuesIn(RunAudioRecordInputPathTests()));
    990 
    991 }  // namespace media
    992