Expose the internal MatrixBuilder class as ChannelMixingMatrix.

R=dalecurtis@chromium.org
BUG=none

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

Cr-Commit-Position: refs/heads/master@{#300962}

media/base/BUILD.gn

@@ -64,6 +64,8 @@ source_set("base") {
     "cdm_promise.h",
     "channel_mixer.cc",
     "channel_mixer.h",
+    "channel_mixing_matrix.cc",
+    "channel_mixing_matrix.h",
     "clock.h",
     "data_buffer.cc",
     "data_buffer.h",
@@ -291,6 +293,7 @@ source_set("unittests") {
     "callback_holder.h",
     "callback_holder_unittest.cc",
     "channel_mixer_unittest.cc",
+    "channel_mixing_matrix_unittest.cc",
     "data_buffer_unittest.cc",
     "decoder_buffer_queue_unittest.cc",
     "decoder_buffer_unittest.cc",

media/base/channel_mixer_unittest.cc

@@ -24,14 +24,16 @@ TEST(ChannelMixerTest, ConstructAllPossibleLayouts) {
        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;
       }
 
@@ -141,7 +143,7 @@ TEST_P(ChannelMixerTest, Mixing) {
   if (input_layout != CHANNEL_LAYOUT_DISCRETE) {
     for (int ch = 0; ch < output_bus->channels(); ++ch) {
       for (int frame = 0; frame < output_bus->frames(); ++frame) {
-        ASSERT_FLOAT_EQ(output_bus->channel(ch)[frame], expected_value);
+        ASSERT_FLOAT_EQ(expected_value, output_bus->channel(ch)[frame]);
       }
     }
   } else {
@@ -151,7 +153,7 @@ TEST_P(ChannelMixerTest, Mixing) {
     for (int ch = 0; ch < output_bus->channels(); ++ch) {
       expected_value = (ch < input_channels) ? channel_values[ch] : 0;
       for (int frame = 0; frame < output_bus->frames(); ++frame) {
-        ASSERT_FLOAT_EQ(output_bus->channel(ch)[frame], expected_value);
+        ASSERT_FLOAT_EQ(expected_value, output_bus->channel(ch)[frame]);
       }
     }
   }

media/base/channel_mixing_matrix.h

+// 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.
+
+#ifndef MEDIA_BASE_CHANNEL_MIXING_MATRIX_H_
+#define MEDIA_BASE_CHANNEL_MIXING_MATRIX_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "media/base/channel_layout.h"
+#include "media/base/media_export.h"
+
+namespace media {
+
+class MEDIA_EXPORT ChannelMixingMatrix {
+ public:
+  ChannelMixingMatrix(ChannelLayout input_layout,
+                      int input_channels,
+                      ChannelLayout output_layout,
+                      int output_channels);
+
+  ~ChannelMixingMatrix();
+
+  // Create the transformation matrix of input channels to output channels.
+  // Updates the empty matrix with the transformation, and returns true
+  // if the transformation is just a remapping of channels (no mixing).
+  bool CreateTransformationMatrix(std::vector<std::vector<float>>* matrix);
+
+ private:
+  // Result transformation of input channels to output channels
+  std::vector<std::vector<float>>* matrix_;
+
+  // Input and output channel layout provided during construction.
+  ChannelLayout input_layout_;
+  int input_channels_;
+  ChannelLayout output_layout_;
+  int output_channels_;
+
+  // Helper variable for tracking which inputs are currently unaccounted,
+  // should be empty after construction completes.
+  std::vector<Channels> unaccounted_inputs_;
+
+  // Helper methods for managing unaccounted input channels.
+  void AccountFor(Channels ch);
+  bool IsUnaccounted(Channels ch) const;
+
+  // Helper methods for checking if |ch| exists in either |input_layout_| or
+  // |output_layout_| respectively.
+  bool HasInputChannel(Channels ch) const;
+  bool HasOutputChannel(Channels ch) const;
+
+  // Helper methods for updating |matrix_| with the proper value for
+  // mixing |input_ch| into |output_ch|.  MixWithoutAccounting() does not
+  // remove the channel from |unaccounted_inputs_|.
+  void Mix(Channels input_ch, Channels output_ch, float scale);
+  void MixWithoutAccounting(Channels input_ch, Channels output_ch, float scale);
+
+  DISALLOW_COPY_AND_ASSIGN(ChannelMixingMatrix);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_CHANNEL_MIXING_MATRIX_H_

media/base/channel_mixing_matrix_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 "media/base/channel_mixing_matrix.h"
+
+#include <cmath>
+
+#include "base/strings/stringprintf.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+// Test all possible layout conversions can be constructed and mixed.
+TEST(ChannelMixingMatrixTest, 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_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_DOWNMIX) {
+        continue;
+      }
+
+      SCOPED_TRACE(base::StringPrintf(
+          "Input Layout: %d, Output Layout: %d", input_layout, output_layout));
+      ChannelMixingMatrix matrix_builder(
+          input_layout,
+          ChannelLayoutToChannelCount(input_layout),
+          output_layout,
+          ChannelLayoutToChannelCount(output_layout));
+      std::vector<std::vector<float>> matrix;
+      matrix_builder.CreateTransformationMatrix(&matrix);
+    }
+  }
+}
+
+// Verify channels are mixed and scaled correctly.
+TEST(ChannelMixingMatrixTest, StereoToMono) {
+  ChannelLayout input_layout = CHANNEL_LAYOUT_STEREO;
+  ChannelLayout output_layout = CHANNEL_LAYOUT_MONO;
+  ChannelMixingMatrix matrix_builder(
+      input_layout,
+      ChannelLayoutToChannelCount(input_layout),
+      output_layout,
+      ChannelLayoutToChannelCount(output_layout));
+  std::vector<std::vector<float>> matrix;
+  bool remapping = matrix_builder.CreateTransformationMatrix(&matrix);
+
+  //                      Input: stereo
+  //                      LEFT  RIGHT
+  // Output: mono CENTER  0.5   0.5
+  //
+  EXPECT_FALSE(remapping);
+  EXPECT_EQ(1u, matrix.size());
+  EXPECT_EQ(2u, matrix[0].size());
+  EXPECT_EQ(0.5f, matrix[0][0]);
+  EXPECT_EQ(0.5f, matrix[0][1]);
+}
+
+TEST(ChannelMixingMatrixTest, MonoToStereo) {
+  ChannelLayout input_layout = CHANNEL_LAYOUT_MONO;
+  ChannelLayout output_layout = CHANNEL_LAYOUT_STEREO;
+  ChannelMixingMatrix matrix_builder(
+      input_layout,
+      ChannelLayoutToChannelCount(input_layout),
+      output_layout,
+      ChannelLayoutToChannelCount(output_layout));
+  std::vector<std::vector<float>> matrix;
+  bool remapping = matrix_builder.CreateTransformationMatrix(&matrix);
+
+  //                       Input: mono
+  //                       CENTER
+  // Output: stereo LEFT   1
+  //                RIGHT  1
+  //
+  EXPECT_TRUE(remapping);
+  EXPECT_EQ(2u, matrix.size());
+  EXPECT_EQ(1u, matrix[0].size());
+  EXPECT_EQ(1.0f, matrix[0][0]);
+  EXPECT_EQ(1u, matrix[1].size());
+  EXPECT_EQ(1.0f, matrix[1][0]);
+}
+
+TEST(ChannelMixingMatrixTest, FiveOneToMono) {
+  ChannelLayout input_layout = CHANNEL_LAYOUT_5_1;
+  ChannelLayout output_layout = CHANNEL_LAYOUT_MONO;
+  ChannelMixingMatrix matrix_builder(
+      input_layout,
+      ChannelLayoutToChannelCount(input_layout),
+      output_layout,
+      ChannelLayoutToChannelCount(output_layout));
+  std::vector<std::vector<float>> matrix;
+  bool remapping = matrix_builder.CreateTransformationMatrix(&matrix);
+
+  // Note: 1/sqrt(2) is shown as 0.707.
+  //
+  //                      Input: 5.1
+  //                      LEFT   RIGHT  CENTER  LFE    SIDE_LEFT  SIDE_RIGHT
+  // Output: mono CENTER  0.707  0.707  1       0.707  0.707      0.707
+  //
+  EXPECT_FALSE(remapping);
+  EXPECT_EQ(1u, matrix.size());
+  EXPECT_EQ(6u, matrix[0].size());
+  EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][0]);
+  EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][1]);
+  // The center channel will be mixed at scale 1.
+  EXPECT_EQ(1.0f, matrix[0][2]);
+  EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][3]);
+  EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][4]);
+  EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][5]);
+}
+
+TEST(ChannelMixingMatrixTest, DiscreteToDiscrete) {
+  const struct {
+    int input_channels;
+    int output_channels;
+  } test_case[] = {
+    {2, 2}, {2, 5}, {5, 2},
+  };
+
+  for (size_t n = 0; n < arraysize(test_case); n++) {
+    int input_channels = test_case[n].input_channels;
+    int output_channels = test_case[n].output_channels;
+    ChannelMixingMatrix matrix_builder(CHANNEL_LAYOUT_DISCRETE,
+                                       input_channels,
+                                       CHANNEL_LAYOUT_DISCRETE,
+                                       output_channels);
+    std::vector<std::vector<float>> matrix;
+    bool remapping = matrix_builder.CreateTransformationMatrix(&matrix);
+    EXPECT_TRUE(remapping);
+    EXPECT_EQ(static_cast<size_t>(output_channels), matrix.size());
+    for (int i = 0; i < output_channels; i++) {
+      EXPECT_EQ(static_cast<size_t>(input_channels), matrix[i].size());
+      for (int j = 0; j < input_channels; j++) {
+        if (i == j) {
+          EXPECT_EQ(1.0f, matrix[i][j]);
+        } else {
+          EXPECT_EQ(0.0f, matrix[i][j]);
+        }
+      }
+    }
+  }
+}
+
+}  // namespace media

media/media.gyp

@@ -263,6 +263,8 @@
         'base/cdm_promise.h',
         'base/channel_mixer.cc',
         'base/channel_mixer.h',
+        'base/channel_mixing_matrix.cc',
+        'base/channel_mixing_matrix.h',
         'base/container_names.cc',
         'base/container_names.h',
         'base/data_buffer.cc',
@@ -1215,6 +1217,7 @@
         'base/callback_holder.h',
         'base/callback_holder_unittest.cc',
         'base/channel_mixer_unittest.cc',
+        'base/channel_mixing_matrix_unittest.cc',
         'base/container_names_unittest.cc',
         'base/data_buffer_unittest.cc',
         'base/decoder_buffer_queue_unittest.cc',