AudioBus: Add a ToInterleavedFloat() method to AudioBus

content/renderer/media/audio_track_recorder.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 "content/renderer/media/audio_track_recorder.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 57 matching lines @@
     data_out->resize(result);
     return true;
   }
   // If |result| in {0,1}, do nothing; the documentation says that a return
   // value of zero or one means the packet does not need to be transmitted.
   // Otherwise, we have an error.
   DLOG_IF(ERROR, result < 0) << " encode failed: " << opus_strerror(result);
   return false;
 }
 
-// Interleaves |audio_bus| channels() of floats into a single output linear
-// |buffer|.
-// TODO(mcasas) https://crbug.com/580391 use AudioBus::ToInterleavedFloat().
-void ToInterleaved(media::AudioBus* audio_bus, float* buffer) {
-  for (int ch = 0; ch < audio_bus->channels(); ++ch) {
-    const float* src = audio_bus->channel(ch);
-    const float* const src_end = src + audio_bus->frames();
-    float* dest = buffer + ch;
-    for (; src < src_end; ++src, dest += audio_bus->channels())
-      *dest = *src;
-  }
-}
-
 }  // anonymous namespace
 
 // Nested class encapsulating opus-related encoding details. It contains an
 // AudioConverter to adapt incoming data to the format Opus likes to have.
 // AudioEncoder is created and destroyed on ATR's main thread (usually the main
 // render thread) but otherwise should operate entirely on |encoder_thread_|,
 // which is owned by AudioTrackRecorder. Be sure to delete |encoder_thread_|
 // before deleting the AudioEncoder using it.
 class AudioTrackRecorder::AudioEncoder
     : public base::RefCountedThreadSafe<AudioEncoder>,
@@ skipping 144 matching lines @@
   // TODO(mcasas): Consider using a std::deque<scoped_ptr<AudioBus>> instead of
   // an AudioFifo, to avoid copying data needlessly since we know the sizes of
   // both input and output and they are multiples.
   fifo_->Push(input_bus.get());
 
   // Wait to have enough |input_bus|s to guarantee a satisfactory conversion.
   while (fifo_->frames() >= input_params_.frames_per_buffer()) {
     scoped_ptr<media::AudioBus> audio_bus = media::AudioBus::Create(
         output_params_.channels(), kOpusPreferredFramesPerBuffer);
     converter_->Convert(audio_bus.get());
-    ToInterleaved(audio_bus.get(), buffer_.get());
+    audio_bus->ToInterleavedFloat(0, 0, audio_bus->frames(),
+                                  buffer_.get());
 
     scoped_ptr<std::string> encoded_data(new std::string());
     if (DoEncode(opus_encoder_, buffer_.get(), kOpusPreferredFramesPerBuffer,
                  encoded_data.get())) {
       const base::TimeTicks capture_time_of_first_sample =
           capture_time -
           base::TimeDelta::FromMicroseconds(fifo_->frames() *
                                             base::Time::kMicrosecondsPerSecond /
                                             input_params_.sample_rate());
       on_encoded_audio_cb_.Run(output_params_, std::move(encoded_data),
@@ skipping 63 matching lines @@
   scoped_ptr<media::AudioBus> audio_data =
       media::AudioBus::Create(audio_bus.channels(), audio_bus.frames());
   audio_bus.CopyTo(audio_data.get());
 
   encoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&AudioEncoder::EncodeAudio, encoder_,
                             base::Passed(&audio_data), capture_time));
 }
 
 }  // namespace content