Convert audio samples in Whispernet.

components/audio_modem/audio_recorder_impl.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/audio_modem/audio_recorder_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 36 matching lines @@
       content::BrowserThread::UI, FROM_HERE, base::Bind(callback, samples));
 }
 
 }  // namespace
 
 // Public methods.
 
 AudioRecorderImpl::AudioRecorderImpl()
     : is_recording_(false),
       stream_(nullptr),
-      temp_conversion_buffer_(nullptr),
       total_buffer_frames_(0),
       buffer_frame_index_(0) {
 }
 
 void AudioRecorderImpl::Initialize(
     const RecordedSamplesCallback& decode_callback) {
   decode_callback_ = decode_callback;
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&AudioRecorderImpl::InitializeOnAudioThread,
@@ skipping 28 matching lines @@
 
 void AudioRecorderImpl::InitializeOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
 
   media::AudioParameters params =
       params_for_testing_
           ? *params_for_testing_
           : media::AudioManager::Get()->GetInputStreamParameters(
                 media::AudioManagerBase::kDefaultDeviceId);
 
-  const media::AudioParameters dest_params(params.format(),
-                                           kDefaultChannelLayout,
-                                           kDefaultSampleRate,
-                                           kDefaultBitsPerSample,
-                                           params.frames_per_buffer(),
-                                           media::AudioParameters::NO_EFFECTS);
-
-  converter_.reset(new media::AudioConverter(
-      params, dest_params, params.sample_rate() == dest_params.sample_rate()));
-  converter_->AddInput(this);
-
-  total_buffer_frames_ = kProcessIntervalMs * dest_params.sample_rate() / 1000;
-  buffer_ =
-      media::AudioBus::Create(dest_params.channels(), total_buffer_frames_);
+  total_buffer_frames_ = kProcessIntervalMs * params.sample_rate() / 1000;
+  buffer_ = media::AudioBus::Create(params.channels(), total_buffer_frames_);
   buffer_frame_index_ = 0;
 
   stream_ = input_stream_for_testing_
                 ? input_stream_for_testing_.get()
                 : media::AudioManager::Get()->MakeAudioInputStream(
                       params, media::AudioManagerBase::kDefaultDeviceId);
 
   if (!stream_ || !stream_->Open()) {
     LOG(ERROR) << "Failed to open an input stream.";
     if (stream_) {
       stream_->Close();
       stream_ = nullptr;
     }
     return;
   }
   stream_->SetVolume(stream_->GetMaxVolume());
 }
 
 void AudioRecorderImpl::RecordOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   if (!stream_ || is_recording_)
     return;
 
   VLOG(3) << "Starting recording.";
-  converter_->Reset();
   stream_->Start(this);
   is_recording_ = true;
 }
 
 void AudioRecorderImpl::StopOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   if (!stream_ || !is_recording_)
     return;
 
   VLOG(3) << "Stopping recording.";
@@ skipping 14 matching lines @@
 void AudioRecorderImpl::FinalizeOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   StopAndCloseOnAudioThread();
   delete this;
 }
 
 void AudioRecorderImpl::OnData(media::AudioInputStream* stream,
                                const media::AudioBus* source,
                                uint32 /* hardware_delay_bytes */,
                                double /* volume */) {
-  temp_conversion_buffer_ = source;
-  while (temp_conversion_buffer_) {
-    // source->frames() == source_params.frames_per_buffer(), so we only have
-    // one chunk of data in the source; correspondingly set the destination
-    // size to one chunk.
-    // TODO(rkc): Optimize this to directly write into buffer_ so we can avoid
-    // the copy into this buffer and then the copy back into buffer_.
-    scoped_ptr<media::AudioBus> converted_source =
-        media::AudioBus::Create(kDefaultChannels, converter_->ChunkSize());
+  // source->frames() == source_params.frames_per_buffer(), so we only have
+  // one chunk of data in the source; correspondingly set the destination
+  // size to one chunk.
 
-    // Convert accumulated samples into converted_source. Note: One call may not
-    // be enough to consume the samples from |source|.  The converter may have
-    // accumulated samples over time due to a fractional input:output sample
-    // rate ratio.  Since |source| is ephemeral, Convert() must be called until
-    // |source| is at least buffered into the converter.  Once |source| is
-    // consumed during ProvideInput(), |temp_conversion_buffer_| will be set to
-    // NULL, which will break the conversion loop.
-    converter_->Convert(converted_source.get());
+  int remaining_buffer_frames = buffer_->frames() - buffer_frame_index_;
+  int frames_to_copy = std::min(remaining_buffer_frames, source->frames());
+  source->CopyPartialFramesTo(0, frames_to_copy, buffer_frame_index_,
+                              buffer_.get());
+  buffer_frame_index_ += frames_to_copy;
 
-    int remaining_buffer_frames = buffer_->frames() - buffer_frame_index_;
-    int frames_to_copy =
-        std::min(remaining_buffer_frames, converted_source->frames());
-    converted_source->CopyPartialFramesTo(
-        0, frames_to_copy, buffer_frame_index_, buffer_.get());
-    buffer_frame_index_ += frames_to_copy;
+  // Buffer full, send it for processing.
+  if (buffer_->frames() == buffer_frame_index_) {

[DaleCurtis, 2015/02/20 18:31:42]

Is this always going to be an exact match? It seems like it wouldn't be,
especially since you're copying remaining frames below.

[rkc, 2015/02/20 18:53:07]

It'll still be an exact match since if buffer_frame_index_ will only be
increased to the match buffer_->frames() and never over (since if we don't have
enough frames left in the buffer, the std::min 3 lines above will change
frames_to_copy to only the number of frames left in the buffer).

+    ProcessSamples(buffer_.Pass(), decode_callback_);
+    buffer_ = media::AudioBus::Create(kDefaultChannels, total_buffer_frames_);
+    buffer_frame_index_ = 0;
 
-    // Buffer full, send it for processing.
-    if (buffer_->frames() == buffer_frame_index_) {
-      ProcessSamples(buffer_.Pass(), decode_callback_);
-      buffer_ = media::AudioBus::Create(kDefaultChannels, total_buffer_frames_);
-      buffer_frame_index_ = 0;
-
-      // Copy any remaining frames in the source to our buffer.
-      int remaining_source_frames = converted_source->frames() - frames_to_copy;
-      converted_source->CopyPartialFramesTo(frames_to_copy,
-                                            remaining_source_frames,
-                                            buffer_frame_index_,
-                                            buffer_.get());
-      buffer_frame_index_ += remaining_source_frames;
-    }
+    // Copy any remaining frames in the source to our buffer.
+    int remaining_source_frames = source->frames() - frames_to_copy;
+    source->CopyPartialFramesTo(frames_to_copy, remaining_source_frames,
+                                buffer_frame_index_, buffer_.get());
+    buffer_frame_index_ += remaining_source_frames;
   }
 }
 
 void AudioRecorderImpl::OnError(media::AudioInputStream* /* stream */) {
   LOG(ERROR) << "Error during sound recording.";
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&AudioRecorderImpl::StopAndCloseOnAudioThread,
                  base::Unretained(this)));
 }
 
-double AudioRecorderImpl::ProvideInput(media::AudioBus* dest,
-                                       base::TimeDelta /* buffer_delay */) {
-  DCHECK(temp_conversion_buffer_);
-  DCHECK_LE(temp_conversion_buffer_->frames(), dest->frames());
-  temp_conversion_buffer_->CopyTo(dest);
-  temp_conversion_buffer_ = nullptr;
-  return 1.0;
-}
-
 void AudioRecorderImpl::FlushAudioLoopForTesting() {
   if (media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread())
     return;
 
   // Queue task on the audio thread, when it is executed, that means we've
   // successfully executed all the tasks before us.
   base::RunLoop rl;
   media::AudioManager::Get()->GetTaskRunner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&AudioRecorderImpl::FlushAudioLoopForTesting),
           base::Unretained(this)),
       rl.QuitClosure());
   rl.Run();
 }
 
 }  // namespace audio_modem