[Chromecast] Process streams with different post-processing.

chromecast/media/cma/backend/alsa/stream_mixer_alsa.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_H_
 #define CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_
 
 #include <alsa/asoundlib.h>
 #include <stdint.h>
 
@@ skipping 11 matching lines @@
 #include "chromecast/public/cast_media_shlib.h"
 
 namespace media {
 class AudioBus;
 }  // namespace media
 
 namespace chromecast {
 namespace media {
 class AlsaWrapper;
 
+const int kNumFilterGroups = 2;
+
 // Mixer implementation. The mixer has one or more input queues; these can be
 // added/removed at any time. When an input source pushes frames to an input
 // queue, the queue should call StreamMixerAlsa::WriteFrames(); this causes
 // the mixer to attempt to mix and write out as many frames as possible. To do
 // this, the mixer determines how many frames can be read from all inputs (ie,
 // it gets the maximum number of frames that can be read from each input, and
 // uses the minimum value). Assuming that all primary inputs have some data
 // available, the calculated number of frames are pulled from each input (maybe
 // resampled, if the input's incoming sample rate is not equal to the mixer's
-// output sample rate) and written to the ALSA stack.
+// output sample rate), mixed and written to the ALSA stack.
+//
+// MIXER ARCHITECTURE
+// The mixer allows multiple streams to be grouped together for post-processing
+// purposes. Each group has a single AudioFilterInterface instance that
+// is used to post-process the data before a final mixing stage.
+//
+//  Stream  Stream  Stream   Stream  Stream   <- Input streams
+//    |        |       |       |       |
+//  ---------------------   ----------------
+//  |  Media Mixer      |   | System Mixer |  <- Intermediate mix
+//  ---------------------   ----------------
+//           |                     |
+//  ---------------------   -----------------
+//  |  Media Filter     |   | System Filter |
+//  ---------------------   -----------------
+//                 \             /
+//                -----------------
+//                |  Final Mixer  |
+//                -----------------
+//                        |
+//                      ALSA
 //
 // The rendering delay is recalculated after every successful write to the ALSA
 // stack. This delay is passed up to the input sources whenever some new data
 // is sucessfully added to the input queue (which happens whenever the amount
 // of data in the queue drops below the maximum limit, if data is pending). Note
 // that the rendering delay is not accurate while the mixer is gathering frames
 // to write, so the rendering delay and the queue size for each input must be
 // updated atomically after each write is complete (ie, in AfterWriteFrames()).
 class StreamMixerAlsa {
  public:
   // This mixer will pull data from InputQueues which are added to it, mix the
   // data from the streams, and write the mixed data as a single stream to ALSA.
   // These methods will be called on the mixer thread only.
   class InputQueue {
    public:
     using OnReadyToDeleteCb = base::Callback<void(InputQueue*)>;
 
     virtual ~InputQueue() {}
 
     // Returns the sample rate of this stream *before* data is resampled to
     // match the sample rate expected by the mixer. The returned value must be
     // positive.
     virtual int input_samples_per_second() const = 0;
 
     // Returns true if the stream is primary. Primary streams will be given
     // precedence for sample rates and will dictate when data is polled.
     virtual bool primary() const = 0;
 
+    // Returns a string describing the content type class.
+    // Should be from chromecast/public/media/audio_device_ids.h
+    // or media/audio/audio_device_description.h
+    virtual std::string name() const = 0;
+
     // Returns true if PrepareToDelete() has been called.
     virtual bool IsDeleting() const = 0;
 
     // Initializes the InputQueue after the mixer is set up. At this point the
     // input can correctly determine the mixer's output sample rate.
     virtual void Initialize(const MediaPipelineBackendAlsa::RenderingDelay&
                                 mixer_rendering_delay) = 0;
 
     // Returns the maximum number of frames that can be read from this input
     // stream without filling with zeros. This should return 0 if the queue is
@@ skipping 108 matching lines @@
   // May be called on any thread.
   void DeleteInputQueue(InputQueue* input);
   // Runs on mixer thread to complete input queue deletion.
   void DeleteInputQueueInternal(InputQueue* input);
   // Called after a timeout period to close the PCM handle if no inputs are
   // present.
   void CheckClose();
 
   void WriteFrames();
   bool TryWriteFrames();
-  void WriteMixedPcm(const ::media::AudioBus& mixed, int frames,
-      bool is_silence);
+
+  // Mixes |active_inputs| and processes the resulting buffer
+  // with pre_loopback_filter_[|filter|].
+  // If |accumulate| is false, |interleaved_| will be overwritten
+  //  (rather than summed).
+  // Returns |true| if non-zero data was written to |interleaved_|.
+  bool MixAndFilterGroup(const std::vector<InputQueue*>& active_inputs,
+                         int filter,
+                         int frames,
+                         bool accumulate);
+  void WriteMixedPcm(int frames);
   void UpdateRenderingDelay(int newly_pushed_frames);
   ssize_t BytesPerOutputFormatSample();
+  void ResizeBuffersIfNecessary(int chunk_size);
 
   static bool single_threaded_for_test_;
 
   std::unique_ptr<AlsaWrapper> alsa_;
   std::unique_ptr<base::Thread> mixer_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> mixer_task_runner_;
 
   unsigned int fixed_output_samples_per_second_;
   unsigned int low_sample_rate_cutoff_;
   int requested_output_samples_per_second_;
@@ skipping 10 matching lines @@
   bool alsa_period_explicitly_set;
   snd_pcm_uframes_t alsa_period_size_;
   snd_pcm_uframes_t alsa_start_threshold_;
   snd_pcm_uframes_t alsa_avail_min_;
 
   State state_;
 
   std::vector<std::unique_ptr<InputQueue>> inputs_;
   std::vector<std::unique_ptr<InputQueue>> ignored_inputs_;
   MediaPipelineBackendAlsa::RenderingDelay rendering_delay_;
+  // Buffer to write intermediate mixes during post-processing.
+  std::vector<uint8_t> interleaved_intermediate_;
   // Buffer to write final interleaved data before sending to snd_pcm_writei().
   std::vector<uint8_t> interleaved_;
 
   // Buffers that hold audio data while it is mixed, before it is passed to the
   // ALSA layer. These are kept as members of this class to minimize copies and
   // allocations.
   std::unique_ptr<::media::AudioBus> temp_;
   std::unique_ptr<::media::AudioBus> mixed_;
 
   std::unique_ptr<base::Timer> retry_write_frames_timer_;
 
   int check_close_timeout_;
   std::unique_ptr<base::Timer> check_close_timer_;
 
   std::vector<CastMediaShlib::LoopbackAudioObserver*> loopback_observers_;
 
-  std::unique_ptr<AudioFilterInterface> pre_loopback_filter_;
-  std::unique_ptr<AudioFilterInterface> post_loopback_filter_;
-  int silence_frames_filtered_ = 0;
+  std::unique_ptr<AudioFilterInterface> pre_loopback_filter_[kNumFilterGroups];

[tianyuwang1, 2017/02/18 00:17:08]

Since there's no post_loopback_filter_ anymore, just call this output_filter or
playout_filter?  

[bshaya, 2017/02/21 23:30:14]

Done.

+  int silence_frames_filtered_[kNumFilterGroups];
 
   DISALLOW_COPY_AND_ASSIGN(StreamMixerAlsa);
 };
 
 }  // namespace media
 }  // namespace chromecast
 
 #endif  // CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_