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
28using ::testing::_;
29using ::testing::AtLeast;
30using ::testing::DoAll;
31using ::testing::Invoke;
32using ::testing::NotNull;
33using ::testing::Return;
34
35namespace media {
36
37ACTION_P3(CheckCountAndPostQuitTask, count, limit, loop) {
38  if (++*count >= limit) {
39    loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
40  }
41}
42
43static const char kSpeechFile_16b_s_48k[] = "speech_16b_stereo_48kHz.raw";
44static const char kSpeechFile_16b_m_48k[] = "speech_16b_mono_48kHz.raw";
45static const char kSpeechFile_16b_s_44k[] = "speech_16b_stereo_44kHz.raw";
46static const char kSpeechFile_16b_m_44k[] = "speech_16b_mono_44kHz.raw";
47
48static const float kCallbackTestTimeMs = 2000.0;
49static const int kBitsPerSample = 16;
50static const int kBytesPerSample = kBitsPerSample / 8;
51
52// Converts AudioParameters::Format enumerator to readable string.
53static 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.
70static 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
84static 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.
92static 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.
126static int RealOnMoreData(AudioBus* dest, AudioBuffersState buffers_state) {
127  dest->Zero();
128  return dest->frames();
129}
130
131std::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.
149class 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.
161class 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.
226class 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.
296class 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.
408class 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.
571std::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.
582class 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.
719TEST_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.
728TEST_F(AudioAndroidOutputTest, GetDefaultOutputStreamParameters) {
729  GetDefaultOutputStreamParametersOnAudioThread();
730  VLOG(1) << audio_output_parameters();
731}
732
733// Verify input device enumeration.
734TEST_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.
746TEST_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.
758TEST_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?
770TEST_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.
779TEST_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.
786TEST_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.
794TEST_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.
802TEST_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.
830TEST_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.
840TEST_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.
855TEST_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.
888TEST_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.
911TEST_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.
947TEST_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
988INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
989    testing::ValuesIn(RunAudioRecordInputPathTests()));
990
991}  // namespace media
992