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.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         was_closed_(0),
  27         max_data_bytes_(max_data_bytes) {
  28   }
  29   virtual void OnData(AudioInputStream* stream, const uint8* data,
  30                       uint32 size, uint32 hardware_delay_bytes, double volume) {
  31     ++callback_count_;
  32     // Read the first byte to make sure memory is good.
  33     if (size) {
  34       ASSERT_LE(static_cast<int>(size), max_data_bytes_);
  35       int value = data[0];
  36       EXPECT_GE(value, 0);
  37     }
  38   }
  39   virtual void OnClose(AudioInputStream* stream) {
  40     ++was_closed_;
  41   }
  42   virtual void OnError(AudioInputStream* stream, int code) {
  43     ++had_error_;
  44   }
  45   // Returns how many times OnData() has been called.
  46   int callback_count() const {
  47     return callback_count_;
  48   }
  49   // Returns how many times the OnError callback was called.
  50   int had_error() const {
  51     return had_error_;
  52   }
  53
  54   void set_error(bool error) {
  55     had_error_ += error ? 1 : 0;
  56   }
  57   // Returns how many times the OnClose callback was called.
  58   int was_closed() const {
  59     return was_closed_;
  60   }
  61
  62  private:
  63   int callback_count_;
  64   int had_error_;
  65   int was_closed_;
  66   int max_data_bytes_;
  67 };
  68
  69 static bool CanRunAudioTests(AudioManager* audio_man) {
  70   bool has_input = audio_man->HasAudioInputDevices();
  71
  72   if (!has_input)
  73     LOG(WARNING) << "No input devices detected";
  74
  75   return has_input;
  76 }
  77
  78 static AudioInputStream* CreateTestAudioInputStream(AudioManager* audio_man) {
  79   AudioInputStream* ais = audio_man->MakeAudioInputStream(
  80       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
  81                       kSamplingRate, 16, kSamplesPerPacket),
  82                       AudioManagerBase::kDefaultDeviceId);
  83   EXPECT_TRUE(NULL != ais);
  84   return ais;
  85 }
  86
  87 // Test that AudioInputStream rejects out of range parameters.
  88 TEST(AudioInputTest, SanityOnMakeParams) {
  89   scoped_ptr<AudioManager> audio_man(AudioManager::Create());
  90   if (!CanRunAudioTests(audio_man.get()))
  91     return;
  92
  93   AudioParameters::Format fmt = AudioParameters::AUDIO_PCM_LINEAR;
  94   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
  95       AudioParameters(fmt, CHANNEL_LAYOUT_7_1, 8000, 16,
  96                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
  97   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
  98       AudioParameters(fmt, CHANNEL_LAYOUT_MONO, 1024 * 1024, 16,
  99                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 100   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 101       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, 80,
 102                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 103   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 104       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, 80,
 105                       1000 * kSamplesPerPacket),
 106                       AudioManagerBase::kDefaultDeviceId));
 107   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 108       AudioParameters(fmt, CHANNEL_LAYOUT_UNSUPPORTED, 8000, 16,
 109                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 110   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 111       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, -8000, 16,
 112                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 113   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 114       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, -16,
 115                       kSamplesPerPacket), AudioManagerBase::kDefaultDeviceId));
 116   EXPECT_TRUE(NULL == audio_man->MakeAudioInputStream(
 117       AudioParameters(fmt, CHANNEL_LAYOUT_STEREO, 8000, 16, -1024),
 118       AudioManagerBase::kDefaultDeviceId));
 119 }
 120
 121 // Test create and close of an AudioInputStream without recording audio.
 122 TEST(AudioInputTest, CreateAndClose) {
 123   scoped_ptr<AudioManager> audio_man(AudioManager::Create());
 124   if (!CanRunAudioTests(audio_man.get()))
 125     return;
 126   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 127   ais->Close();
 128 }
 129
 130 // Test create, open and close of an AudioInputStream without recording audio.
 131 TEST(AudioInputTest, OpenAndClose) {
 132   scoped_ptr<AudioManager> audio_man(AudioManager::Create());
 133   if (!CanRunAudioTests(audio_man.get()))
 134     return;
 135   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 136   EXPECT_TRUE(ais->Open());
 137   ais->Close();
 138 }
 139
 140 // Test create, open, stop and close of an AudioInputStream without recording.
 141 TEST(AudioInputTest, OpenStopAndClose) {
 142   scoped_ptr<AudioManager> audio_man(AudioManager::Create());
 143   if (!CanRunAudioTests(audio_man.get()))
 144     return;
 145   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 146   EXPECT_TRUE(ais->Open());
 147   ais->Stop();
 148   ais->Close();
 149 }
 150
 151 // Test a normal recording sequence using an AudioInputStream.
 152 TEST(AudioInputTest, Record) {
 153   scoped_ptr<AudioManager> audio_man(AudioManager::Create());
 154   if (!CanRunAudioTests(audio_man.get()))
 155     return;
 156   MessageLoop message_loop(MessageLoop::TYPE_DEFAULT);
 157   AudioInputStream* ais = CreateTestAudioInputStream(audio_man.get());
 158   EXPECT_TRUE(ais->Open());
 159
 160   TestInputCallback test_callback(kSamplesPerPacket * 4);
 161   ais->Start(&test_callback);
 162   // Verify at least 500ms worth of audio was recorded, after giving sufficient
 163   // extra time.
 164   message_loop.PostDelayedTask(
 165       FROM_HERE,
 166       MessageLoop::QuitClosure(),
 167       base::TimeDelta::FromMilliseconds(590));
 168   message_loop.Run();
 169   EXPECT_GE(test_callback.callback_count(), 10);
 170   EXPECT_FALSE(test_callback.had_error());
 171
 172   ais->Stop();
 173   ais->Close();
 174 }
 175
 176 }  // namespace media