OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 // MSVC++ requires this to be set before any other includes to get M_SQRT1_2. |
| 6 #define _USE_MATH_DEFINES |
| 7 |
| 8 #include "media/base/channel_mixing_matrix.h" |
| 9 |
| 10 #include <cmath> |
| 11 |
| 12 #include "base/strings/stringprintf.h" |
| 13 #include "testing/gtest/include/gtest/gtest.h" |
| 14 |
| 15 namespace media { |
| 16 |
| 17 // Test all possible layout conversions can be constructed and mixed. |
| 18 TEST(ChannelMixingMatrixTest, ConstructAllPossibleLayouts) { |
| 19 for (ChannelLayout input_layout = CHANNEL_LAYOUT_MONO; |
| 20 input_layout <= CHANNEL_LAYOUT_MAX; |
| 21 input_layout = static_cast<ChannelLayout>(input_layout + 1)) { |
| 22 for (ChannelLayout output_layout = CHANNEL_LAYOUT_MONO; |
| 23 output_layout <= CHANNEL_LAYOUT_MAX; |
| 24 output_layout = static_cast<ChannelLayout>(output_layout + 1)) { |
| 25 // DISCRETE can't be tested here based on the current approach. |
| 26 // CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC is not mixable. |
| 27 // Stereo down mix should never be the output layout. |
| 28 if (input_layout == CHANNEL_LAYOUT_DISCRETE || |
| 29 input_layout == CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC || |
| 30 output_layout == CHANNEL_LAYOUT_DISCRETE || |
| 31 output_layout == CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC || |
| 32 output_layout == CHANNEL_LAYOUT_STEREO_DOWNMIX) { |
| 33 continue; |
| 34 } |
| 35 |
| 36 SCOPED_TRACE(base::StringPrintf( |
| 37 "Input Layout: %d, Output Layout: %d", input_layout, output_layout)); |
| 38 ChannelMixingMatrix matrix_builder( |
| 39 input_layout, |
| 40 ChannelLayoutToChannelCount(input_layout), |
| 41 output_layout, |
| 42 ChannelLayoutToChannelCount(output_layout)); |
| 43 std::vector<std::vector<float>> matrix; |
| 44 matrix_builder.CreateTransformationMatrix(&matrix); |
| 45 } |
| 46 } |
| 47 } |
| 48 |
| 49 // Verify channels are mixed and scaled correctly. |
| 50 TEST(ChannelMixingMatrixTest, StereoToMono) { |
| 51 ChannelLayout input_layout = CHANNEL_LAYOUT_STEREO; |
| 52 ChannelLayout output_layout = CHANNEL_LAYOUT_MONO; |
| 53 ChannelMixingMatrix matrix_builder( |
| 54 input_layout, |
| 55 ChannelLayoutToChannelCount(input_layout), |
| 56 output_layout, |
| 57 ChannelLayoutToChannelCount(output_layout)); |
| 58 std::vector<std::vector<float>> matrix; |
| 59 bool remapping = matrix_builder.CreateTransformationMatrix(&matrix); |
| 60 |
| 61 // Input: stereo |
| 62 // LEFT RIGHT |
| 63 // Output: mono CENTER 0.5 0.5 |
| 64 // |
| 65 EXPECT_FALSE(remapping); |
| 66 EXPECT_EQ(1u, matrix.size()); |
| 67 EXPECT_EQ(2u, matrix[0].size()); |
| 68 EXPECT_EQ(0.5f, matrix[0][0]); |
| 69 EXPECT_EQ(0.5f, matrix[0][1]); |
| 70 } |
| 71 |
| 72 TEST(ChannelMixingMatrixTest, MonoToStereo) { |
| 73 ChannelLayout input_layout = CHANNEL_LAYOUT_MONO; |
| 74 ChannelLayout output_layout = CHANNEL_LAYOUT_STEREO; |
| 75 ChannelMixingMatrix matrix_builder( |
| 76 input_layout, |
| 77 ChannelLayoutToChannelCount(input_layout), |
| 78 output_layout, |
| 79 ChannelLayoutToChannelCount(output_layout)); |
| 80 std::vector<std::vector<float>> matrix; |
| 81 bool remapping = matrix_builder.CreateTransformationMatrix(&matrix); |
| 82 |
| 83 // Input: mono |
| 84 // CENTER |
| 85 // Output: stereo LEFT 1 |
| 86 // RIGHT 1 |
| 87 // |
| 88 EXPECT_TRUE(remapping); |
| 89 EXPECT_EQ(2u, matrix.size()); |
| 90 EXPECT_EQ(1u, matrix[0].size()); |
| 91 EXPECT_EQ(1.0f, matrix[0][0]); |
| 92 EXPECT_EQ(1u, matrix[1].size()); |
| 93 EXPECT_EQ(1.0f, matrix[1][0]); |
| 94 } |
| 95 |
| 96 TEST(ChannelMixingMatrixTest, FiveOneToMono) { |
| 97 ChannelLayout input_layout = CHANNEL_LAYOUT_5_1; |
| 98 ChannelLayout output_layout = CHANNEL_LAYOUT_MONO; |
| 99 ChannelMixingMatrix matrix_builder( |
| 100 input_layout, |
| 101 ChannelLayoutToChannelCount(input_layout), |
| 102 output_layout, |
| 103 ChannelLayoutToChannelCount(output_layout)); |
| 104 std::vector<std::vector<float>> matrix; |
| 105 bool remapping = matrix_builder.CreateTransformationMatrix(&matrix); |
| 106 |
| 107 // Note: 1/sqrt(2) is shown as 0.707. |
| 108 // |
| 109 // Input: 5.1 |
| 110 // LEFT RIGHT CENTER LFE SIDE_LEFT SIDE_RIGHT |
| 111 // Output: mono CENTER 0.707 0.707 1 0.707 0.707 0.707 |
| 112 // |
| 113 EXPECT_FALSE(remapping); |
| 114 EXPECT_EQ(1u, matrix.size()); |
| 115 EXPECT_EQ(6u, matrix[0].size()); |
| 116 EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][0]); |
| 117 EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][1]); |
| 118 // The center channel will be mixed at scale 1. |
| 119 EXPECT_EQ(1.0f, matrix[0][2]); |
| 120 EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][3]); |
| 121 EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][4]); |
| 122 EXPECT_FLOAT_EQ(static_cast<float>(M_SQRT1_2), matrix[0][5]); |
| 123 } |
| 124 |
| 125 TEST(ChannelMixingMatrixTest, DiscreteToDiscrete) { |
| 126 const struct { |
| 127 int input_channels; |
| 128 int output_channels; |
| 129 } test_case[] = { |
| 130 {2, 2}, {2, 5}, {5, 2}, |
| 131 }; |
| 132 |
| 133 for (size_t n = 0; n < arraysize(test_case); n++) { |
| 134 int input_channels = test_case[n].input_channels; |
| 135 int output_channels = test_case[n].output_channels; |
| 136 ChannelMixingMatrix matrix_builder(CHANNEL_LAYOUT_DISCRETE, |
| 137 input_channels, |
| 138 CHANNEL_LAYOUT_DISCRETE, |
| 139 output_channels); |
| 140 std::vector<std::vector<float>> matrix; |
| 141 bool remapping = matrix_builder.CreateTransformationMatrix(&matrix); |
| 142 EXPECT_TRUE(remapping); |
| 143 EXPECT_EQ(static_cast<size_t>(output_channels), matrix.size()); |
| 144 for (int i = 0; i < output_channels; i++) { |
| 145 EXPECT_EQ(static_cast<size_t>(input_channels), matrix[i].size()); |
| 146 for (int j = 0; j < input_channels; j++) { |
| 147 if (i == j) { |
| 148 EXPECT_EQ(1.0f, matrix[i][j]); |
| 149 } else { |
| 150 EXPECT_EQ(0.0f, matrix[i][j]); |
| 151 } |
| 152 } |
| 153 } |
| 154 } |
| 155 } |
| 156 |
| 157 } // namespace media |
OLD | NEW |