src/components/copresence/mediums/audio/audio_recorder.cc

   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
  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.
  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
  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
  61 void AudioRecorder::Initialize() {
  62   media::AudioManager::Get()->GetTaskRunner()->PostTask(
  63       FROM_HERE,
  64       base::Bind(&AudioRecorder::InitializeOnAudioThread,
  65                  base::Unretained(this)));
  66 }
  67
  68 AudioRecorder::~AudioRecorder() {
  69 }
  70
  71 void AudioRecorder::Record() {
  72   media::AudioManager::Get()->GetTaskRunner()->PostTask(
  73       FROM_HERE,
  74       base::Bind(&AudioRecorder::RecordOnAudioThread, base::Unretained(this)));
  75 }
  76
  77 void AudioRecorder::Stop() {
  78   media::AudioManager::Get()->GetTaskRunner()->PostTask(
  79       FROM_HERE,
  80       base::Bind(&AudioRecorder::StopOnAudioThread, base::Unretained(this)));
  81 }
  82
  83 bool AudioRecorder::IsRecording() {
  84   return is_recording_;
  85 }
  86
  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
  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
 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
 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
 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
 166 void AudioRecorder::FinalizeOnAudioThread() {
 167   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
 168   StopAndCloseOnAudioThread();
 169   delete this;
 170 }
 171
 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
 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
 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
 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