Expose the internal MatrixBuilder class as ChannelMixingMatrix.

media/base/channel_mixer_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.
 
 // MSVC++ requires this to be set before any other includes to get M_SQRT1_2.
 #define _USE_MATH_DEFINES
 
 #include <cmath>
 
 #include "base/strings/stringprintf.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
 #include "media/base/channel_mixer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // Number of frames to test with.
 enum { kFrames = 16 };
 
 // Test all possible layout conversions can be constructed and mixed.
 TEST(ChannelMixerTest, ConstructAllPossibleLayouts) {
   for (ChannelLayout input_layout = CHANNEL_LAYOUT_MONO;
        input_layout <= CHANNEL_LAYOUT_MAX;
        input_layout = static_cast<ChannelLayout>(input_layout + 1)) {
     for (ChannelLayout output_layout = CHANNEL_LAYOUT_MONO;
-         output_layout < CHANNEL_LAYOUT_STEREO_DOWNMIX;
+         output_layout <= CHANNEL_LAYOUT_MAX;
          output_layout = static_cast<ChannelLayout>(output_layout + 1)) {
       // DISCRETE can't be tested here based on the current approach.
       // CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC is not mixable.
+      // Stereo down mix should never be the output layout.
       if (input_layout == CHANNEL_LAYOUT_DISCRETE ||
           input_layout == CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC ||
           output_layout == CHANNEL_LAYOUT_DISCRETE ||
-          output_layout == CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC) {
+          output_layout == CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC ||
+          output_layout == CHANNEL_LAYOUT_STEREO_DOWNMIX) {
         continue;
       }
 
       SCOPED_TRACE(base::StringPrintf(
           "Input Layout: %d, Output Layout: %d", input_layout, output_layout));
       ChannelMixer mixer(input_layout, output_layout);
       scoped_ptr<AudioBus> input_bus = AudioBus::Create(
           ChannelLayoutToChannelCount(input_layout), kFrames);
       scoped_ptr<AudioBus> output_bus = AudioBus::Create(
           ChannelLayoutToChannelCount(output_layout), kFrames);
@@ skipping 108 matching lines @@
       for (int frame = 0; frame < output_bus->frames(); ++frame) {
         ASSERT_FLOAT_EQ(output_bus->channel(ch)[frame], expected_value);
       }
     }
   }
 }
 
 static float kStereoToMonoValues[] = { 0.5f, 0.75f };
 static float kMonoToStereoValues[] = { 0.5f };
 // Zero the center channel since it will be mixed at scale 1 vs M_SQRT1_2.
 static float kFiveOneToMonoValues[] = { 0.1f, 0.2f, 0.0f, 0.4f, 0.5f, 0.6f };

[wtc, 2014/10/23 19:24:00]

Nit: when these inputs are mixed and scaled by 1/sqrt(2), the result is 1.27279,
which is outside the [-1.0, 1.0] range. I assume if this happens in reality the
output will be clipped to 1.0?

I only considered this issue because clipping avoidance is the reason we use the
0.5 scale in the stereo to mono case. I wonder if we should do the same when
down mixing from 5.1 to mono.

[DaleCurtis, 2014/10/23 19:27:55]

Clipping avoidance would be nice, but I wouldn't worry about it in this patch
set. I'd include such fixups as a consequence of a larger listening-test based
analysis.

Indeed, in Chrome, values are clipped when interleaving to integer output, which
is used for all our platform drivers.

 static float kFiveDiscreteValues[] = { 0.1f, 0.2f, 0.3f, 0.4f, 0.5f };
 
 // Run through basic sanity tests for some common conversions.
 INSTANTIATE_TEST_CASE_P(ChannelMixerTest, ChannelMixerTest, testing::Values(
     ChannelMixerTestData(CHANNEL_LAYOUT_STEREO, CHANNEL_LAYOUT_MONO,
                          kStereoToMonoValues, arraysize(kStereoToMonoValues),
                          0.5f),
     ChannelMixerTestData(CHANNEL_LAYOUT_MONO, CHANNEL_LAYOUT_STEREO,
                          kMonoToStereoValues, arraysize(kMonoToStereoValues),
                          1.0f),
     ChannelMixerTestData(CHANNEL_LAYOUT_5_1, CHANNEL_LAYOUT_MONO,
                          kFiveOneToMonoValues, arraysize(kFiveOneToMonoValues),
                          static_cast<float>(M_SQRT1_2)),
     ChannelMixerTestData(CHANNEL_LAYOUT_DISCRETE, 2,
                          CHANNEL_LAYOUT_DISCRETE, 2,
                          kStereoToMonoValues, arraysize(kStereoToMonoValues)),
     ChannelMixerTestData(CHANNEL_LAYOUT_DISCRETE, 2,
                          CHANNEL_LAYOUT_DISCRETE, 5,
                          kStereoToMonoValues, arraysize(kStereoToMonoValues)),
     ChannelMixerTestData(CHANNEL_LAYOUT_DISCRETE, 5,
                          CHANNEL_LAYOUT_DISCRETE, 2,
                          kFiveDiscreteValues, arraysize(kFiveDiscreteValues))
 ));
 
 }  // namespace media