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.
5 #include "components/copresence/mediums/audio/audio_recorder.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"
20 class TestAudioInputStream : public media::AudioInputStream {
22 TestAudioInputStream(const media::AudioParameters& params,
23 const std::vector<float*> channel_data,
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);
32 virtual ~TestAudioInputStream() {}
34 virtual bool Open() OVERRIDE { return true; }
35 virtual void Start(AudioInputCallback* callback) OVERRIDE {
38 media::AudioManager::Get()->GetTaskRunner()->PostTask(
40 base::Bind(&TestAudioInputStream::SimulateRecording,
41 base::Unretained(this)));
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; }
52 void SimulateRecording() {
53 const int fpb = params_.frames_per_buffer();
54 for (int i = 0; i < buffer_->frames() / fpb; ++i) {
55 scoped_ptr<media::AudioBus> source = media::AudioBus::Create(2, fpb);
56 buffer_->CopyPartialFramesTo(i * fpb, fpb, 0, source.get());
57 callback_->OnData(this, source.get(), fpb, 1.0);
61 AudioInputCallback* callback_;
62 media::AudioParameters params_;
63 scoped_ptr<media::AudioBus> buffer_;
65 DISALLOW_COPY_AND_ASSIGN(TestAudioInputStream);
70 namespace copresence {
72 class AudioRecorderTest : public testing::Test {
74 AudioRecorderTest() : total_samples_(0), recorder_(NULL) {
75 if (!media::AudioManager::Get())
76 media::AudioManager::CreateForTesting();
79 virtual ~AudioRecorderTest() {
81 for (size_t i = 0; i < channel_data_.size(); ++i)
82 base::AlignedFree(channel_data_[i]);
85 void CreateSimpleRecorder() {
87 recorder_ = new AudioRecorder(
88 base::Bind(&AudioRecorderTest::DecodeSamples, base::Unretained(this)));
89 recorder_->Initialize();
92 void CreateRecorder(size_t channels,
94 size_t bits_per_sample,
97 params_.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
98 kDefaultChannelLayout,
104 channel_data_.clear();
105 channel_data_.push_back(GenerateSamples(0x1337, samples));
106 channel_data_.push_back(GenerateSamples(0x7331, samples));
108 total_samples_ = samples;
110 recorder_ = new AudioRecorder(
111 base::Bind(&AudioRecorderTest::DecodeSamples, base::Unretained(this)));
112 recorder_->set_input_stream_for_testing(
113 new TestAudioInputStream(params_, channel_data_, samples));
114 recorder_->set_params_for_testing(new media::AudioParameters(params_));
115 recorder_->Initialize();
118 void DeleteRecorder() {
121 recorder_->Finalize();
125 void RecordAndVerifySamples() {
126 received_samples_.clear();
127 run_loop_.reset(new base::RunLoop());
132 void DecodeSamples(const std::string& samples) {
133 received_samples_ += samples;
134 // We expect one less decode than our total samples would ideally have
135 // triggered since we process data in 4k chunks. So our sample processing
136 // will never rarely be perfectly aligned with 0.5s worth of samples, hence
137 // we will almost always run with a buffer of leftover samples that will
138 // not get sent to this callback since the recorder will be waiting for
140 const size_t decode_buffer = params_.sample_rate() / 2; // 0.5s
141 const size_t expected_samples =
142 (total_samples_ / decode_buffer - 1) * decode_buffer;
143 const size_t expected_samples_size =
144 expected_samples * sizeof(float) * params_.channels();
145 if (received_samples_.size() == expected_samples_size) {
151 void VerifySamples() {
155 reinterpret_cast<float*>(string_as_array(&received_samples_));
156 const int channels = params_.channels();
158 received_samples_.size() / sizeof(float) / params_.channels();
159 for (int ch = 0; ch < channels; ++ch) {
160 for (int si = 0, di = ch; si < frames; ++si, di += channels)
161 differences += (buffer_view[di] != channel_data_[ch][si]);
164 ASSERT_EQ(0, differences);
168 float* GenerateSamples(int random_seed, size_t size) {
169 float* samples = static_cast<float*>(base::AlignedAlloc(
170 size * sizeof(float), media::AudioBus::kChannelAlignment));
171 PopulateSamples(0x1337, size, samples);
175 recorder_->FlushAudioLoopForTesting();
176 return recorder_->is_recording_;
179 std::vector<float*> channel_data_;
180 media::AudioParameters params_;
181 size_t total_samples_;
183 AudioRecorder* recorder_;
185 std::string received_samples_;
187 scoped_ptr<base::RunLoop> run_loop_;
188 content::TestBrowserThreadBundle thread_bundle_;
191 // TODO(rkc): These tests are broken on all platforms.
192 // On Windows and Mac, we cannot use non-OS params. The tests need to be
193 // rewritten to use the params provided to us by the audio manager
194 // rather than setting our own params.
195 // On Linux, there is a memory leak in the audio code during initialization.
196 #define MAYBE_BasicRecordAndStop DISABLED_BasicRecordAndStop
197 #define MAYBE_OutOfOrderRecordAndStopMultiple DISABLED_OutOfOrderRecordAndStopMultiple
198 #define MAYBE_RecordingEndToEnd DISABLED_RecordingEndToEnd
200 TEST_F(AudioRecorderTest, MAYBE_BasicRecordAndStop) {
201 CreateSimpleRecorder();
204 EXPECT_TRUE(IsRecording());
206 EXPECT_FALSE(IsRecording());
209 EXPECT_TRUE(IsRecording());
211 EXPECT_FALSE(IsRecording());
214 EXPECT_TRUE(IsRecording());
216 EXPECT_FALSE(IsRecording());
221 TEST_F(AudioRecorderTest, MAYBE_OutOfOrderRecordAndStopMultiple) {
222 CreateSimpleRecorder();
227 EXPECT_FALSE(IsRecording());
231 EXPECT_TRUE(IsRecording());
235 EXPECT_FALSE(IsRecording());
240 TEST_F(AudioRecorderTest, MAYBE_RecordingEndToEnd) {
241 const int kNumSamples = 48000 * 3;
243 kDefaultChannels, kDefaultSampleRate, kDefaultBitsPerSample, kNumSamples);
245 RecordAndVerifySamples();
250 // TODO(rkc): Add tests with recording different sample rates.
252 } // namespace copresence