Add channel_count parameter back to AudioBuffer creation methods.

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"
 
 namespace media {
 
 AudioBuffer::AudioBuffer(SampleFormat sample_format,
                          ChannelLayout channel_layout,
+                         int channel_count,
                          int sample_rate,
                          int frame_count,
                          bool create_buffer,
                          const uint8* const* data,
                          const base::TimeDelta timestamp,
                          const base::TimeDelta duration)
     : sample_format_(sample_format),
       channel_layout_(channel_layout),
-      channel_count_(ChannelLayoutToChannelCount(channel_layout)),
+      channel_count_(channel_count),
       sample_rate_(sample_rate),
       adjusted_frame_count_(frame_count),
       trim_start_(0),
       end_of_stream_(!create_buffer && data == NULL && frame_count == 0),
       timestamp_(timestamp),
       duration_(duration) {
   CHECK_GE(channel_count_, 0);
   CHECK_LE(channel_count_, limits::kMaxChannels);
   CHECK_GE(frame_count, 0);
+  DCHECK(channel_layout == CHANNEL_LAYOUT_DISCRETE ||
+         ChannelLayoutToChannelCount(channel_layout) == channel_count);
+
   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) {
@@ skipping 32 matching lines @@
   if (data)
     memcpy(data_.get(), data[0], data_size);
 }
 
 AudioBuffer::~AudioBuffer() {}
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CopyFrom(
     SampleFormat sample_format,
     ChannelLayout channel_layout,
+    int channel_count,
     int sample_rate,
     int frame_count,
     const uint8* const* data,
     const base::TimeDelta timestamp,
     const base::TimeDelta duration) {
   // If you hit this CHECK you likely have a bug in a demuxer. Go fix it.
   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
   CHECK(data[0]);
   return make_scoped_refptr(new AudioBuffer(sample_format,
                                             channel_layout,
+                                            channel_count,
                                             sample_rate,
                                             frame_count,
                                             true,
                                             data,
                                             timestamp,
                                             duration));
 }
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateBuffer(
     SampleFormat sample_format,
     ChannelLayout channel_layout,
+    int channel_count,
     int sample_rate,
     int frame_count) {
   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
   return make_scoped_refptr(new AudioBuffer(sample_format,
                                             channel_layout,
+                                            channel_count,
                                             sample_rate,
                                             frame_count,
                                             true,
                                             NULL,
                                             kNoTimestamp(),
                                             kNoTimestamp()));
 }
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateEmptyBuffer(
     ChannelLayout channel_layout,
+    int channel_count,
     int sample_rate,
     int frame_count,
     const base::TimeDelta timestamp,
     const base::TimeDelta duration) {
   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
   // Since data == NULL, format doesn't matter.
   return make_scoped_refptr(new AudioBuffer(kSampleFormatF32,
                                             channel_layout,
+                                            channel_count,
                                             sample_rate,
                                             frame_count,
                                             false,
                                             NULL,
                                             timestamp,
                                             duration));
 }
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateEOSBuffer() {
   return make_scoped_refptr(new AudioBuffer(kUnknownSampleFormat,
                                             CHANNEL_LAYOUT_NONE,
                                             0,
                                             0,
+                                            0,
                                             false,
                                             NULL,
                                             kNoTimestamp(),
                                             kNoTimestamp()));
 }
 
 // Convert int16 values in the range [kint16min, kint16max] to [-1.0, 1.0].
 static inline float ConvertS16ToFloat(int16 value) {
   return value * (value < 0 ? -1.0f / kint16min : 1.0f / kint16max);
 }
@@ skipping 102 matching lines @@
                   frames_to_trim / adjusted_frame_count_;
   base::TimeDelta offset_as_time =
       base::TimeDelta::FromMicroseconds(static_cast<int64>(offset));
   duration_ -= offset_as_time;
 
   // Finally adjust the number of frames in this buffer.
   adjusted_frame_count_ -= frames_to_trim;
 }
 
 }  // namespace media