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 <algorithm>
8 #include <vector>
9
10 #include "base/bind.h"
11 #include "base/bind_helpers.h"
12 #include "base/logging.h"
13 #include "base/run_loop.h"
14 #include "base/synchronization/waitable_event.h"
15 #include "components/copresence/public/copresence_constants.h"
16 #include "content/public/browser/browser_thread.h"
17 #include "media/audio/audio_manager.h"
18 #include "media/audio/audio_manager_base.h"
19 #include "media/base/audio_bus.h"
20
21 namespace copresence {
22
23 namespace {
24
25 const float kProcessIntervalMs = 500.0f; // milliseconds.
26
AudioBusToString(scoped_ptr<media::AudioBus> source,std::string * buffer)27 void AudioBusToString(scoped_ptr<media::AudioBus> source, std::string* buffer) {
28 buffer->resize(source->frames() * source->channels() * sizeof(float));
29 float* buffer_view = reinterpret_cast<float*>(string_as_array(buffer));
30
31 const int channels = source->channels();
32 for (int ch = 0; ch < channels; ++ch) {
33 for (int si = 0, di = ch; si < source->frames(); ++si, di += channels)
34 buffer_view[di] = source->channel(ch)[si];
35 }
36 }
37
38 // Called every kProcessIntervalMs to process the recorded audio. This
39 // converts our samples to the required sample rate, interleaves the samples
40 // and sends them to the whispernet decoder to process.
ProcessSamples(scoped_ptr<media::AudioBus> bus,const AudioRecorder::DecodeSamplesCallback & callback)41 void ProcessSamples(scoped_ptr<media::AudioBus> bus,
42 const AudioRecorder::DecodeSamplesCallback& callback) {
43 std::string samples;
44 AudioBusToString(bus.Pass(), &samples);
45 content::BrowserThread::PostTask(
46 content::BrowserThread::UI, FROM_HERE, base::Bind(callback, samples));
47 }
48
49 } // namespace
50
51 // Public methods.
52
AudioRecorder(const DecodeSamplesCallback & decode_callback)53 AudioRecorder::AudioRecorder(const DecodeSamplesCallback& decode_callback)
54 : is_recording_(false),
55 stream_(NULL),
56 decode_callback_(decode_callback),
57 total_buffer_frames_(0),
58 buffer_frame_index_(0) {
59 }
60
Initialize()61 void AudioRecorder::Initialize() {
62 media::AudioManager::Get()->GetTaskRunner()->PostTask(
63 FROM_HERE,
64 base::Bind(&AudioRecorder::InitializeOnAudioThread,
65 base::Unretained(this)));
66 }
67
~AudioRecorder()68 AudioRecorder::~AudioRecorder() {
69 }
70
Record()71 void AudioRecorder::Record() {
72 media::AudioManager::Get()->GetTaskRunner()->PostTask(
73 FROM_HERE,
74 base::Bind(&AudioRecorder::RecordOnAudioThread, base::Unretained(this)));
75 }
76
Stop()77 void AudioRecorder::Stop() {
78 media::AudioManager::Get()->GetTaskRunner()->PostTask(
79 FROM_HERE,
80 base::Bind(&AudioRecorder::StopOnAudioThread, base::Unretained(this)));
81 }
82
IsRecording()83 bool AudioRecorder::IsRecording() {
84 return is_recording_;
85 }
86
Finalize()87 void AudioRecorder::Finalize() {
88 media::AudioManager::Get()->GetTaskRunner()->PostTask(
89 FROM_HERE,
90 base::Bind(&AudioRecorder::FinalizeOnAudioThread,
91 base::Unretained(this)));
92 }
93
94 // Private methods.
95
InitializeOnAudioThread()96 void AudioRecorder::InitializeOnAudioThread() {
97 DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
98
99 media::AudioParameters params =
100 params_for_testing_
101 ? *params_for_testing_
102 : media::AudioManager::Get()->GetInputStreamParameters(
103 media::AudioManagerBase::kDefaultDeviceId);
104
105 const media::AudioParameters dest_params(params.format(),
106 kDefaultChannelLayout,
107 kDefaultSampleRate,
108 kDefaultBitsPerSample,
109 params.frames_per_buffer(),
110 media::AudioParameters::NO_EFFECTS);
111
112 converter_.reset(new media::AudioConverter(
113 params, dest_params, params.sample_rate() == dest_params.sample_rate()));
114 converter_->AddInput(this);
115
116 total_buffer_frames_ = kProcessIntervalMs * dest_params.sample_rate() / 1000;
117 buffer_ =
118 media::AudioBus::Create(dest_params.channels(), total_buffer_frames_);
119 buffer_frame_index_ = 0;
120
121 stream_ = input_stream_for_testing_
122 ? input_stream_for_testing_.get()
123 : media::AudioManager::Get()->MakeAudioInputStream(
124 params, media::AudioManagerBase::kDefaultDeviceId);
125
126 if (!stream_ || !stream_->Open()) {
127 LOG(ERROR) << "Failed to open an input stream.";
128 if (stream_) {
129 stream_->Close();
130 stream_ = NULL;
131 }
132 return;
133 }
134 stream_->SetVolume(stream_->GetMaxVolume());
135 }
136
RecordOnAudioThread()137 void AudioRecorder::RecordOnAudioThread() {
138 DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
139 if (!stream_ || is_recording_)
140 return;
141
142 converter_->Reset();
143 stream_->Start(this);
144 is_recording_ = true;
145 }
146
StopOnAudioThread()147 void AudioRecorder::StopOnAudioThread() {
148 DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
149 if (!stream_ || !is_recording_)
150 return;
151
152 stream_->Stop();
153 is_recording_ = false;
154 }
155
StopAndCloseOnAudioThread()156 void AudioRecorder::StopAndCloseOnAudioThread() {
157 DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
158 if (!stream_)
159 return;
160
161 StopOnAudioThread();
162 stream_->Close();
163 stream_ = NULL;
164 }
165
FinalizeOnAudioThread()166 void AudioRecorder::FinalizeOnAudioThread() {
167 DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
168 StopAndCloseOnAudioThread();
169 delete this;
170 }
171
OnData(media::AudioInputStream * stream,const media::AudioBus * source,uint32,double)172 void AudioRecorder::OnData(media::AudioInputStream* stream,
173 const media::AudioBus* source,
174 uint32 /* hardware_delay_bytes */,
175 double /* volume */) {
176 temp_conversion_buffer_ = source;
177 while (temp_conversion_buffer_) {
178 // source->frames() == source_params.frames_per_buffer(), so we only have
179 // one chunk of data in the source; correspondingly set the destination
180 // size to one chunk.
181 // TODO(rkc): Optimize this to directly write into buffer_ so we can avoid
182 // the copy into this buffer and then the copy back into buffer_.
183 scoped_ptr<media::AudioBus> converted_source =
184 media::AudioBus::Create(kDefaultChannels, converter_->ChunkSize());
185
186 // Convert accumulated samples into converted_source. Note: One call may not
187 // be enough to consume the samples from |source|. The converter may have
188 // accumulated samples over time due to a fractional input:output sample
189 // rate ratio. Since |source| is ephemeral, Convert() must be called until
190 // |source| is at least buffered into the converter. Once |source| is
191 // consumed during ProvideInput(), |temp_conversion_buffer_| will be set to
192 // NULL, which will break the conversion loop.
193 converter_->Convert(converted_source.get());
194
195 int remaining_buffer_frames = buffer_->frames() - buffer_frame_index_;
196 int frames_to_copy =
197 std::min(remaining_buffer_frames, converted_source->frames());
198 converted_source->CopyPartialFramesTo(
199 0, frames_to_copy, buffer_frame_index_, buffer_.get());
200 buffer_frame_index_ += frames_to_copy;
201
202 // Buffer full, send it for processing.
203 if (buffer_->frames() == buffer_frame_index_) {
204 ProcessSamples(buffer_.Pass(), decode_callback_);
205 buffer_ = media::AudioBus::Create(kDefaultChannels, total_buffer_frames_);
206 buffer_frame_index_ = 0;
207
208 // Copy any remaining frames in the source to our buffer.
209 int remaining_source_frames = converted_source->frames() - frames_to_copy;
210 converted_source->CopyPartialFramesTo(frames_to_copy,
211 remaining_source_frames,
212 buffer_frame_index_,
213 buffer_.get());
214 buffer_frame_index_ += remaining_source_frames;
215 }
216 }
217 }
218
OnError(media::AudioInputStream *)219 void AudioRecorder::OnError(media::AudioInputStream* /* stream */) {
220 LOG(ERROR) << "Error during sound recording.";
221 media::AudioManager::Get()->GetTaskRunner()->PostTask(
222 FROM_HERE,
223 base::Bind(&AudioRecorder::StopAndCloseOnAudioThread,
224 base::Unretained(this)));
225 }
226
ProvideInput(media::AudioBus * dest,base::TimeDelta)227 double AudioRecorder::ProvideInput(media::AudioBus* dest,
228 base::TimeDelta /* buffer_delay */) {
229 DCHECK(temp_conversion_buffer_);
230 DCHECK_LE(temp_conversion_buffer_->frames(), dest->frames());
231 temp_conversion_buffer_->CopyTo(dest);
232 temp_conversion_buffer_ = NULL;
233 return 1.0;
234 }
235
FlushAudioLoopForTesting()236 void AudioRecorder::FlushAudioLoopForTesting() {
237 if (media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread())
238 return;
239
240 // Queue task on the audio thread, when it is executed, that means we've
241 // successfully executed all the tasks before us.
242 base::RunLoop rl;
243 media::AudioManager::Get()->GetTaskRunner()->PostTaskAndReply(
244 FROM_HERE,
245 base::Bind(base::IgnoreResult(&AudioRecorder::FlushAudioLoopForTesting),
246 base::Unretained(this)),
247 rl.QuitClosure());
248 rl.Run();
249 }
250
251 } // namespace copresence
252