Add channel_count parameter back to AudioBuffer creation methods.

This fixes a bug where we failed to set the proper channel count on
AudioBuffers with the CHANNEL_LAYOUT_DISCRETE channel layout.

BUG=357801
R=dalecurtis@chromium.org
TBR=dmichael

Review URL: https://codereview.chromium.org/212103013

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@260333 0039d316-1c4b-4281-b951-d872f2087c98

content/renderer/pepper/content_decryptor_delegate.cc

@@ -1024,6 +1024,7 @@ bool ContentDecryptorDelegate::DeserializeAudioFrames(
     scoped_refptr<media::AudioBuffer> frame = media::AudioBuffer::CopyFrom(
         sample_format,
         audio_channel_layout_,
+        audio_channel_count_,
         audio_samples_per_second_,
         frame_count,
         &channel_ptrs[0],

media/base/audio_buffer.cc

@@ -13,6 +13,7 @@ namespace media {
 
 AudioBuffer::AudioBuffer(SampleFormat sample_format,
                          ChannelLayout channel_layout,
+                         int channel_count,
                          int sample_rate,
                          int frame_count,
                          bool create_buffer,
@@ -21,7 +22,7 @@ AudioBuffer::AudioBuffer(SampleFormat sample_format,
                          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),
@@ -31,6 +32,9 @@ AudioBuffer::AudioBuffer(SampleFormat sample_format,
   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;
@@ -83,6 +87,7 @@ AudioBuffer::~AudioBuffer() {}
 scoped_refptr<AudioBuffer> AudioBuffer::CopyFrom(
     SampleFormat sample_format,
     ChannelLayout channel_layout,
+    int channel_count,
     int sample_rate,
     int frame_count,
     const uint8* const* data,
@@ -93,6 +98,7 @@ scoped_refptr<AudioBuffer> AudioBuffer::CopyFrom(
   CHECK(data[0]);
   return make_scoped_refptr(new AudioBuffer(sample_format,
                                             channel_layout,
+                                            channel_count,
                                             sample_rate,
                                             frame_count,
                                             true,
@@ -105,11 +111,13 @@ scoped_refptr<AudioBuffer> AudioBuffer::CopyFrom(
 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,
@@ -121,6 +129,7 @@ scoped_refptr<AudioBuffer> AudioBuffer::CreateBuffer(
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateEmptyBuffer(
     ChannelLayout channel_layout,
+    int channel_count,
     int sample_rate,
     int frame_count,
     const base::TimeDelta timestamp,
@@ -129,6 +138,7 @@ scoped_refptr<AudioBuffer> AudioBuffer::CreateEmptyBuffer(
   // Since data == NULL, format doesn't matter.
   return make_scoped_refptr(new AudioBuffer(kSampleFormatF32,
                                             channel_layout,
+                                            channel_count,
                                             sample_rate,
                                             frame_count,
                                             false,
@@ -143,6 +153,7 @@ scoped_refptr<AudioBuffer> AudioBuffer::CreateEOSBuffer() {
                                             CHANNEL_LAYOUT_NONE,
                                             0,
                                             0,
+                                            0,
                                             false,
                                             NULL,
                                             kNoTimestamp(),

media/base/audio_buffer.h

@@ -38,6 +38,7 @@ class MEDIA_EXPORT AudioBuffer
   // TODO(jrummell): Compute duration rather than pass it in.
   static scoped_refptr<AudioBuffer> CopyFrom(SampleFormat sample_format,
                                              ChannelLayout channel_layout,
+                                             int channel_count,
                                              int sample_rate,
                                              int frame_count,
                                              const uint8* const* data,
@@ -48,12 +49,14 @@ class MEDIA_EXPORT AudioBuffer
   // not initialized. Timestamp and duration are set to kNoTimestamp().
   static scoped_refptr<AudioBuffer> CreateBuffer(SampleFormat sample_format,
                                                  ChannelLayout channel_layout,
+                                                 int channel_count,
                                                  int sample_rate,
                                                  int frame_count);
 
   // Create an empty AudioBuffer with |frame_count| frames.
   static scoped_refptr<AudioBuffer> CreateEmptyBuffer(
       ChannelLayout channel_layout,
+      int channel_count,
       int sample_rate,
       int frame_count,
       const base::TimeDelta timestamp,
@@ -123,6 +126,7 @@ class MEDIA_EXPORT AudioBuffer
   // copied to).
   AudioBuffer(SampleFormat sample_format,
               ChannelLayout channel_layout,
+              int channel_count,
               int sample_rate,
               int frame_count,
               bool create_buffer,

media/base/audio_buffer_converter.cc

@@ -188,6 +188,7 @@ void AudioBufferConverter::ConvertIfPossible() {
   scoped_refptr<AudioBuffer> output_buffer =
       AudioBuffer::CreateBuffer(kSampleFormatPlanarF32,
                                 output_params_.channel_layout(),
+                                output_params_.channels(),
                                 output_params_.sample_rate(),
                                 request_frames);
   scoped_ptr<AudioBus> output_bus =

media/base/audio_buffer_converter_unittest.cc

@@ -14,12 +14,15 @@ namespace media {
 
 const int kOutSampleRate = 44100;
 const ChannelLayout kOutChannelLayout = CHANNEL_LAYOUT_STEREO;
+const int kOutChannelCount = 2;
 
 static scoped_refptr<AudioBuffer> MakeTestBuffer(int sample_rate,
                                                  ChannelLayout channel_layout,
+                                                 int channel_count,
                                                  int frames) {
   return MakeAudioBuffer<uint8>(kSampleFormatU8,
                                 channel_layout,
+                                channel_count,
                                 sample_rate,
                                 0,
                                 1,
@@ -37,7 +40,7 @@ class AudioBufferConverterTest : public ::testing::Test {
                                   kOutSampleRate,
                                   16,
                                   512);
-    audio_buffer_converter_.reset(new AudioBufferConverter(output_params));
+    ResetConverter(output_params);
   }
 
   void Reset() {
@@ -61,8 +64,9 @@ class AudioBufferConverterTest : public ::testing::Test {
       scoped_refptr<AudioBuffer> out = audio_buffer_converter_->GetNextBuffer();
       if (!out->end_of_stream()) {
         output_frames_ += out->frame_count();
-        EXPECT_EQ(out->sample_rate(), kOutSampleRate);
-        EXPECT_EQ(out->channel_layout(), kOutChannelLayout);
+        EXPECT_EQ(out->sample_rate(), out_sample_rate_);
+        EXPECT_EQ(out->channel_layout(), out_channel_layout_);
+        EXPECT_EQ(out->channel_count(), out_channel_count_);
       } else {
         EXPECT_FALSE(audio_buffer_converter_->HasNextBuffer());
       }
@@ -70,29 +74,42 @@ class AudioBufferConverterTest : public ::testing::Test {
     EXPECT_EQ(output_frames_, ceil(expected_output_frames_));
   }
 
+  void ResetConverter(AudioParameters out_params) {
+    audio_buffer_converter_.reset(new AudioBufferConverter(out_params));
+    out_channel_layout_ = out_params.channel_layout();
+    out_channel_count_ = out_params.channels();
+    out_sample_rate_ = out_params.sample_rate();
+  }
+
  private:
   scoped_ptr<AudioBufferConverter> audio_buffer_converter_;
 
   int input_frames_;
   double expected_output_frames_;
   int output_frames_;
+
+  int out_sample_rate_;
+  ChannelLayout out_channel_layout_;
+  int out_channel_count_;
 };
 
 TEST_F(AudioBufferConverterTest, PassThrough) {
   scoped_refptr<AudioBuffer> in =
-      MakeTestBuffer(kOutSampleRate, kOutChannelLayout, 512);
+      MakeTestBuffer(kOutSampleRate, kOutChannelLayout, kOutChannelCount, 512);
   AddInput(in);
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, Downsample) {
-  scoped_refptr<AudioBuffer> in = MakeTestBuffer(48000, kOutChannelLayout, 512);
+  scoped_refptr<AudioBuffer> in =
+      MakeTestBuffer(48000, kOutChannelLayout, kOutChannelCount, 512);
   AddInput(in);
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, Upsample) {
-  scoped_refptr<AudioBuffer> in = MakeTestBuffer(8000, kOutChannelLayout, 512);
+  scoped_refptr<AudioBuffer> in =
+      MakeTestBuffer(8000, kOutChannelLayout, kOutChannelCount, 512);
   AddInput(in);
   ConsumeAllOutput();
 }
@@ -100,69 +117,74 @@ TEST_F(AudioBufferConverterTest, Upsample) {
 // Test resampling a buffer smaller than the SincResampler's kernel size.
 TEST_F(AudioBufferConverterTest, Resample_TinyBuffer) {
   AddInput(MakeTestBuffer(
-      48000, CHANNEL_LAYOUT_STEREO, SincResampler::kKernelSize - 1));
+      48000, CHANNEL_LAYOUT_STEREO, 2, SincResampler::kKernelSize - 1));
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, Resample_DifferingBufferSizes) {
   const int input_sample_rate = 48000;
-  AddInput(MakeTestBuffer(input_sample_rate, kOutChannelLayout, 100));
-  AddInput(MakeTestBuffer(input_sample_rate, kOutChannelLayout, 200));
-  AddInput(MakeTestBuffer(input_sample_rate, kOutChannelLayout, 300));
-  AddInput(MakeTestBuffer(input_sample_rate, kOutChannelLayout, 400));
-  AddInput(MakeTestBuffer(input_sample_rate, kOutChannelLayout, 500));
+  AddInput(MakeTestBuffer(
+      input_sample_rate, kOutChannelLayout, kOutChannelCount, 100));
+  AddInput(MakeTestBuffer(
+      input_sample_rate, kOutChannelLayout, kOutChannelCount, 200));
+  AddInput(MakeTestBuffer(
+      input_sample_rate, kOutChannelLayout, kOutChannelCount, 300));
+  AddInput(MakeTestBuffer(
+      input_sample_rate, kOutChannelLayout, kOutChannelCount, 400));
+  AddInput(MakeTestBuffer(
+      input_sample_rate, kOutChannelLayout, kOutChannelCount, 500));
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ChannelDownmix) {
   scoped_refptr<AudioBuffer> in =
-      MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_MONO, 512);
+      MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_MONO, 1, 512);
   AddInput(in);
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ChannelUpmix) {
   scoped_refptr<AudioBuffer> in =
-      MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_5_1, 512);
+      MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_5_1, 6, 512);
   AddInput(in);
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ResampleAndRemix) {
   scoped_refptr<AudioBuffer> in =
-      MakeTestBuffer(48000, CHANNEL_LAYOUT_5_1, 512);
+      MakeTestBuffer(48000, CHANNEL_LAYOUT_5_1, 6, 512);
   AddInput(in);
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ConfigChange_SampleRate) {
-  AddInput(MakeTestBuffer(48000, kOutChannelLayout, 512));
-  AddInput(MakeTestBuffer(44100, kOutChannelLayout, 512));
+  AddInput(MakeTestBuffer(48000, kOutChannelLayout, kOutChannelCount, 512));
+  AddInput(MakeTestBuffer(44100, kOutChannelLayout, kOutChannelCount, 512));
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ConfigChange_ChannelLayout) {
-  AddInput(MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_STEREO, 512));
-  AddInput(MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_MONO, 512));
+  AddInput(MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_STEREO, 2, 512));
+  AddInput(MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_MONO, 1, 512));
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ConfigChange_SampleRateAndChannelLayout) {
-  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_STEREO, 512));
-  AddInput(MakeTestBuffer(48000, CHANNEL_LAYOUT_MONO, 512));
+  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_STEREO, 2, 512));
+  AddInput(MakeTestBuffer(48000, CHANNEL_LAYOUT_MONO, 1, 512));
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ConfigChange_Multiple) {
-  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_STEREO, 512));
-  AddInput(MakeTestBuffer(48000, CHANNEL_LAYOUT_MONO, 512));
-  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_5_1, 512));
-  AddInput(MakeTestBuffer(22050, CHANNEL_LAYOUT_STEREO, 512));
+  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_STEREO, 2, 512));
+  AddInput(MakeTestBuffer(48000, CHANNEL_LAYOUT_MONO, 1, 512));
+  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_5_1, 6, 512));
+  AddInput(MakeTestBuffer(22050, CHANNEL_LAYOUT_STEREO, 2, 512));
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, Reset) {
-  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_STEREO, 512));
+  AddInput(MakeTestBuffer(44100, CHANNEL_LAYOUT_STEREO, 2, 512));
   Reset();
   ConsumeAllOutput();
 }
@@ -170,16 +192,32 @@ TEST_F(AudioBufferConverterTest, Reset) {
 TEST_F(AudioBufferConverterTest, ResampleThenReset) {
   // Resampling is likely to leave some data buffered in AudioConverter's
   // fifo or resampler, so make sure Reset() cleans that all up.
-  AddInput(MakeTestBuffer(48000, CHANNEL_LAYOUT_STEREO, 512));
+  AddInput(MakeTestBuffer(48000, CHANNEL_LAYOUT_STEREO, 2, 512));
   Reset();
   ConsumeAllOutput();
 }
 
 TEST_F(AudioBufferConverterTest, ResetThenConvert) {
-  AddInput(MakeTestBuffer(kOutSampleRate, kOutChannelLayout, 512));
+  AddInput(
+      MakeTestBuffer(kOutSampleRate, kOutChannelLayout, kOutChannelCount, 512));
   Reset();
   // Make sure we can keep using the AudioBufferConverter after we've Reset().
-  AddInput(MakeTestBuffer(kOutSampleRate, kOutChannelLayout, 512));
+  AddInput(
+      MakeTestBuffer(kOutSampleRate, kOutChannelLayout, kOutChannelCount, 512));
+  ConsumeAllOutput();
+}
+
+TEST_F(AudioBufferConverterTest, DiscreteChannelLayout) {
+  AudioParameters output_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                                CHANNEL_LAYOUT_DISCRETE,
+                                2,
+                                0,
+                                kOutSampleRate,
+                                16,
+                                512,
+                                0);
+  ResetConverter(output_params);
+  AddInput(MakeTestBuffer(kOutSampleRate, CHANNEL_LAYOUT_STEREO, 2, 512));
   ConsumeAllOutput();
 }
 

media/base/audio_buffer_queue_unittest.cc

@@ -39,6 +39,7 @@ static scoped_refptr<AudioBuffer> MakeTestBuffer(SampleFormat format,
   const base::TimeDelta kNoTime = kNoTimestamp();
   return MakeAudioBuffer<T>(format,
                             channel_layout,
+                            ChannelLayoutToChannelCount(channel_layout),
                             kSampleRate,
                             start,
                             end,
@@ -388,6 +389,7 @@ TEST(AudioBufferQueueTest, Time) {
   //   second: start=30s, duration=10s
   buffer.Append(MakeAudioBuffer<int16>(kSampleFormatS16,
                                        channel_layout,
+                                       channels,
                                        kSampleRate,
                                        1,
                                        1,
@@ -412,6 +414,7 @@ TEST(AudioBufferQueueTest, Time) {
   // Add second buffer for more data.
   buffer.Append(MakeAudioBuffer<int16>(kSampleFormatS16,
                                        channel_layout,
+                                       channels,
                                        kSampleRate,
                                        1,
                                        1,

media/base/audio_buffer_unittest.cc

@@ -30,14 +30,16 @@ TEST(AudioBufferTest, CopyFrom) {
   const int frames = 8;
   const base::TimeDelta start_time;
   const base::TimeDelta duration = base::TimeDelta::FromSeconds(frames);
-  scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<uint8>(kSampleFormatU8,
-                                                             channel_layout,
-                                                             kSampleRate,
-                                                             1,
-                                                             1,
-                                                             frames,
-                                                             start_time,
-                                                             duration);
+  scoped_refptr<AudioBuffer> buffer =
+      MakeAudioBuffer<uint8>(kSampleFormatU8,
+                             channel_layout,
+                             ChannelLayoutToChannelCount(channel_layout),
+                             kSampleRate,
+                             1,
+                             1,
+                             frames,
+                             start_time,
+                             duration);
   EXPECT_EQ(frames, buffer->frame_count());
   EXPECT_EQ(buffer->timestamp(), start_time);
   EXPECT_EQ(buffer->duration().InSeconds(), frames);
@@ -60,6 +62,7 @@ TEST(AudioBufferTest, FrameSize) {
   scoped_refptr<AudioBuffer> buffer =
       AudioBuffer::CopyFrom(kSampleFormatU8,
                             CHANNEL_LAYOUT_STEREO,
+                            2,
                             kSampleRate,
                             16,
                             data,
@@ -69,6 +72,7 @@ TEST(AudioBufferTest, FrameSize) {
 
   buffer = AudioBuffer::CopyFrom(kSampleFormatF32,
                                  CHANNEL_LAYOUT_4_0,
+                                 4,
                                  kSampleRate,
                                  2,
                                  data,
@@ -85,6 +89,7 @@ TEST(AudioBufferTest, ReadU8) {
   const base::TimeDelta duration = base::TimeDelta::FromSeconds(frames);
   scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<uint8>(kSampleFormatU8,
                                                              channel_layout,
+                                                             channels,
                                                              kSampleRate,
                                                              128,
                                                              1,
@@ -112,6 +117,7 @@ TEST(AudioBufferTest, ReadS16) {
   const base::TimeDelta duration = base::TimeDelta::FromSeconds(frames);
   scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<int16>(kSampleFormatS16,
                                                              channel_layout,
+                                                             channels,
                                                              kSampleRate,
                                                              1,
                                                              1,
@@ -144,6 +150,7 @@ TEST(AudioBufferTest, ReadS32) {
   const base::TimeDelta duration = base::TimeDelta::FromSeconds(frames);
   scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<int32>(kSampleFormatS32,
                                                              channel_layout,
+                                                             channels,
                                                              kSampleRate,
                                                              1,
                                                              1,
@@ -174,6 +181,7 @@ TEST(AudioBufferTest, ReadF32) {
   const base::TimeDelta duration = base::TimeDelta::FromSeconds(frames);
   scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<float>(kSampleFormatF32,
                                                              channel_layout,
+                                                             channels,
                                                              kSampleRate,
                                                              1.0f,
                                                              1.0f,
@@ -204,6 +212,7 @@ TEST(AudioBufferTest, ReadS16Planar) {
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<int16>(kSampleFormatPlanarS16,
                              channel_layout,
+                             channels,
                              kSampleRate,
                              1,
                              1,
@@ -245,6 +254,7 @@ TEST(AudioBufferTest, ReadF32Planar) {
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<float>(kSampleFormatPlanarF32,
                              channel_layout,
+                             channels,
                              kSampleRate,
                              1.0f,
                              1.0f,
@@ -278,7 +288,7 @@ TEST(AudioBufferTest, EmptyBuffer) {
   const base::TimeDelta start_time;
   const base::TimeDelta duration = base::TimeDelta::FromSeconds(frames);
   scoped_refptr<AudioBuffer> buffer = AudioBuffer::CreateEmptyBuffer(
-      channel_layout, kSampleRate, frames, start_time, duration);
+      channel_layout, channels, kSampleRate, frames, start_time, duration);
   EXPECT_EQ(frames, buffer->frame_count());
   EXPECT_EQ(start_time, buffer->timestamp());
   EXPECT_EQ(frames, buffer->duration().InSeconds());
@@ -302,6 +312,7 @@ TEST(AudioBufferTest, Trim) {
   scoped_refptr<AudioBuffer> buffer =
       MakeAudioBuffer<float>(kSampleFormatPlanarF32,
                              channel_layout,
+                             channels,
                              kSampleRate,
                              1.0f,
                              1.0f,

media/base/audio_splicer.cc

@@ -182,6 +182,7 @@ bool AudioStreamSanitizer::AddInput(const scoped_refptr<AudioBuffer>& input) {
     // add it to the output buffer.
     scoped_refptr<AudioBuffer> gap = AudioBuffer::CreateEmptyBuffer(
         input->channel_layout(),
+        input->channel_count(),
         input->sample_rate(),
         frames_to_fill,
         expected_timestamp,
@@ -433,6 +434,7 @@ scoped_ptr<AudioBus> AudioSplicer::ExtractCrossfadeFromPreSplice(
       // Allocate output buffer for crossfade.
       *crossfade_buffer = AudioBuffer::CreateBuffer(kSampleFormatPlanarF32,
                                                     preroll->channel_layout(),
+                                                    preroll->channel_count(),
                                                     preroll->sample_rate(),
                                                     frames_to_crossfade);
     }

media/base/audio_splicer_unittest.cc

@@ -38,6 +38,7 @@ class AudioSplicerTest : public ::testing::Test {
     scoped_refptr<AudioBuffer> buffer = MakeAudioBuffer<float>(
         kSampleFormat,
         kChannelLayout,
+        kChannels,
         kDefaultSampleRate,
         value,
         0.0f,
@@ -130,6 +131,7 @@ class AudioSplicerTest : public ::testing::Test {
             ? AudioBuffer::CreateEOSBuffer()
             : AudioBuffer::CopyFrom(kSampleFormat,
                                     input->channel_layout(),
+                                    input->channel_count(),
                                     input->sample_rate(),
                                     input->frame_count(),
                                     &input->channel_data()[0],

media/base/test_helpers.cc

@@ -151,6 +151,7 @@ gfx::Size TestVideoConfig::LargeCodedSize() {
 template <class T>
 scoped_refptr<AudioBuffer> MakeAudioBuffer(SampleFormat format,
                                            ChannelLayout channel_layout,
+                                           int channel_count,
                                            int sample_rate,
                                            T start,
                                            T increment,
@@ -158,8 +159,8 @@ scoped_refptr<AudioBuffer> MakeAudioBuffer(SampleFormat format,
                                            base::TimeDelta timestamp,
                                            base::TimeDelta duration) {
   int channels = ChannelLayoutToChannelCount(channel_layout);
-  scoped_refptr<AudioBuffer> output =
-      AudioBuffer::CreateBuffer(format, channel_layout, sample_rate, frames);
+  scoped_refptr<AudioBuffer> output = AudioBuffer::CreateBuffer(
+      format, channel_layout, channel_count, sample_rate, frames);
   output->set_timestamp(timestamp);
   output->set_duration(duration);
 
@@ -198,6 +199,7 @@ scoped_refptr<AudioBuffer> MakeAudioBuffer(SampleFormat format,
   template scoped_refptr<AudioBuffer> MakeAudioBuffer<type>( \
       SampleFormat format,                                   \
       ChannelLayout channel_layout,                          \
+      int channel_count,                                     \
       int sample_rate,                                       \
       type start,                                            \
       type increment,                                        \

media/base/test_helpers.h

@@ -114,6 +114,7 @@ class TestVideoConfig {
 template <class T>
 scoped_refptr<AudioBuffer> MakeAudioBuffer(SampleFormat format,
                                            ChannelLayout channel_layout,
+                                           int channel_count,
                                            int sample_rate,
                                            T start,
                                            T increment,

media/filters/audio_renderer_algorithm_unittest.cc

@@ -105,34 +105,40 @@ class AudioRendererAlgorithmTest : public testing::Test {
     while (!algorithm_.IsQueueFull()) {
       switch (sample_format_) {
         case kSampleFormatU8:
-          buffer = MakeAudioBuffer<uint8>(sample_format_,
-                                          channel_layout_,
-                                          samples_per_second_,
-                                          1,
-                                          1,
-                                          kFrameSize,
-                                          kNoTimestamp(),
-                                          kNoTimestamp());
+          buffer = MakeAudioBuffer<uint8>(
+              sample_format_,
+              channel_layout_,
+              ChannelLayoutToChannelCount(channel_layout_),
+              samples_per_second_,
+              1,
+              1,
+              kFrameSize,
+              kNoTimestamp(),
+              kNoTimestamp());
           break;
         case kSampleFormatS16:
-          buffer = MakeAudioBuffer<int16>(sample_format_,
-                                          channel_layout_,
-                                          samples_per_second_,
-                                          1,
-                                          1,
-                                          kFrameSize,
-                                          kNoTimestamp(),
-                                          kNoTimestamp());
+          buffer = MakeAudioBuffer<int16>(
+              sample_format_,
+              channel_layout_,
+              ChannelLayoutToChannelCount(channel_layout_),
+              samples_per_second_,
+              1,
+              1,
+              kFrameSize,
+              kNoTimestamp(),
+              kNoTimestamp());
           break;
         case kSampleFormatS32:
-          buffer = MakeAudioBuffer<int32>(sample_format_,
-                                          channel_layout_,
-                                          samples_per_second_,
-                                          1,
-                                          1,
-                                          kFrameSize,
-                                          kNoTimestamp(),
-                                          kNoTimestamp());
+          buffer = MakeAudioBuffer<int32>(
+              sample_format_,
+              channel_layout_,
+              ChannelLayoutToChannelCount(channel_layout_),
+              samples_per_second_,
+              1,
+              1,
+              kFrameSize,
+              kNoTimestamp(),
+              kNoTimestamp());
           break;
         default:
           NOTREACHED() << "Unrecognized format " << sample_format_;
@@ -232,7 +238,7 @@ class AudioRendererAlgorithmTest : public testing::Test {
 
   void WsolaTest(float playback_rate) {
     const int kSampleRateHz = 48000;
-    const media::ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
+    const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
     const int kBytesPerSample = 2;
     const int kNumFrames = kSampleRateHz / 100;  // 10 milliseconds.
 
@@ -252,6 +258,7 @@ class AudioRendererAlgorithmTest : public testing::Test {
     scoped_refptr<AudioBuffer> input =
         AudioBuffer::CreateBuffer(kSampleFormatPlanarF32,
                                   kChannelLayout,
+                                  channels_,
                                   kSampleRateHz,
                                   kPulseWidthSamples);
 

media/filters/audio_renderer_impl_unittest.cc

@@ -34,6 +34,7 @@ namespace media {
 static AudioCodec kCodec = kCodecVorbis;
 static SampleFormat kSampleFormat = kSampleFormatPlanarF32;
 static ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
+static int kChannelCount = 2;
 static int kChannels = ChannelLayoutToChannelCount(kChannelLayout);
 static int kSamplesPerSecond = 44100;
 
@@ -297,6 +298,7 @@ class AudioRendererImplTest : public ::testing::Test {
     scoped_refptr<AudioBuffer> buffer =
         MakeAudioBuffer<float>(kSampleFormat,
                                kChannelLayout,
+                               kChannelCount,
                                kSamplesPerSecond,
                                kPlayingAudio,
                                0.0f,

media/filters/decrypting_audio_decoder_unittest.cc

@@ -94,7 +94,14 @@ class DecryptingAudioDecoderTest : public testing::Test {
 
   void InitializeAndExpectStatus(const AudioDecoderConfig& config,
                                  PipelineStatus status) {
+    // Initialize data now that the config is known. Since the code uses
+    // invalid values (that CreateEmptyBuffer() doesn't support), tweak them
+    // just for CreateEmptyBuffer().
+    int channels = ChannelLayoutToChannelCount(config.channel_layout());
+    if (channels < 0)
+      channels = 0;
     decoded_frame_ = AudioBuffer::CreateEmptyBuffer(config.channel_layout(),
+                                                    channels,
                                                     kSampleRate,
                                                     kFakeAudioFrameSize,
                                                     kNoTimestamp(),
@@ -353,12 +360,14 @@ TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_MultipleFrames) {
 
   scoped_refptr<AudioBuffer> frame_a = AudioBuffer::CreateEmptyBuffer(
       config_.channel_layout(),
+      ChannelLayoutToChannelCount(config_.channel_layout()),
       kSampleRate,
       kFakeAudioFrameSize,
       kNoTimestamp(),
       kNoTimestamp());
   scoped_refptr<AudioBuffer> frame_b = AudioBuffer::CreateEmptyBuffer(
       config_.channel_layout(),
+      ChannelLayoutToChannelCount(config_.channel_layout()),
       kSampleRate,
       kFakeAudioFrameSize,
       kNoTimestamp(),

media/filters/ffmpeg_audio_decoder.cc

@@ -92,6 +92,7 @@ static int GetAudioBuffer(struct AVCodecContext* s, AVFrame* frame, int flags) {
   scoped_refptr<AudioBuffer> buffer = AudioBuffer::CreateBuffer(
       sample_format,
       ChannelLayoutToChromeChannelLayout(s->channel_layout, s->channels),
+      channels,
       s->sample_rate,
       frames_required);
 

media/filters/opus_audio_decoder.cc

@@ -464,10 +464,12 @@ void OpusAudioDecoder::ResetTimestampState() {
 bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
                               scoped_refptr<AudioBuffer>* output_buffer) {
   // Allocate a buffer for the output samples.
-  *output_buffer = AudioBuffer::CreateBuffer(config_.sample_format(),
-                                             config_.channel_layout(),
-                                             config_.samples_per_second(),
-                                             kMaxOpusOutputPacketSizeSamples);
+  *output_buffer = AudioBuffer::CreateBuffer(
+      config_.sample_format(),
+      config_.channel_layout(),
+      ChannelLayoutToChannelCount(config_.channel_layout()),
+      config_.samples_per_second(),
+      kMaxOpusOutputPacketSizeSamples);
   const int buffer_size =
       output_buffer->get()->channel_count() *
       output_buffer->get()->frame_count() *