Adding an ALAC enum to AudioDecoderConfig

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 33 matching lines @@
 
   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format);
   DCHECK_LE(bytes_per_channel, kChannelAlignment);
   int data_size = frame_count * bytes_per_channel;
 
   // Empty buffer?
   if (!create_buffer)
     return;
 
   if (sample_format == kSampleFormatPlanarF32 ||
-      sample_format == kSampleFormatPlanarS16) {
+      sample_format == kSampleFormatPlanarS16 ||
+      sample_format == kSampleFormatPlanarS32) {
     // Planar data, so need to allocate buffer for each channel.
     // Determine per channel data size, taking into account alignment.
     int block_size_per_channel =
         (data_size + kChannelAlignment - 1) & ~(kChannelAlignment - 1);
     DCHECK_GE(block_size_per_channel, data_size);
 
     // Allocate a contiguous buffer for all the channel data.
     data_.reset(static_cast<uint8*>(base::AlignedAlloc(
         channel_count_ * block_size_per_channel, kChannelAlignment)));
     channel_data_.reserve(channel_count_);
@@ skipping 182 matching lines @@
 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());
 }
 
+// No need for conversion. Return value as is. Keeping function to align with
+// code structure.
+static inline int32 ConvertS32ToS32(int32 value) {
+  return value;
+}
+
 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;
@@ skipping 48 matching lines @@
       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 kSampleFormatPlanarS32:
+      // Format is planar signed 32 bit. Convert each value into int32 and
+      // insert into output channel data.
+      InterleaveToS32<int32>(channel_data_,
+                             frames_to_copy,
+                             trim_start_,
+                             dest_data,
+                             ConvertS32ToS32);
     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_);
 
@@ skipping 23 matching lines @@
   const int frames_to_trim = end - start;
   CHECK_GE(frames_to_trim, 0);
   CHECK_LE(frames_to_trim, adjusted_frame_count_);
 
   const int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format_);
   const int frames_to_copy = adjusted_frame_count_ - end;
   if (frames_to_copy > 0) {
     switch (sample_format_) {
       case kSampleFormatPlanarS16:
       case kSampleFormatPlanarF32:
+      case kSampleFormatPlanarS32:
         // Planar data must be shifted per channel.
         for (int ch = 0; ch < channel_count_; ++ch) {
           memmove(channel_data_[ch] + (trim_start_ + start) * bytes_per_channel,
                   channel_data_[ch] + (trim_start_ + end) * bytes_per_channel,
                   bytes_per_channel * frames_to_copy);
         }
         break;
       case kSampleFormatU8:
       case kSampleFormatS16:
       case kSampleFormatS32:
@@ skipping 10 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