Adding new function ReadFrames() that returns the audio frame in planar

media/base/audio_buffer.cc

 // Copyright 2013 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 "media/base/audio_buffer.h"
 
 #include "base/logging.h"
 #include "media/base/audio_bus.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
@@ skipping 225 matching lines @@
   DCHECK(sample_format_ == kSampleFormatU8 ||
          sample_format_ == kSampleFormatS16 ||
          sample_format_ == kSampleFormatS32);
   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format_);
   int frame_size = channel_count_ * bytes_per_channel;
   const uint8* source_data = data_.get() + source_frame_offset * frame_size;
   dest->FromInterleavedPartial(
       source_data, dest_frame_offset, frames_to_copy, bytes_per_channel);
 }
 
+static inline int32 ConvertS16ToS32(int16 value) {
+  return static_cast<int32>(value) << 16;
+}
+
+static inline int32 ConvertF32ToS32(float value) {
+  return static_cast<int32>(value < 0
+                                ? (-value) * std::numeric_limits<int32>::min()
+                                : value * std::numeric_limits<int32>::max());
+}
+
+template <class Target, typename Converter>
+void InterleaveToS32(const std::vector<uint8*>& channel_data,
+                     size_t frames_to_copy,
+                     int trim_start,
+                     int32* dest_data,
+                     Converter convert_func) {
+  for (size_t ch = 0; ch < channel_data.size(); ++ch) {
+    const Target* source_data =
+        reinterpret_cast<const Target*>(channel_data[ch]) + trim_start;
+    for (size_t i = 0, offset = ch; i < frames_to_copy;
+         ++i, offset += channel_data.size())

[DaleCurtis, 2014/09/29 23:01:32]

{} since the for() spans multiple lines.

[pwestin(chromium), 2014/09/30 00:15:17]

Done.

+      dest_data[offset] = convert_func(source_data[i]);
+  }
+}
+
+void AudioBuffer::ReadFramesInterleavedS32(int frames_to_copy,
+                                           int32* dest_data) {
+  DCHECK_LE(frames_to_copy, adjusted_frame_count_);
+
+  switch (sample_format_) {
+    case kSampleFormatU8:
+      NOTIMPLEMENTED();
+      break;
+    case kSampleFormatS16:
+      // Format is interleaved signed16. Convert each value into int32 and
+      // insert into output channel data.
+      InterleaveToS32<int16>(channel_data_,
+                             frames_to_copy * channel_count_,
+                             trim_start_,
+                             dest_data,
+                             ConvertS16ToS32);
+      break;
+    case kSampleFormatS32: {
+      // Format is interleaved signed32; just copy the data.
+      const int32* source_data =
+          reinterpret_cast<const int32*>(channel_data_[0]) + trim_start_;
+      memcpy(dest_data,
+             source_data,
+             frames_to_copy * channel_count_ * sizeof(int32));
+    } break;
+    case kSampleFormatF32:
+      // Format is interleaved float. Convert each value into int32 and insert
+      // into output channel data.
+      InterleaveToS32<float>(channel_data_,
+                             frames_to_copy * channel_count_,
+                             trim_start_,
+                             dest_data,
+                             ConvertF32ToS32);
+      break;
+    case kSampleFormatPlanarS16:
+      // Format is planar signed 16 bit. Convert each value into int32 and
+      // insert into output channel data.
+      InterleaveToS32<int16>(channel_data_,
+                             frames_to_copy,
+                             trim_start_,
+                             dest_data,
+                             ConvertS16ToS32);
+      break;
+    case kSampleFormatPlanarF32:
+      // Format is planar float. Convert each value into int32 and insert into
+      // output channel data.
+      InterleaveToS32<float>(channel_data_,
+                             frames_to_copy,
+                             trim_start_,
+                             dest_data,
+                             ConvertF32ToS32);
+      break;
+    case kUnknownSampleFormat:
+      NOTREACHED();
+      break;
+  }
+}
+
 void AudioBuffer::TrimStart(int frames_to_trim) {
   CHECK_GE(frames_to_trim, 0);
   CHECK_LE(frames_to_trim, adjusted_frame_count_);
 
   // Adjust the number of frames in this buffer and where the start really is.
   adjusted_frame_count_ -= frames_to_trim;
   trim_start_ += frames_to_trim;
 
   // Adjust timestamp_ and duration_ to reflect the smaller number of frames.
   const base::TimeDelta old_duration = duration_;
@@ skipping 47 matching lines @@
     }
   } else {
     CHECK_EQ(frames_to_copy, 0);
   }
 
   // Trim the leftover data off the end of the buffer and update duration.
   TrimEnd(frames_to_trim);
 }
 
 }  // namespace media