Add support for channel transforms.

media/base/channel_mixer.h

Index: media/base/channel_mixer.h
diff --git a/media/base/channel_mixer.h b/media/base/channel_mixer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3beb17ffe6c28c8b0f16a1b639b97fd287bda765
--- /dev/null
+++ b/media/base/channel_mixer.h
@@ -0,0 +1,68 @@
+// 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_MIXER_H_
+#define MEDIA_BASE_CHANNEL_MIXER_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "media/base/channel_layout.h"
+#include "media/base/media_export.h"
+
+namespace media {
+
+class AudioBus;
+
+// ChannelMixer is a simple rematrixing solution for converting between channel
+// layouts.  The conversion matrix is built upon construction and used during
+// each Rematrix() call.  The algorithm works by generating a conversion matrix
+// mapping each output channel to list of input channels.  The rematrixing is
+// then done by scaling each input channel according to the matrix and summing
+// it into a single output channel.
+class MEDIA_EXPORT ChannelMixer {
+ public:
+  ChannelMixer(ChannelLayout input, ChannelLayout output);
+  ~ChannelMixer();
+
+  // Rematrixes all channels from |input| into |output|.
+  void Rematrix(const AudioBus* input, AudioBus* output);

[DaleCurtis, 2012/10/18 21:36:54]

Henrik brought this up on another CL, but is Rematrix() the common term for
this? I've heard it used in this way before, but I don't see much support via
Google. WDYT crogers?

[scherkus (not reviewing), 2012/10/18 21:42:05]

Well... the dictionary doesn't list "matrix" as a verb so I suppose it's a
little odd.

Perhaps the right way to think of this is that this class is really a
ChannelMatrix (not a mixer?!) and that if we're to use mathematical terms you
would have a method called Transform() or Apply().

[DaleCurtis, 2012/10/18 21:44:10]

I like Transform(). We'll see what Chris thinks.

+
+ private:
+  // Constructor helper methods for managing unaccounted input channels.
+  void AccountFor(Channels ch);
+  bool IsUnaccounted(Channels ch);
+
+  // Helper methods for checking if |ch| exists in either |input_layout_| or
+  // |output_layout_| respectively.
+  bool HasInputChannel(Channels ch);
+  bool HasOutputChannel(Channels ch);
+
+  // Constructor 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);
+
+  // Input and output channel layout provided during construction.
+  ChannelLayout input_layout_;
+  ChannelLayout output_layout_;
+
+  // Helper variable for tracking which inputs are currently unaccounted, should
+  // be empty after construction completes.
+  std::vector<Channels> unaccounted_inputs_;
+
+  // 2D matrix of output channels to input channels.
+  std::vector< std::vector<float> > matrix_;
+
+  // Optimization case for when we can simply remap the input channels to output
+  // channels and don't need to do a multiply-accumulate loop over |matrix_|.
+  bool remapping_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChannelMixer);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_CHANNEL_MIXER_H_