Pass more detailed audio hardware configuration information to the renderer

media/base/channel_mixer.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_mixer.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
+#include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
 #include "media/base/vector_math.h"
 
 namespace media {
 
 // Default scale factor for mixing two channels together.  We use a different
 // value for stereo -> mono and mono -> stereo mixes.
 static const float kEqualPowerScale = static_cast<float>(M_SQRT1_2);
 
-static int ValidateLayout(ChannelLayout layout) {
+static void ValidateLayout(ChannelLayout layout) {
   CHECK_NE(layout, CHANNEL_LAYOUT_NONE);
   CHECK_NE(layout, CHANNEL_LAYOUT_MAX);
-
-  // TODO(dalecurtis, crogers): We will eventually handle unsupported layouts by
-  // simply copying the input channels to the output channels, similar to if the
-  // user requests identical input and output layouts today.
   CHECK_NE(layout, CHANNEL_LAYOUT_UNSUPPORTED);
+  CHECK_NE(layout, CHANNEL_LAYOUT_DISCRETE);
 
   // Verify there's at least one channel.  Should always be true here by virtue
   // of not being one of the invalid layouts, but lets double check to be sure.
   int channel_count = ChannelLayoutToChannelCount(layout);
   DCHECK_GT(channel_count, 0);
 
   // If we have more than one channel, verify a symmetric layout for sanity.
   // The unit test will verify all possible layouts, so this can be a DCHECK.
   // Symmetry allows simplifying the matrix building code by allowing us to
   // assume that if one channel of a pair exists, the other will too.
   if (channel_count > 1) {
     DCHECK((ChannelOrder(layout, LEFT) >= 0 &&
             ChannelOrder(layout, RIGHT) >= 0) ||
            (ChannelOrder(layout, SIDE_LEFT) >= 0 &&
             ChannelOrder(layout, SIDE_RIGHT) >= 0) ||
            (ChannelOrder(layout, BACK_LEFT) >= 0 &&
             ChannelOrder(layout, BACK_RIGHT) >= 0) ||
            (ChannelOrder(layout, LEFT_OF_CENTER) >= 0 &&
             ChannelOrder(layout, RIGHT_OF_CENTER) >= 0))
         << "Non-symmetric channel layout encountered.";
   } else {
     DCHECK_EQ(layout, CHANNEL_LAYOUT_MONO);
   }
 
-  return channel_count;
+  return;
 }
 
-ChannelMixer::ChannelMixer(ChannelLayout input, ChannelLayout output)
-    : input_layout_(input),
-      output_layout_(output),
-      remapping_(false) {
+ChannelMixer::ChannelMixer(ChannelLayout input_layout,
+                           ChannelLayout output_layout) {
+  Initialize(input_layout,
+             ChannelLayoutToChannelCount(input_layout),
+             output_layout,
+             ChannelLayoutToChannelCount(output_layout));
+}
+
+ChannelMixer::ChannelMixer(
+    const AudioParameters& input, const AudioParameters& output) {
+  Initialize(input.channel_layout(),
+             input.channels(),
+             output.channel_layout(),
+             output.channels());
+}
+
+void ChannelMixer::Initialize(
+    ChannelLayout input_layout, int input_channels,
+    ChannelLayout output_layout, int output_channels) {
+  input_layout_ = input_layout;
+  output_layout_ = output_layout;
+  remapping_ = false;
+
   // Stereo down mix should never be the output layout.
   CHECK_NE(output_layout_, CHANNEL_LAYOUT_STEREO_DOWNMIX);
 
-  int input_channels = ValidateLayout(input_layout_);
-  int output_channels = ValidateLayout(output_layout_);
+  if (input_layout_ != CHANNEL_LAYOUT_DISCRETE)
+    ValidateLayout(input_layout_);
+  if (output_layout_ != CHANNEL_LAYOUT_DISCRETE)
+    ValidateLayout(output_layout_);
 
   // Size out the initial matrix.
   matrix_.reserve(output_channels);
   for (int output_ch = 0; output_ch < output_channels; ++output_ch)
     matrix_.push_back(std::vector<float>(input_channels, 0));
 
+  // First check for discrete case.
+  if (input_layout_ == CHANNEL_LAYOUT_DISCRETE ||
+      output_layout_ == CHANNEL_LAYOUT_DISCRETE) {
+    // If the number of input channels is more than output channels, then
+    // copy as many as we can then drop the remaining input channels.
+    // If the number of input channels is less than output channels, then
+    // copy them all, then zero out the remaining output channels.
+    int passthrough_channels = std::min(input_channels, output_channels);
+    for (int i = 0; i < passthrough_channels; ++i)
+      matrix_[i][i] = 1;
+
+    remapping_ = true;
+    return;
+  }
+
   // Route matching channels and figure out which ones aren't accounted for.
   for (Channels ch = LEFT; ch < CHANNELS_MAX;
        ch = static_cast<Channels>(ch + 1)) {
     int input_ch_index = ChannelOrder(input_layout_, ch);
     int output_ch_index = ChannelOrder(output_layout_, ch);
 
     if (input_ch_index < 0)
       continue;
 
     if (output_ch_index < 0) {
@@ skipping 12 matching lines @@
     // Since all output channels map directly to inputs we can optimize.
     remapping_ = true;
     return;
   }
 
   // Mix front LR into center.
   if (IsUnaccounted(LEFT)) {
     // When down mixing to mono from stereo, we need to be careful of full scale
     // stereo mixes.  Scaling by 1 / sqrt(2) here will likely lead to clipping
     // so we use 1 / 2 instead.
-    float scale = (output == CHANNEL_LAYOUT_MONO && input_channels == 2) ?
+    float scale =
+        (output_layout_ == CHANNEL_LAYOUT_MONO && input_channels == 2) ?
         0.5 : kEqualPowerScale;
     Mix(LEFT, CENTER, scale);
     Mix(RIGHT, CENTER, scale);
   }
 
   // Mix center into front LR.
   if (IsUnaccounted(CENTER)) {
     // When up mixing from mono, just do a copy to front LR.
-    float scale = (input == CHANNEL_LAYOUT_MONO) ? 1 : kEqualPowerScale;
+    float scale =
+        (input_layout_ == CHANNEL_LAYOUT_MONO) ? 1 : kEqualPowerScale;
     MixWithoutAccounting(CENTER, LEFT, scale);
     Mix(CENTER, RIGHT, scale);
   }
 
   // Mix back LR into: side LR || back center || front LR || front center.
   if (IsUnaccounted(BACK_LEFT)) {
     if (HasOutputChannel(SIDE_LEFT)) {
       // If we have side LR, mix back LR into side LR, but instead if the input
       // doesn't have side LR (but output does) copy back LR to side LR.
       float scale = HasInputChannel(SIDE_LEFT) ? kEqualPowerScale : 1;
       Mix(BACK_LEFT, SIDE_LEFT, scale);
       Mix(BACK_RIGHT, SIDE_RIGHT, scale);
     } else if (HasOutputChannel(BACK_CENTER)) {
       // Mix back LR into back center.
       Mix(BACK_LEFT, BACK_CENTER, kEqualPowerScale);
       Mix(BACK_RIGHT, BACK_CENTER, kEqualPowerScale);
-    } else if (output > CHANNEL_LAYOUT_MONO) {
+    } else if (output_layout_ > CHANNEL_LAYOUT_MONO) {
       // Mix back LR into front LR.
       Mix(BACK_LEFT, LEFT, kEqualPowerScale);
       Mix(BACK_RIGHT, RIGHT, kEqualPowerScale);
     } else {
       // Mix back LR into front center.
       Mix(BACK_LEFT, CENTER, kEqualPowerScale);
       Mix(BACK_RIGHT, CENTER, kEqualPowerScale);
     }
   }
 
   // Mix side LR into: back LR || back center || front LR || front center.
   if (IsUnaccounted(SIDE_LEFT)) {
     if (HasOutputChannel(BACK_LEFT)) {
       // If we have back LR, mix side LR into back LR, but instead if the input
       // doesn't have back LR (but output does) copy side LR to back LR.
       float scale = HasInputChannel(BACK_LEFT) ? kEqualPowerScale : 1;
       Mix(SIDE_LEFT, BACK_LEFT, scale);
       Mix(SIDE_RIGHT, BACK_RIGHT, scale);
     } else if (HasOutputChannel(BACK_CENTER)) {
       // Mix side LR into back center.
       Mix(SIDE_LEFT, BACK_CENTER, kEqualPowerScale);
       Mix(SIDE_RIGHT, BACK_CENTER, kEqualPowerScale);
-    } else if (output > CHANNEL_LAYOUT_MONO) {
+    } else if (output_layout_ > CHANNEL_LAYOUT_MONO) {
       // Mix side LR into front LR.
       Mix(SIDE_LEFT, LEFT, kEqualPowerScale);
       Mix(SIDE_RIGHT, RIGHT, kEqualPowerScale);
     } else {
       // Mix side LR into front center.
       Mix(SIDE_LEFT, CENTER, kEqualPowerScale);
       Mix(SIDE_RIGHT, CENTER, kEqualPowerScale);
     }
   }
 
   // Mix back center into: back LR || side LR || front LR || front center.
   if (IsUnaccounted(BACK_CENTER)) {
     if (HasOutputChannel(BACK_LEFT)) {
       // Mix back center into back LR.
       MixWithoutAccounting(BACK_CENTER, BACK_LEFT, kEqualPowerScale);
       Mix(BACK_CENTER, BACK_RIGHT, kEqualPowerScale);
     } else if (HasOutputChannel(SIDE_LEFT)) {
       // Mix back center into side LR.
       MixWithoutAccounting(BACK_CENTER, SIDE_LEFT, kEqualPowerScale);
       Mix(BACK_CENTER, SIDE_RIGHT, kEqualPowerScale);
-    } else if (output > CHANNEL_LAYOUT_MONO) {
+    } else if (output_layout_ > CHANNEL_LAYOUT_MONO) {
       // Mix back center into front LR.
       // TODO(dalecurtis): Not sure about these values?
       MixWithoutAccounting(BACK_CENTER, LEFT, kEqualPowerScale);
       Mix(BACK_CENTER, RIGHT, kEqualPowerScale);
     } else {
       // Mix back center into front center.
       // TODO(dalecurtis): Not sure about these values?
       Mix(BACK_CENTER, CENTER, kEqualPowerScale);
     }
   }
@@ skipping 112 matching lines @@
 
   DCHECK(IsUnaccounted(input_ch));
   DCHECK_GE(input_ch_index, 0);
   DCHECK_GE(output_ch_index, 0);
 
   DCHECK_EQ(matrix_[output_ch_index][input_ch_index], 0);
   matrix_[output_ch_index][input_ch_index] = scale;
 }
 
 }  // namespace media