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.
5 // MSVC++ requires this to be set before any other includes to get M_SQRT1_2.
6 #define _USE_MATH_DEFINES
8 #include "media/base/channel_mixer.h"
13 #include "base/logging.h"
14 #include "media/audio/audio_parameters.h"
15 #include "media/base/audio_bus.h"
16 #include "media/base/vector_math.h"
20 // Default scale factor for mixing two channels together. We use a different
21 // value for stereo -> mono and mono -> stereo mixes.
22 static const float kEqualPowerScale
= static_cast<float>(M_SQRT1_2
);
24 static void ValidateLayout(ChannelLayout layout
) {
25 CHECK_NE(layout
, CHANNEL_LAYOUT_NONE
);
26 CHECK_NE(layout
, CHANNEL_LAYOUT_MAX
);
27 CHECK_NE(layout
, CHANNEL_LAYOUT_UNSUPPORTED
);
28 CHECK_NE(layout
, CHANNEL_LAYOUT_DISCRETE
);
30 // Verify there's at least one channel. Should always be true here by virtue
31 // of not being one of the invalid layouts, but lets double check to be sure.
32 int channel_count
= ChannelLayoutToChannelCount(layout
);
33 DCHECK_GT(channel_count
, 0);
35 // If we have more than one channel, verify a symmetric layout for sanity.
36 // The unit test will verify all possible layouts, so this can be a DCHECK.
37 // Symmetry allows simplifying the matrix building code by allowing us to
38 // assume that if one channel of a pair exists, the other will too.
39 if (channel_count
> 1) {
40 DCHECK((ChannelOrder(layout
, LEFT
) >= 0 &&
41 ChannelOrder(layout
, RIGHT
) >= 0) ||
42 (ChannelOrder(layout
, SIDE_LEFT
) >= 0 &&
43 ChannelOrder(layout
, SIDE_RIGHT
) >= 0) ||
44 (ChannelOrder(layout
, BACK_LEFT
) >= 0 &&
45 ChannelOrder(layout
, BACK_RIGHT
) >= 0) ||
46 (ChannelOrder(layout
, LEFT_OF_CENTER
) >= 0 &&
47 ChannelOrder(layout
, RIGHT_OF_CENTER
) >= 0))
48 << "Non-symmetric channel layout encountered.";
50 DCHECK_EQ(layout
, CHANNEL_LAYOUT_MONO
);
58 MatrixBuilder(ChannelLayout input_layout
, int input_channels
,
59 ChannelLayout output_layout
, int output_channels
)
60 : input_layout_(input_layout
),
61 input_channels_(input_channels
),
62 output_layout_(output_layout
),
63 output_channels_(output_channels
) {
64 // Special case for 5.0, 5.1 with back channels when upmixed to 7.0, 7.1,
65 // which should map the back LR to side LR.
66 if (input_layout_
== CHANNEL_LAYOUT_5_0_BACK
&&
67 output_layout_
== CHANNEL_LAYOUT_7_0
) {
68 input_layout_
= CHANNEL_LAYOUT_5_0
;
69 } else if (input_layout_
== CHANNEL_LAYOUT_5_1_BACK
&&
70 output_layout_
== CHANNEL_LAYOUT_7_1
) {
71 input_layout_
= CHANNEL_LAYOUT_5_1
;
77 // Create the transformation matrix of input channels to output channels.
78 // Updates the empty matrix with the transformation, and returns true
79 // if the transformation is just a remapping of channels (no mixing).
80 bool CreateTransformationMatrix(std::vector
< std::vector
<float> >* matrix
);
83 // Result transformation of input channels to output channels
84 std::vector
< std::vector
<float> >* matrix_
;
86 // Input and output channel layout provided during construction.
87 ChannelLayout input_layout_
;
89 ChannelLayout output_layout_
;
92 // Helper variable for tracking which inputs are currently unaccounted,
93 // should be empty after construction completes.
94 std::vector
<Channels
> unaccounted_inputs_
;
96 // Helper methods for managing unaccounted input channels.
97 void AccountFor(Channels ch
);
98 bool IsUnaccounted(Channels ch
);
100 // Helper methods for checking if |ch| exists in either |input_layout_| or
101 // |output_layout_| respectively.
102 bool HasInputChannel(Channels ch
);
103 bool HasOutputChannel(Channels ch
);
105 // Helper methods for updating |matrix_| with the proper value for
106 // mixing |input_ch| into |output_ch|. MixWithoutAccounting() does not
107 // remove the channel from |unaccounted_inputs_|.
108 void Mix(Channels input_ch
, Channels output_ch
, float scale
);
109 void MixWithoutAccounting(Channels input_ch
, Channels output_ch
,
112 DISALLOW_COPY_AND_ASSIGN(MatrixBuilder
);
115 ChannelMixer::ChannelMixer(ChannelLayout input_layout
,
116 ChannelLayout output_layout
) {
117 Initialize(input_layout
,
118 ChannelLayoutToChannelCount(input_layout
),
120 ChannelLayoutToChannelCount(output_layout
));
123 ChannelMixer::ChannelMixer(
124 const AudioParameters
& input
, const AudioParameters
& output
) {
125 Initialize(input
.channel_layout(),
127 output
.channel_layout(),
131 void ChannelMixer::Initialize(
132 ChannelLayout input_layout
, int input_channels
,
133 ChannelLayout output_layout
, int output_channels
) {
134 // Stereo down mix should never be the output layout.
135 CHECK_NE(output_layout
, CHANNEL_LAYOUT_STEREO_DOWNMIX
);
137 // Verify that the layouts are supported
138 if (input_layout
!= CHANNEL_LAYOUT_DISCRETE
)
139 ValidateLayout(input_layout
);
140 if (output_layout
!= CHANNEL_LAYOUT_DISCRETE
)
141 ValidateLayout(output_layout
);
143 // Create the transformation matrix
144 MatrixBuilder
matrix_builder(input_layout
, input_channels
,
145 output_layout
, output_channels
);
146 remapping_
= matrix_builder
.CreateTransformationMatrix(&matrix_
);
149 bool MatrixBuilder::CreateTransformationMatrix(
150 std::vector
< std::vector
<float> >* matrix
) {
153 // Size out the initial matrix.
154 matrix_
->reserve(output_channels_
);
155 for (int output_ch
= 0; output_ch
< output_channels_
; ++output_ch
)
156 matrix_
->push_back(std::vector
<float>(input_channels_
, 0));
158 // First check for discrete case.
159 if (input_layout_
== CHANNEL_LAYOUT_DISCRETE
||
160 output_layout_
== CHANNEL_LAYOUT_DISCRETE
) {
161 // If the number of input channels is more than output channels, then
162 // copy as many as we can then drop the remaining input channels.
163 // If the number of input channels is less than output channels, then
164 // copy them all, then zero out the remaining output channels.
165 int passthrough_channels
= std::min(input_channels_
, output_channels_
);
166 for (int i
= 0; i
< passthrough_channels
; ++i
)
167 (*matrix_
)[i
][i
] = 1;
172 // Route matching channels and figure out which ones aren't accounted for.
173 for (Channels ch
= LEFT
; ch
< CHANNELS_MAX
;
174 ch
= static_cast<Channels
>(ch
+ 1)) {
175 int input_ch_index
= ChannelOrder(input_layout_
, ch
);
176 if (input_ch_index
< 0)
179 int output_ch_index
= ChannelOrder(output_layout_
, ch
);
180 if (output_ch_index
< 0) {
181 unaccounted_inputs_
.push_back(ch
);
185 DCHECK_LT(static_cast<size_t>(output_ch_index
), matrix_
->size());
186 DCHECK_LT(static_cast<size_t>(input_ch_index
),
187 (*matrix_
)[output_ch_index
].size());
188 (*matrix_
)[output_ch_index
][input_ch_index
] = 1;
191 // If all input channels are accounted for, there's nothing left to do.
192 if (unaccounted_inputs_
.empty()) {
193 // Since all output channels map directly to inputs we can optimize.
197 // Mix front LR into center.
198 if (IsUnaccounted(LEFT
)) {
199 // When down mixing to mono from stereo, we need to be careful of full scale
200 // stereo mixes. Scaling by 1 / sqrt(2) here will likely lead to clipping
201 // so we use 1 / 2 instead.
203 (output_layout_
== CHANNEL_LAYOUT_MONO
&& input_channels_
== 2) ?
204 0.5 : kEqualPowerScale
;
205 Mix(LEFT
, CENTER
, scale
);
206 Mix(RIGHT
, CENTER
, scale
);
209 // Mix center into front LR.
210 if (IsUnaccounted(CENTER
)) {
211 // When up mixing from mono, just do a copy to front LR.
213 (input_layout_
== CHANNEL_LAYOUT_MONO
) ? 1 : kEqualPowerScale
;
214 MixWithoutAccounting(CENTER
, LEFT
, scale
);
215 Mix(CENTER
, RIGHT
, scale
);
218 // Mix back LR into: side LR || back center || front LR || front center.
219 if (IsUnaccounted(BACK_LEFT
)) {
220 if (HasOutputChannel(SIDE_LEFT
)) {
221 // If we have side LR, mix back LR into side LR, but instead if the input
222 // doesn't have side LR (but output does) copy back LR to side LR.
223 float scale
= HasInputChannel(SIDE_LEFT
) ? kEqualPowerScale
: 1;
224 Mix(BACK_LEFT
, SIDE_LEFT
, scale
);
225 Mix(BACK_RIGHT
, SIDE_RIGHT
, scale
);
226 } else if (HasOutputChannel(BACK_CENTER
)) {
227 // Mix back LR into back center.
228 Mix(BACK_LEFT
, BACK_CENTER
, kEqualPowerScale
);
229 Mix(BACK_RIGHT
, BACK_CENTER
, kEqualPowerScale
);
230 } else if (output_layout_
> CHANNEL_LAYOUT_MONO
) {
231 // Mix back LR into front LR.
232 Mix(BACK_LEFT
, LEFT
, kEqualPowerScale
);
233 Mix(BACK_RIGHT
, RIGHT
, kEqualPowerScale
);
235 // Mix back LR into front center.
236 Mix(BACK_LEFT
, CENTER
, kEqualPowerScale
);
237 Mix(BACK_RIGHT
, CENTER
, kEqualPowerScale
);
241 // Mix side LR into: back LR || back center || front LR || front center.
242 if (IsUnaccounted(SIDE_LEFT
)) {
243 if (HasOutputChannel(BACK_LEFT
)) {
244 // If we have back LR, mix side LR into back LR, but instead if the input
245 // doesn't have back LR (but output does) copy side LR to back LR.
246 float scale
= HasInputChannel(BACK_LEFT
) ? kEqualPowerScale
: 1;
247 Mix(SIDE_LEFT
, BACK_LEFT
, scale
);
248 Mix(SIDE_RIGHT
, BACK_RIGHT
, scale
);
249 } else if (HasOutputChannel(BACK_CENTER
)) {
250 // Mix side LR into back center.
251 Mix(SIDE_LEFT
, BACK_CENTER
, kEqualPowerScale
);
252 Mix(SIDE_RIGHT
, BACK_CENTER
, kEqualPowerScale
);
253 } else if (output_layout_
> CHANNEL_LAYOUT_MONO
) {
254 // Mix side LR into front LR.
255 Mix(SIDE_LEFT
, LEFT
, kEqualPowerScale
);
256 Mix(SIDE_RIGHT
, RIGHT
, kEqualPowerScale
);
258 // Mix side LR into front center.
259 Mix(SIDE_LEFT
, CENTER
, kEqualPowerScale
);
260 Mix(SIDE_RIGHT
, CENTER
, kEqualPowerScale
);
264 // Mix back center into: back LR || side LR || front LR || front center.
265 if (IsUnaccounted(BACK_CENTER
)) {
266 if (HasOutputChannel(BACK_LEFT
)) {
267 // Mix back center into back LR.
268 MixWithoutAccounting(BACK_CENTER
, BACK_LEFT
, kEqualPowerScale
);
269 Mix(BACK_CENTER
, BACK_RIGHT
, kEqualPowerScale
);
270 } else if (HasOutputChannel(SIDE_LEFT
)) {
271 // Mix back center into side LR.
272 MixWithoutAccounting(BACK_CENTER
, SIDE_LEFT
, kEqualPowerScale
);
273 Mix(BACK_CENTER
, SIDE_RIGHT
, kEqualPowerScale
);
274 } else if (output_layout_
> CHANNEL_LAYOUT_MONO
) {
275 // Mix back center into front LR.
276 // TODO(dalecurtis): Not sure about these values?
277 MixWithoutAccounting(BACK_CENTER
, LEFT
, kEqualPowerScale
);
278 Mix(BACK_CENTER
, RIGHT
, kEqualPowerScale
);
280 // Mix back center into front center.
281 // TODO(dalecurtis): Not sure about these values?
282 Mix(BACK_CENTER
, CENTER
, kEqualPowerScale
);
286 // Mix LR of center into: front center || front LR.
287 if (IsUnaccounted(LEFT_OF_CENTER
)) {
288 if (HasOutputChannel(LEFT
)) {
289 // Mix LR of center into front LR.
290 Mix(LEFT_OF_CENTER
, LEFT
, kEqualPowerScale
);
291 Mix(RIGHT_OF_CENTER
, RIGHT
, kEqualPowerScale
);
293 // Mix LR of center into front center.
294 Mix(LEFT_OF_CENTER
, CENTER
, kEqualPowerScale
);
295 Mix(RIGHT_OF_CENTER
, CENTER
, kEqualPowerScale
);
299 // Mix LFE into: front LR || front center.
300 if (IsUnaccounted(LFE
)) {
301 if (!HasOutputChannel(CENTER
)) {
302 // Mix LFE into front LR.
303 MixWithoutAccounting(LFE
, LEFT
, kEqualPowerScale
);
304 Mix(LFE
, RIGHT
, kEqualPowerScale
);
306 // Mix LFE into front center.
307 Mix(LFE
, CENTER
, kEqualPowerScale
);
311 // All channels should now be accounted for.
312 DCHECK(unaccounted_inputs_
.empty());
314 // See if the output |matrix_| is simply a remapping matrix. If each input
315 // channel maps to a single output channel we can simply remap. Doing this
316 // programmatically is less fragile than logic checks on channel mappings.
317 for (int output_ch
= 0; output_ch
< output_channels_
; ++output_ch
) {
318 int input_mappings
= 0;
319 for (int input_ch
= 0; input_ch
< input_channels_
; ++input_ch
) {
320 // We can only remap if each row contains a single scale of 1. I.e., each
321 // output channel is mapped from a single unscaled input channel.
322 if ((*matrix_
)[output_ch
][input_ch
] != 1 || ++input_mappings
> 1)
327 // If we've gotten here, |matrix_| is simply a remapping.
331 ChannelMixer::~ChannelMixer() {}
333 void ChannelMixer::Transform(const AudioBus
* input
, AudioBus
* output
) {
334 CHECK_EQ(matrix_
.size(), static_cast<size_t>(output
->channels()));
335 CHECK_EQ(matrix_
[0].size(), static_cast<size_t>(input
->channels()));
336 CHECK_EQ(input
->frames(), output
->frames());
338 // Zero initialize |output| so we're accumulating from zero.
341 // If we're just remapping we can simply copy the correct input to output.
343 for (int output_ch
= 0; output_ch
< output
->channels(); ++output_ch
) {
344 for (int input_ch
= 0; input_ch
< input
->channels(); ++input_ch
) {
345 float scale
= matrix_
[output_ch
][input_ch
];
347 DCHECK_EQ(scale
, 1.0f
);
348 memcpy(output
->channel(output_ch
), input
->channel(input_ch
),
349 sizeof(*output
->channel(output_ch
)) * output
->frames());
357 for (int output_ch
= 0; output_ch
< output
->channels(); ++output_ch
) {
358 for (int input_ch
= 0; input_ch
< input
->channels(); ++input_ch
) {
359 float scale
= matrix_
[output_ch
][input_ch
];
360 // Scale should always be positive. Don't bother scaling by zero.
363 vector_math::FMAC(input
->channel(input_ch
), scale
, output
->frames(),
364 output
->channel(output_ch
));
370 void MatrixBuilder::AccountFor(Channels ch
) {
371 unaccounted_inputs_
.erase(std::find(
372 unaccounted_inputs_
.begin(), unaccounted_inputs_
.end(), ch
));
375 bool MatrixBuilder::IsUnaccounted(Channels ch
) {
376 return std::find(unaccounted_inputs_
.begin(), unaccounted_inputs_
.end(),
377 ch
) != unaccounted_inputs_
.end();
380 bool MatrixBuilder::HasInputChannel(Channels ch
) {
381 return ChannelOrder(input_layout_
, ch
) >= 0;
384 bool MatrixBuilder::HasOutputChannel(Channels ch
) {
385 return ChannelOrder(output_layout_
, ch
) >= 0;
388 void MatrixBuilder::Mix(Channels input_ch
, Channels output_ch
, float scale
) {
389 MixWithoutAccounting(input_ch
, output_ch
, scale
);
390 AccountFor(input_ch
);
393 void MatrixBuilder::MixWithoutAccounting(Channels input_ch
, Channels output_ch
,
395 int input_ch_index
= ChannelOrder(input_layout_
, input_ch
);
396 int output_ch_index
= ChannelOrder(output_layout_
, output_ch
);
398 DCHECK(IsUnaccounted(input_ch
));
399 DCHECK_GE(input_ch_index
, 0);
400 DCHECK_GE(output_ch_index
, 0);
402 DCHECK_EQ((*matrix_
)[output_ch_index
][input_ch_index
], 0);
403 (*matrix_
)[output_ch_index
][input_ch_index
] = scale
;