[Chromecast] Process streams with different post-processing.

chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.h

 // Copyright 2015 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 CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_INPUT_IMPL_H_
 #define CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_INPUT_IMPL_H_
 
 #include <deque>
 #include <memory>
+#include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "chromecast/media/cma/backend/alsa/media_pipeline_backend_alsa.h"
 #include "chromecast/media/cma/backend/alsa/slew_volume.h"
 #include "chromecast/media/cma/backend/alsa/stream_mixer_alsa.h"
 #include "chromecast/media/cma/backend/alsa/stream_mixer_alsa_input.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace media {
 class AudioBus;
 class MultiChannelResampler;
 }  // namespace media
 
 namespace chromecast {
 namespace media {
 
+class FilterGroup;
+
 // Input queue implementation for StreamMixerAlsa. Each input source pushes
 // frames to an instance of StreamMixerAlsaInputImpl; this then signals the
 // mixer to pull as much data as possible from all input queues, and mix it and
 // write it out to the ALSA stack. The delegate's OnWritePcmCompletion() method
 // is called (on the caller thread) whenever data has been successfully added to
 // the queue (this may not happen immediately if the queue's maximum size limit
 // has been exceeded).
 //
 // If an input is being resampled, it is conservative about how much data it can
 // provide to be written. This is because the resampler buffers some data
@@ skipping 40 matching lines @@
     kStatePaused,          // Currently paused.
     kStateGotEos,          // Got the end-of-stream buffer (normal playback).
     kStateFinalFade,       // Fading out to a deleted state.
     kStateDeleted,         // Told the mixer to delete this.
     kStateError,           // A mixer error occurred, this is unusable now.
   };
 
   StreamMixerAlsaInputImpl(StreamMixerAlsaInput::Delegate* delegate,
                            int input_samples_per_second,
                            bool primary,
+                           const std::string& device_id,
                            StreamMixerAlsa* mixer);
 
   ~StreamMixerAlsaInputImpl() override;
 
   // Queues some PCM data to be mixed. |data| must be in planar float format.
   void WritePcm(const scoped_refptr<DecoderBufferBase>& data);
 
   // Sets the pause state of this stream.
   void SetPaused(bool paused);
 
   // Sets the volume multiplier for this stream. If |multiplier| < 0, sets the
   // volume multiplier to 0. If |multiplier| > 1, sets the volume multiplier
   // to 1.
   void SetVolumeMultiplier(float multiplier);
 
   // Prevents any further calls to the delegate (ie, called when the delegate
   // is being destroyed).
   void PreventDelegateCalls();
 
   State state() const { return state_; }
 
  private:
   // StreamMixerAlsa::InputQueue implementation:
   int input_samples_per_second() const override;
   bool primary() const override;
+  std::string device_id() const override;
   bool IsDeleting() const override;
   void Initialize(const MediaPipelineBackendAlsa::RenderingDelay&
                       mixer_rendering_delay) override;
+  void set_filter_group(FilterGroup* filter_group) override;
+  FilterGroup* filter_group() override;
   int MaxReadSize() override;
   void GetResampledData(::media::AudioBus* dest, int frames) override;
   void OnSkipped() override;
   void VolumeScaleAccumulate(bool repeat_transition,
                              const float* src,
                              int frames,
                              float* dest) override;
   void AfterWriteFrames(const MediaPipelineBackendAlsa::RenderingDelay&
                             mixer_rendering_delay) override;
   void SignalError(StreamMixerAlsaInput::MixerError error) override;
   void PrepareToDelete(const OnReadyToDeleteCb& delete_cb) override;
 
   // Tells the mixer to delete |this|. Makes sure not to call |delete_cb_| more
   // than once for |this|.
   void DeleteThis();
   MediaPipelineBackendAlsa::RenderingDelay QueueData(
       const scoped_refptr<DecoderBufferBase>& data);
   void PostPcmCallback(const MediaPipelineBackendAlsa::RenderingDelay& delay);
   void DidQueueData(bool end_of_stream);
   void ReadCB(int frame_delay, ::media::AudioBus* output);
   void FillFrames(int frame_delay, ::media::AudioBus* output, int frames);
   int NormalFadeFrames();
   void FadeIn(::media::AudioBus* dest, int frames);
   void FadeOut(::media::AudioBus* dest, int frames);
   void PostError(StreamMixerAlsaInput::MixerError error);
 
   StreamMixerAlsaInput::Delegate* const delegate_;
   const int input_samples_per_second_;
   const bool primary_;
+  std::string device_id_;
   StreamMixerAlsa* const mixer_;
+  FilterGroup* filter_group_;
   const scoped_refptr<base::SingleThreadTaskRunner> mixer_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
   double resample_ratio_;
 
   State state_;
   SlewVolume slew_volume_;
 
   base::Lock queue_lock_;  // Lock for the following queue-related members.
   scoped_refptr<DecoderBufferBase> pending_data_;
@@ skipping 17 matching lines @@
   base::WeakPtr<StreamMixerAlsaInputImpl> weak_this_;
   base::WeakPtrFactory<StreamMixerAlsaInputImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamMixerAlsaInputImpl);
 };
 
 }  // namespace media
 }  // namespace chromecast
 
 #endif  // CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_INPUT_IMPL_H_