media/audio/audio_input_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/environment.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/threading/platform_thread.h"
  10 #include "media/audio/audio_io.h"
  11 #include "media/audio/audio_manager_base.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace media {
  15
  16 static const int kSamplingRate = 8000;
  17 static const int kSamplesPerPacket = kSamplingRate / 20;
  18
  19 // This class allows to find out if the callbacks are occurring as
  20 // expected and if any error has been reported.
  21 class TestInputCallback : public AudioInputStream::AudioInputCallback {
  22  public:
  23   explicit TestInputCallback(int max_data_bytes)
  24       : callback_count_(0),
  25         had_error_(0),
  26         max_data_bytes_(max_data_bytes) {
  27   }
  28   virtual void OnData(AudioInputStream* stream,
  29                       const uint8* data,
  30                       uint32 size,
  31                       uint32 hardware_delay_bytes,
  32                       double volume) OVERRIDE {
  33     ++callback_count_;
  34     // Read the first byte to make sure memory is good.
  35     if (size) {
  36       ASSERT_LE(static_cast<int>(size), max_data_bytes_);
  37       int value = data[0];
  38       EXPECT_GE(value, 0);
  39     }
  40   }
  41   virtual void OnError(AudioInputStream* stream) OVERRIDE {
  42     ++had_error_;
  43   }
  44   // Returns how many times OnData() has been called.
  45   int callback_count() const {
  46     return callback_count_;
  47   }
  48   // Returns how many times the OnError callback was called.
  49   int had_error() const {
  50     return had_error_;
  51   }
  52
  53  private:
  54   int callback_count_;
  55   int had_error_;
  56   int max_data_bytes_;
  57 };
  58
  59 static bool CanRunAudioTests(AudioManager* audio_man) {
  60   bool has_input = audio_man->HasAudioInputDevices();
  61
  62   if (!has_input)
  63     LOG(WARNING) << "No input devices detected";
  64
  65   return has_input;
  66 }
  67
  68 static AudioInputStream* CreateTestAudioInputStream(AudioManager* audio_man) {
  69   AudioInputStream* ais = audio_man->MakeAudioInputStream(
  70       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
  71                       kSamplingRate, 16, kSamplesPerPacket),
  72                       AudioManagerBase::kDefaultDeviceId);
  73   EXPECT_TRUE(NULL != ais);
  74   return ais;
  75 }
  76
  77 // Test that AudioInputStream rejects out of range parameters.
  78 TEST(AudioInputTest, SanityOnMakeParams) {
  79   scoped_ptr<AudioManager> audio_man(AudioManager::CreateForTesting());
  80   if (!CanRunAudioTests(audio_man.get()))
  81     return;
  82
  83   AudioParameters::Format fmt = AudioParameters::AUDIO_PCM_LINEAR;
  84   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
  85       AudioParameters(fmt, CHANNEL_LAYOUT_7_1, 8000, 16,
  86                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
  87   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
  88       AudioParameters(fmt, CHANNEL_LAYOUT_MONO, 1024 * 1024, 16,
  89                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
  90   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
  91       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, 80,
  92                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
  93   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
  94       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, 80,
  95                       1000 * kSamplesPerPacket),
  96                       AudioManagerBase::kDefaultDeviceId));
  97   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
  98       AudioParameters(fmt, CHANNEL_LAYOUT_UNSUPPORTED, 8000, 16,
  99                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 100   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 101       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, -8000, 16,
 102                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 103   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 104       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, -16,
 105                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 106   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 107       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, 16, -1024),
 108       AudioManagerBase::kDefaultDeviceId));
 109 }
 110
 111 // Test create and close of an AudioInputStream without recording audio.
 112 TEST(AudioInputTest, CreateAndClose) {
 113   scoped_ptr<AudioManager> audio_man(AudioManager::CreateForTesting());
 114   if (!CanRunAudioTests(audio_man.get()))
 115     return;
 116   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 117   ais->Close();
 118 }
 119
 120 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 121 // This test is failing on ARM linux: http://crbug.com/238490
 122 #define MAYBE_OpenAndClose DISABLED_OpenAndClose
 123 #else
 124 #define MAYBE_OpenAndClose OpenAndClose
 125 #endif
 126 // Test create, open and close of an AudioInputStream without recording audio.
 127 TEST(AudioInputTest, MAYBE_OpenAndClose) {
 128   scoped_ptr<AudioManager> audio_man(AudioManager::CreateForTesting());
 129   if (!CanRunAudioTests(audio_man.get()))
 130     return;
 131   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 132   EXPECT_TRUE(ais->Open());
 133   ais->Close();
 134 }
 135
 136 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 137 // This test is failing on ARM linux: http://crbug.com/238490
 138 #define MAYBE_OpenStopAndClose DISABLED_OpenStopAndClose
 139 #else
 140 #define MAYBE_OpenStopAndClose OpenStopAndClose
 141 #endif
 142 // Test create, open, stop and close of an AudioInputStream without recording.
 143 TEST(AudioInputTest, MAYBE_OpenStopAndClose) {
 144   scoped_ptr<AudioManager> audio_man(AudioManager::CreateForTesting());
 145   if (!CanRunAudioTests(audio_man.get()))
 146     return;
 147   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 148   EXPECT_TRUE(ais->Open());
 149   ais->Stop();
 150   ais->Close();
 151 }
 152
 153 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 154 // This test is failing on ARM linux: http://crbug.com/238490
 155 #define MAYBE_Record DISABLED_Record
 156 #else
 157 #define MAYBE_Record Record
 158 #endif
 159 // Test a normal recording sequence using an AudioInputStream.
 160 TEST(AudioInputTest, MAYBE_Record) {
 161   scoped_ptr<AudioManager> audio_man(AudioManager::CreateForTesting());
 162   if (!CanRunAudioTests(audio_man.get()))
 163     return;
 164   base::MessageLoop message_loop;
 165   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 166   EXPECT_TRUE(ais->Open());
 167
 168   TestInputCallback test_callback(kSamplesPerPacket * 4);
 169   ais->Start(&test_callback);
 170   // Verify at least 500ms worth of audio was recorded, after giving sufficient
 171   // extra time.
 172   message_loop.PostDelayedTask(
 173       FROM_HERE,
 174       base::MessageLoop::QuitClosure(),
 175       base::TimeDelta::FromMilliseconds(690));
 176   message_loop.Run();
 177   EXPECT_GE(test_callback.callback_count(), 1);
 178   EXPECT_FALSE(test_callback.had_error());
 179
 180   ais->Stop();
 181   ais->Close();
 182 }
 183
 184 }  // namespace media