audio_recorder_unittest.cc revision ab8f6f0bd665d3c1ff476eb06c58c42630e462d4
1// Copyright 2014 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 "components/copresence/mediums/audio/audio_recorder.h" 6 7#include "base/bind.h" 8#include "base/memory/aligned_memory.h" 9#include "base/run_loop.h" 10#include "components/copresence/public/copresence_constants.h" 11#include "components/copresence/test/audio_test_support.h" 12#include "content/public/test/test_browser_thread_bundle.h" 13#include "media/audio/audio_manager.h" 14#include "media/audio/audio_manager_base.h" 15#include "media/base/audio_bus.h" 16#include "testing/gtest/include/gtest/gtest.h" 17 18namespace { 19 20class TestAudioInputStream : public media::AudioInputStream { 21 public: 22 TestAudioInputStream(const media::AudioParameters& params, 23 const std::vector<float*> channel_data, 24 size_t samples) 25 : callback_(NULL), params_(params) { 26 buffer_ = media::AudioBus::CreateWrapper(2); 27 for (size_t i = 0; i < channel_data.size(); ++i) 28 buffer_->SetChannelData(i, channel_data[i]); 29 buffer_->set_frames(samples); 30 } 31 32 virtual ~TestAudioInputStream() {} 33 34 virtual bool Open() OVERRIDE { return true; } 35 virtual void Start(AudioInputCallback* callback) OVERRIDE { 36 DCHECK(callback); 37 callback_ = callback; 38 media::AudioManager::Get()->GetTaskRunner()->PostTask( 39 FROM_HERE, 40 base::Bind(&TestAudioInputStream::SimulateRecording, 41 base::Unretained(this))); 42 } 43 virtual void Stop() OVERRIDE {} 44 virtual void Close() OVERRIDE {} 45 virtual double GetMaxVolume() OVERRIDE { return 1.0; } 46 virtual void SetVolume(double volume) OVERRIDE {} 47 virtual double GetVolume() OVERRIDE { return 1.0; } 48 virtual void SetAutomaticGainControl(bool enabled) OVERRIDE {} 49 virtual bool GetAutomaticGainControl() OVERRIDE { return true; } 50 virtual bool IsMuted() OVERRIDE { return false; } 51 52 private: 53 void SimulateRecording() { 54 const int fpb = params_.frames_per_buffer(); 55 for (int i = 0; i < buffer_->frames() / fpb; ++i) { 56 scoped_ptr<media::AudioBus> source = media::AudioBus::Create(2, fpb); 57 buffer_->CopyPartialFramesTo(i * fpb, fpb, 0, source.get()); 58 callback_->OnData(this, source.get(), fpb, 1.0); 59 } 60 } 61 62 AudioInputCallback* callback_; 63 media::AudioParameters params_; 64 scoped_ptr<media::AudioBus> buffer_; 65 66 DISALLOW_COPY_AND_ASSIGN(TestAudioInputStream); 67}; 68 69} // namespace 70 71namespace copresence { 72 73class AudioRecorderTest : public testing::Test { 74 public: 75 AudioRecorderTest() : total_samples_(0), recorder_(NULL) { 76 if (!media::AudioManager::Get()) 77 media::AudioManager::CreateForTesting(); 78 } 79 80 virtual ~AudioRecorderTest() { 81 DeleteRecorder(); 82 for (size_t i = 0; i < channel_data_.size(); ++i) 83 base::AlignedFree(channel_data_[i]); 84 } 85 86 void CreateSimpleRecorder() { 87 DeleteRecorder(); 88 recorder_ = new AudioRecorder( 89 base::Bind(&AudioRecorderTest::DecodeSamples, base::Unretained(this))); 90 recorder_->Initialize(); 91 } 92 93 void CreateRecorder(size_t channels, 94 size_t sample_rate, 95 size_t bits_per_sample, 96 size_t samples) { 97 DeleteRecorder(); 98 params_.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY, 99 kDefaultChannelLayout, 100 channels, 101 sample_rate, 102 bits_per_sample, 103 4096); 104 105 channel_data_.clear(); 106 channel_data_.push_back(GenerateSamples(0x1337, samples)); 107 channel_data_.push_back(GenerateSamples(0x7331, samples)); 108 109 total_samples_ = samples; 110 111 recorder_ = new AudioRecorder( 112 base::Bind(&AudioRecorderTest::DecodeSamples, base::Unretained(this))); 113 recorder_->set_input_stream_for_testing( 114 new TestAudioInputStream(params_, channel_data_, samples)); 115 recorder_->set_params_for_testing(new media::AudioParameters(params_)); 116 recorder_->Initialize(); 117 } 118 119 void DeleteRecorder() { 120 if (!recorder_) 121 return; 122 recorder_->Finalize(); 123 recorder_ = NULL; 124 } 125 126 void RecordAndVerifySamples() { 127 received_samples_.clear(); 128 run_loop_.reset(new base::RunLoop()); 129 recorder_->Record(); 130 run_loop_->Run(); 131 } 132 133 void DecodeSamples(const std::string& samples) { 134 received_samples_ += samples; 135 // We expect one less decode than our total samples would ideally have 136 // triggered since we process data in 4k chunks. So our sample processing 137 // will never rarely be perfectly aligned with 0.5s worth of samples, hence 138 // we will almost always run with a buffer of leftover samples that will 139 // not get sent to this callback since the recorder will be waiting for 140 // more data. 141 const size_t decode_buffer = params_.sample_rate() / 2; // 0.5s 142 const size_t expected_samples = 143 (total_samples_ / decode_buffer - 1) * decode_buffer; 144 const size_t expected_samples_size = 145 expected_samples * sizeof(float) * params_.channels(); 146 if (received_samples_.size() == expected_samples_size) { 147 VerifySamples(); 148 run_loop_->Quit(); 149 } 150 } 151 152 void VerifySamples() { 153 int differences = 0; 154 155 float* buffer_view = 156 reinterpret_cast<float*>(string_as_array(&received_samples_)); 157 const int channels = params_.channels(); 158 const int frames = 159 received_samples_.size() / sizeof(float) / params_.channels(); 160 for (int ch = 0; ch < channels; ++ch) { 161 for (int si = 0, di = ch; si < frames; ++si, di += channels) 162 differences += (buffer_view[di] != channel_data_[ch][si]); 163 } 164 165 ASSERT_EQ(0, differences); 166 } 167 168 protected: 169 float* GenerateSamples(int random_seed, size_t size) { 170 float* samples = static_cast<float*>(base::AlignedAlloc( 171 size * sizeof(float), media::AudioBus::kChannelAlignment)); 172 PopulateSamples(0x1337, size, samples); 173 return samples; 174 } 175 bool IsRecording() { 176 recorder_->FlushAudioLoopForTesting(); 177 return recorder_->is_recording_; 178 } 179 180 std::vector<float*> channel_data_; 181 media::AudioParameters params_; 182 size_t total_samples_; 183 184 AudioRecorder* recorder_; 185 186 std::string received_samples_; 187 188 scoped_ptr<base::RunLoop> run_loop_; 189 content::TestBrowserThreadBundle thread_bundle_; 190}; 191 192// TODO(rkc): These tests are broken on all platforms. 193// On Windows and Mac, we cannot use non-OS params. The tests need to be 194// rewritten to use the params provided to us by the audio manager 195// rather than setting our own params. 196// On Linux, there is a memory leak in the audio code during initialization. 197#define MAYBE_BasicRecordAndStop DISABLED_BasicRecordAndStop 198#define MAYBE_OutOfOrderRecordAndStopMultiple DISABLED_OutOfOrderRecordAndStopMultiple 199#define MAYBE_RecordingEndToEnd DISABLED_RecordingEndToEnd 200 201TEST_F(AudioRecorderTest, MAYBE_BasicRecordAndStop) { 202 CreateSimpleRecorder(); 203 204 recorder_->Record(); 205 EXPECT_TRUE(IsRecording()); 206 recorder_->Stop(); 207 EXPECT_FALSE(IsRecording()); 208 recorder_->Record(); 209 210 EXPECT_TRUE(IsRecording()); 211 recorder_->Stop(); 212 EXPECT_FALSE(IsRecording()); 213 recorder_->Record(); 214 215 EXPECT_TRUE(IsRecording()); 216 recorder_->Stop(); 217 EXPECT_FALSE(IsRecording()); 218 219 DeleteRecorder(); 220} 221 222TEST_F(AudioRecorderTest, MAYBE_OutOfOrderRecordAndStopMultiple) { 223 CreateSimpleRecorder(); 224 225 recorder_->Stop(); 226 recorder_->Stop(); 227 recorder_->Stop(); 228 EXPECT_FALSE(IsRecording()); 229 230 recorder_->Record(); 231 recorder_->Record(); 232 EXPECT_TRUE(IsRecording()); 233 234 recorder_->Stop(); 235 recorder_->Stop(); 236 EXPECT_FALSE(IsRecording()); 237 238 DeleteRecorder(); 239} 240 241TEST_F(AudioRecorderTest, MAYBE_RecordingEndToEnd) { 242 const int kNumSamples = 48000 * 3; 243 CreateRecorder( 244 kDefaultChannels, kDefaultSampleRate, kDefaultBitsPerSample, kNumSamples); 245 246 RecordAndVerifySamples(); 247 248 DeleteRecorder(); 249} 250 251// TODO(rkc): Add tests with recording different sample rates. 252 253} // namespace copresence 254