[Chromecast] Complete PostProcessingPipeline changes

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 12 matching lines @@
 #include "chromecast/public/volume_control.h"
 
 namespace media {
 class AudioBus;
 }  // namespace media
 
 namespace chromecast {
 namespace media {
 class AlsaWrapper;
 class FilterGroup;
+class PostProcessingPipelineParser;
 
 // 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
@@ skipping 125 matching lines @@
   // RemoveInput(input) is called. Can be called on any thread.
   void AddInput(std::unique_ptr<InputQueue> input);
   // Instructs the mixer to remove an input. The input should not be referenced
   // after this is called. Can be called on any thread.
   void RemoveInput(InputQueue* input);
 
   // Attempts to write some frames of audio to ALSA. Must only be called on the
   // mixer thread.
   void OnFramesQueued();
 
+  void ResetPostProcessorsForTest(const std::string& pipeline_json);
   void SetAlsaWrapperForTest(std::unique_ptr<AlsaWrapper> alsa_wrapper);
-  void DisablePostProcessingForTest();
   void WriteFramesForTest();  // Can be called on any thread.
   void ClearInputsForTest();  // Removes all inputs.
 
   void AddLoopbackAudioObserver(
       CastMediaShlib::LoopbackAudioObserver* observer);
 
   void RemoveLoopbackAudioObserver(
       CastMediaShlib::LoopbackAudioObserver* observer);
 
   // Sets the volume multiplier for the given content |type|.
@@ skipping 16 matching lines @@
 
     float volume = 0.0f;
     float limit = 1.0f;
     bool muted = false;
   };
 
   void ResetTaskRunnerForTest();
   void FinalizeOnMixerThread();
   void FinishFinalize();
 
+  void CreatePostProcessors(PostProcessingPipelineParser* pipeline_parser);
   // Reads the buffer size, period size, start threshold, and avail min value
   // from the provided command line flags or uses default values if no flags are
   // provided.
   void DefineAlsaParameters();
 
   // Takes the provided ALSA config and sets all ALSA output hardware/software
   // playback parameters.  It will try to select sane fallback parameters based
   // on what the output hardware supports and will log warnings if it does so.
   // If any ALSA function returns an unexpected error code, the error code will
   // be returned by this function. Otherwise, it will return 0.
   int SetAlsaPlaybackParams();
   void Start();
   void Stop();
   void Close();
   void SignalError();
   void CheckChangeOutputRate(int input_samples_per_second);
   unsigned int DetermineOutputRate(unsigned int requested_rate);
 
   // Deletes an input queue that has finished preparing to delete itself.
   // 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(std::vector<uint8_t>* interleaved, int frames);
+  void WriteMixedPcm(int frames);
   void UpdateRenderingDelay(int newly_pushed_frames);
   size_t InterleavedSize(int 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_;
@@ skipping 12 matching lines @@
   std::string alsa_device_name_;
   snd_pcm_uframes_t alsa_buffer_size_;
   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_;
+  MediaPipelineBackendAlsa::RenderingDelay alsa_rendering_delay_;
 
   std::unique_ptr<base::Timer> retry_write_frames_timer_;
 
   int check_close_timeout_;
   std::unique_ptr<base::Timer> check_close_timer_;
 
   std::vector<std::unique_ptr<FilterGroup>> filter_groups_;
+  FilterGroup* default_filter_;
+  FilterGroup* mix_filter_;
+  FilterGroup* linearize_filter_;
+  std::vector<uint8_t> interleaved_;
+
   std::vector<CastMediaShlib::LoopbackAudioObserver*> loopback_observers_;
 
   std::map<AudioContentType, VolumeInfo> volume_info_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamMixerAlsa);
 };
 
 }  // namespace media
 }  // namespace chromecast
 
 #endif  // CHROMECAST_MEDIA_CMA_BACKEND_ALSA_STREAM_MIXER_ALSA_H_