Collapse AudioRendererMixer and OnMoreDataResampler into AudioTransform.

media/base/audio_transform.h

+// 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_AUDIO_TRANSFORM_H_
+#define MEDIA_BASE_AUDIO_TRANSFORM_H_
+
+#include <list>
+
+#include "base/callback.h"
+#include "base/time.h"
+#include "media/audio/audio_parameters.h"
+#include "media/base/media_export.h"
+
+namespace media {
+
+class AudioBus;
+class AudioPullFifo;
+class ChannelMixer;
+class MultiChannelResampler;
+
+// AudioTransform is a complete mixing, resampling, rebuffering, and channel
+// mixing solution for converting data from one set of AudioParameters to
+// another.  For efficiency pieces are only invoked when necessary; e.g. the
+// resampler is only used if the input and output sample rates differ.  Mixing
+// and channel down mixing are done prior to resampling to maximize efficiency.
+class MEDIA_EXPORT AudioTransform {

[Chris Rogers, 2012/11/14 23:50:49]

This is just a naming nit, but always good to get the names right:
I recommend avoiding "transform" and calling this class "AudioConverter".  This
is because "transform" has a lot of connotations in audio such as FFT, DCT,
wavelet transform, and effects processing.  "converter" is more often used here.

[DaleCurtis, 2012/11/16 23:51:05]

Done. I'll rename the file in the last patch set to ease reviewing.

+ public:
+  class MEDIA_EXPORT AudioTransformInput {

[scherkus (not reviewing), 2012/11/14 22:43:50]

nit: this can be "Input" because its name is already scoped to AudioTransform

also... any motivation for interface vs. callback?

[DaleCurtis, 2012/11/15 00:30:59]

Just what we discussed at dinner the other day. You can stick callbacks in a
list :-/  Even providing an operator == for the Equals() method doesn't work if
you have construct two bound callbacks for the same call + params.

If we use a callback then we have to accept Callback* and have the client hold
onto it in order to remove it later. We could also take a void* key plus
callback and use an std::map<> which loses the ordering benefits of std::list.

Neither of those sounded appealing to me, so interface it is.

[DaleCurtis, 2012/11/16 23:51:05]

Changed to InputCallback a la RenderCallback

+   public:
+    // Method for providing more data into the transform.  Expects |audio_bus|
+    // to be completely filled with data upon return; zero padded if not enough
+    // frames are available to satisfy the request.  The return value is the
+    // volume level of the provided audio data.  If a volume level of zero is

[Chris Rogers, 2012/11/14 23:50:49]

can you elaborate a little more in this comment on exactly how volume is used

[DaleCurtis, 2012/11/16 23:51:05]

Done.

+    // returned no further processing will be done on the provided data.
+    virtual float ProvideAudioTransformInput(AudioBus* audio_bus,
+                                             base::TimeDelta buffer_delay) = 0;
+
+   protected:
+    virtual ~AudioTransformInput() {}
+  };
+
+  AudioTransform(const AudioParameters& input_params,
+                 const AudioParameters& output_params);
+  ~AudioTransform();
+
+  // Transforms audio from all inputs into the |dest|.  |dest| must be sized for
+  // data matching the output AudioParameters provided during construction.
+  void Transform(AudioBus* dest);
+
+  // Add or remove an input from the transform.
+  void AddInput(AudioTransformInput* input);

[justinlin, 2012/11/12 20:29:38]

Purely from an interface point of view, would it make sense to instead pass the
input_params here? This saves from having to maintain maps of <AudioParams,
AudioTransforms> if we want to resample/mix multiple different input streams.

[DaleCurtis, 2012/11/12 20:48:18]

Currently AudioRendererMixerManager does a similar function, but abstracting
that here would be pretty difficult since we'd need to manage multiple
resamplers, fifos, etc and then feed them into a post-mixer. I'll give it some
thought, but I don't think we'd do that in this CL at least.

For now, I'd just transform all the audio into one set of parameters, and then
have one more AudioTransform which mixes all those together. I think you can
probably even do this without having to manage any maps or whatnot. just a list
of AudioTransforms and then a custom callback you provide to the n+1
AudioTransform which pulls data from the other AudioTransforms.

+  void RemoveInput(AudioTransformInput* input);
+
+  // Flush all buffered data.  Automatically called when all inputs are removed.
+  void Reset();
+
+ private:
+  // Called by MultiChannelResampler when more data is necessary.
+  void ProvideInput(AudioBus* audio_bus);
+
+  // Called by AudioPullFifo when more data is necessary.
+  void SourceCallback(AudioBus* audio_bus);
+
+  // Set of inputs for Transform().
+  typedef std::list<AudioTransformInput*> AudioTransformInputSet;
+  AudioTransformInputSet transform_inputs_;
+
+  // Used to buffer data between the client and the output device in cases where
+  // the client buffer size is not the same as the output device buffer size.
+  scoped_ptr<AudioPullFifo> audio_fifo_;
+
+  // Handles resampling.
+  scoped_ptr<MultiChannelResampler> resampler_;
+
+  // Handles channel transforms.  |unmixed_audio_| is a temporary destination
+  // for audio data before it goes into the channel mixer.
+  scoped_ptr<ChannelMixer> channel_mixer_;
+  scoped_ptr<AudioBus> unmixed_audio_;
+
+  // Temporary AudioBus destination for mixing inputs.
+  scoped_ptr<AudioBus> mixer_input_audio_bus_;
+
+  // Since resampling is expensive, figure out if we should downmix channels
+  // before resampling.
+  bool downmix_early_;
+
+  // Used to calculate buffer delay information AudioTransformInputs.
+  base::TimeDelta input_frame_duration_;
+  base::TimeDelta output_frame_duration_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioTransform);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_AUDIO_TRANSFORM_H_