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
21namespace copresence {
22
23namespace {
24
25const float kProcessIntervalMs = 500.0f;  // milliseconds.
26
27void 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.
41void 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
53AudioRecorder::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
61void AudioRecorder::Initialize() {
62  media::AudioManager::Get()->GetTaskRunner()->PostTask(
63      FROM_HERE,
64      base::Bind(&AudioRecorder::InitializeOnAudioThread,
65                 base::Unretained(this)));
66}
67
68AudioRecorder::~AudioRecorder() {
69}
70
71void AudioRecorder::Record() {
72  media::AudioManager::Get()->GetTaskRunner()->PostTask(
73      FROM_HERE,
74      base::Bind(&AudioRecorder::RecordOnAudioThread, base::Unretained(this)));
75}
76
77void AudioRecorder::Stop() {
78  media::AudioManager::Get()->GetTaskRunner()->PostTask(
79      FROM_HERE,
80      base::Bind(&AudioRecorder::StopOnAudioThread, base::Unretained(this)));
81}
82
83bool AudioRecorder::IsRecording() {
84  return is_recording_;
85}
86
87void 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
96void 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
137void 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
147void 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
156void 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
166void AudioRecorder::FinalizeOnAudioThread() {
167  DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
168  StopAndCloseOnAudioThread();
169  delete this;
170}
171
172void 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
219void 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
227double 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
236void 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