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 const int32 kint24min  = -0x7FFFFF - 1;
+static const int32 kint24max  =  0x7FFFFF;
+static const int32 kUint8Bias = 128;

[DaleCurtis, 2014/09/24 22:30:17]

remove capital U or capitalize int above.

+
+static inline int32 ConvertS16ToS32(int16 value) {
+  return static_cast<int32>(value) << 8;

[DaleCurtis, 2014/09/24 22:30:17]

These are mislabeled, you're actually converting to S24. 

+}
+
+static inline int32 ConvertU8ToS32(uint8 value) {
+  return (static_cast<int32>(value) - kUint8Bias) << 16;
+}
+
+static inline int32 ConvertF32ToS32(float value) {
+  return static_cast<int32>(value < 0 ? value * kint24min : value * kint24max);
+}
+
+std::vector<int32> AudioBuffer::ReadFrames() {

[DaleCurtis, 2014/09/24 22:30:17]

All these conversion methods need to take trim_start into account.

+  int dest_data_offset = 0;
+  std::vector<int32> dest_data;
+  dest_data.reserve(channel_count_ * adjusted_frame_count_);
+
+  if (sample_format_ == kSampleFormatU8) {

[DaleCurtis, 2014/09/24 22:30:17]

It may be worth finally adding in FFmpeg's super optimized libavresample or at
least some shim to get their sample format converters. We don't use it today
since it's a lot of extra code, but a shim approach could be profitable if
you're on a constrained system, third_party/libavresample.

+    // Unsigned 8-bit w/ bias of 128.
+    const uint8* source_data =
+        reinterpret_cast<const uint8*>(channel_data_[0]);
+
+    for (int i = 0; i < adjusted_frame_count_ * channel_count_; ++i) {
+      dest_data[i] = ConvertU8ToS32(source_data[i]);
+    }
+  } else if (sample_format_ == kSampleFormatS16) {
+    // Format is interleaved signed16. Convert each value into int32 and insert
+    // into output channel data.
+    const int16* source_data =
+        reinterpret_cast<const int16*>(channel_data_[0]);
+
+    for (int i = 0; i < adjusted_frame_count_ * channel_count_; ++i) {
+      dest_data[i] = ConvertS16ToS32(source_data[i]);
+    }
+  } else if (sample_format_ == kSampleFormatS32) {
+    // Format is interleaved signed32; just copy the data.
+    const int32* source_data =
+        reinterpret_cast<const int32*>(channel_data_[0]);
+    dest_data.insert(dest_data.begin(),
+                     source_data,
+                     source_data + (adjusted_frame_count_ * channel_count_));
+  } else if (sample_format_ == kSampleFormatF32) {
+    // Format is interleaved float. Convert each value into int32 and insert
+    // into output channel data.
+    const float* source_data = reinterpret_cast<const float*>(channel_data_[0]);
+    for (int i = 0; i < adjusted_frame_count_ * channel_count_; ++i) {
+      dest_data[i] = ConvertF32ToS32(source_data[i]);
+    }
+  } else if (sample_format_ == kSampleFormatPlanarS16) {
+    // Format is planar signed16. Convert each value into int32 and insert into
+    // output channel data.
+    for (int ch = 0; ch < channel_count_; ++ch) {
+      const int16* source_data =
+          reinterpret_cast<const int16*>(channel_data_[ch]);
+
+      for (int i = 0; i < adjusted_frame_count_; ++i) {
+        dest_data[i + dest_data_offset] = ConvertS16ToS32(source_data[i]);
+      }
+      dest_data_offset += adjusted_frame_count_;
+    }
+  } else if (sample_format_ == kSampleFormatPlanarF32) {
+    // Format is planar float. Convert each value into int32 and insert into
+    // output channel data.
+    for (int ch = 0; ch < channel_count_; ++ch) {
+      const float* source_data =
+          reinterpret_cast<const float*>(channel_data_[ch]);
+
+      for (int i = 0; i < adjusted_frame_count_; ++i) {
+        dest_data[i + dest_data_offset] = ConvertF32ToS32(source_data[i]);
+      }
+      dest_data_offset += adjusted_frame_count_;
+    }
+  } else {
+    NOTREACHED();
+  }
+  return dest_data;
+}
+
 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