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..315fd5d991f6d3e82a10f7f3057e490e4a553abf
--- /dev/null
+++ b/media/base/channel_mixer.h
@@ -0,0 +1,64 @@
+// 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);
+  virtual ~ChannelMixer();

[scherkus (not reviewing), 2012/10/18 01:30:39]

drop virtual

[DaleCurtis, 2012/10/18 05:22:04]

Done.

+
+  // Rematrixes all channels from |input| into |output|.
+  void Rematrix(const AudioBus* input, AudioBus* output);
+
+ 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_;

[Chris Rogers, 2012/10/17 19:46:50]

In general you want to avoid the pattern of vector< vector<> > since pushing new
elements requires copying the whole vector.  In this case, it's probably not a
problem since the vector size is small and you're setting it up once in the
constructor.  But FYI, in other cases when dealing with larger vectors it's
better to use other techniques, to avoid this kind of inefficiency.

[DaleCurtis, 2012/10/17 20:06:47]

Sure, I chose this for readability and portability vs trying to manage a
float[][] or vector<float*> of variable size. As you say given it's one time and
of small size it'll be fine here.

+
+  DISALLOW_COPY_AND_ASSIGN(ChannelMixer);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_CHANNEL_MIXER_H_