Support Opus Ambisonics playback

content/renderer/media/audio_renderer_mixer_manager_unittest.cc

 // Copyright (c) 2012 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 "content/renderer/media/audio_renderer_mixer_manager.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "build/build_config.h"
@@ skipping 14 matching lines @@
 namespace content {
 
 namespace {
 const int kBitsPerChannel = 16;
 const int kSampleRate = 48000;
 const int kBufferSize = 8192;
 const int kHardwareSampleRate = 44100;
 const int kHardwareBufferSize = 128;
 const media::ChannelLayout kChannelLayout = media::CHANNEL_LAYOUT_STEREO;
 const media::ChannelLayout kAnotherChannelLayout = media::CHANNEL_LAYOUT_2_1;
+const media::ChannelLayout kDiscreteChannelLayout =
+    media::CHANNEL_LAYOUT_DISCRETE;
 const char* const kDefaultDeviceId =
     media::AudioDeviceDescription::kDefaultDeviceId;
 const char kAnotherDeviceId[] = "another-device-id";
 const char kMatchedDeviceId[] = "matched-device-id";
 const char kNonexistentDeviceId[] = "nonexistent-device-id";
 
 const int kRenderFrameId = 124;
 const int kAnotherRenderFrameId = 678;
 }  // namespace;
 
@@ skipping 124 matching lines @@
   const url::Origin kSecurityOrigin;
   const url::Origin kSecurityOrigin2;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioRendererMixerManagerTest);
 };
 
 // Verify GetMixer() and ReturnMixer() both work as expected; particularly with
 // respect to the explicit ref counting done.
 TEST_F(AudioRendererMixerManagerTest, GetReturnMixer) {
-  // Since we're testing two different sets of parameters, we expect
-  // AudioRendererMixerManager to call Start and Stop on our mock twice.
-  EXPECT_CALL(*mock_sink_.get(), Start()).Times(2);
-  EXPECT_CALL(*mock_sink_.get(), Stop()).Times(2);
+  // Since we're testing three different sets of parameters, we expect
+  // AudioRendererMixerManager to call Start and Stop on our mock three times.
+  EXPECT_CALL(*mock_sink_.get(), Start()).Times(3);
+  EXPECT_CALL(*mock_sink_.get(), Stop()).Times(3);
 
-  // We expect 2 mixers to be created; each of them should release the sink.
-  EXPECT_CALL(*this, ReleaseSinkPtr(mock_sink_.get())).Times(2);
+  // We expect 3 mixers to be created; each of them should release the sink.
+  EXPECT_CALL(*this, ReleaseSinkPtr(mock_sink_.get())).Times(3);
 
   // There should be no mixers outstanding to start with.
   EXPECT_EQ(0, mixer_count());
 
   media::AudioParameters params1(media::AudioParameters::AUDIO_PCM_LINEAR,
                                  kChannelLayout, kSampleRate, kBitsPerChannel,
                                  kBufferSize);
 
   media::AudioRendererMixer* mixer1 =
       GetMixer(kRenderFrameId, params1, AudioLatency::LATENCY_PLAYBACK,
@@ skipping 21 matching lines @@
   EXPECT_EQ(2, mixer_count());
 
   // Different parameters should result in a different mixer1.
   EXPECT_NE(mixer1, mixer2);
 
   // Return both outstanding mixers.
   ReturnMixer(mixer1);
   EXPECT_EQ(1, mixer_count());
   ReturnMixer(mixer2);
   EXPECT_EQ(0, mixer_count());
+
+  // An input with CHANNEL_LAYOUT_DISCRETE should yield a mixer that defaults
+  // to the hardware channel layout.
+  media::AudioParameters params3(AudioParameters::AUDIO_PCM_LINEAR,
+                                 kDiscreteChannelLayout, kSampleRate * 2,
+                                 kBitsPerChannel, kBufferSize * 2);
+  media::AudioRendererMixer* mixer3 =
+      GetMixer(kRenderFrameId, params3, AudioLatency::LATENCY_PLAYBACK,
+               kDefaultDeviceId, kSecurityOrigin, nullptr);
+  ASSERT_TRUE(mixer3);
+  EXPECT_EQ(1, mixer_count());
+  EXPECT_EQ(mock_sink_->GetOutputDeviceInfo().output_params().channel_layout(),
+            mixer3->GetOutputParamsForTesting().channel_layout());
+
+  // Return the final mixer.
+  ReturnMixer(mixer3);
+  EXPECT_EQ(0, mixer_count());
 }
 
 // Verify GetMixer() correctly deduplicates mixer with irrelevant AudioParameter
 // differences.
 TEST_F(AudioRendererMixerManagerTest, MixerReuse) {
   EXPECT_CALL(*mock_sink_.get(), Start()).Times(2);
   EXPECT_CALL(*mock_sink_.get(), Stop()).Times(2);
   EXPECT_EQ(mixer_count(), 0);
 
   // We expect 2 mixers to be created; each of them should release the sink.
@@ skipping 585 matching lines @@
   EXPECT_EQ(2048, mixer->GetOutputParamsForTesting().frames_per_buffer());
 #else
   // Expect hardware buffer size.
   EXPECT_EQ(128, mixer->GetOutputParamsForTesting().frames_per_buffer());
 #endif
 
   ReturnMixer(mixer);
 }
 
 }  // namespace content