Implement runtime audio post-processing pipeline. See go/cast_audio.json

chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc

 // 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.
 
 #include "chromecast/media/cma/backend/alsa/stream_mixer_alsa.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <unordered_set>
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/saturated_arithmetic.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/media/base/audio_device_ids.h"
 #include "chromecast/media/cma/backend/alsa/alsa_wrapper.h"
-#include "chromecast/media/cma/backend/alsa/audio_filter_factory.h"
 #include "chromecast/media/cma/backend/alsa/filter_group.h"
+#include "chromecast/media/cma/backend/alsa/post_processing_pipeline_parser.h"
 #include "chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.h"
 #include "media/audio/audio_device_description.h"
 #include "media/base/audio_bus.h"
 #include "media/base/media_switches.h"
 
 #define RETURN_REPORT_ERROR(snd_func, ...)                        \
   do {                                                            \
     int err = alsa_->snd_func(__VA_ARGS__);                       \
     if (err < 0) {                                                \
       LOG(ERROR) << #snd_func " error: " << alsa_->StrError(err); \
@@ skipping 171 matching lines @@
     LOG(INFO) << "Setting fixed sample rate to " << fixed_samples_per_second;
   }
 
   fixed_output_samples_per_second_ = fixed_samples_per_second;
 
   low_sample_rate_cutoff_ =
       chromecast::GetSwitchValueBoolean(switches::kAlsaEnableUpsampling, false)
           ? kLowSampleRateCutoff
           : 0;
 
+  // Read post-processing configuration file
+  PostProcessingPipelineParser pipeline_parser;
+  pipeline_parser.Initialize();
+
   // Create filter groups.
   // TODO(bshaya): Switch to filter groups based on AudioContentType.
   filter_groups_.push_back(base::MakeUnique<FilterGroup>(
       std::unordered_set<std::string>(
           {::media::AudioDeviceDescription::kCommunicationsDeviceId}),
-      AudioFilterFactory::COMMUNICATION_AUDIO_FILTER,
-      AudioContentType::kMedia));
+      AudioContentType::kMedia, kNumOutputChannels,
+      pipeline_parser.GetPipelineByDeviceId(
+          ::media::AudioDeviceDescription::kCommunicationsDeviceId)));
   filter_groups_.push_back(base::MakeUnique<FilterGroup>(
       std::unordered_set<std::string>({kAlarmAudioDeviceId}),
-      AudioFilterFactory::ALARM_AUDIO_FILTER, AudioContentType::kAlarm));
+      AudioContentType::kAlarm, kNumOutputChannels,
+      pipeline_parser.GetPipelineByDeviceId(kAlarmAudioDeviceId)));
   filter_groups_.push_back(base::MakeUnique<FilterGroup>(
       std::unordered_set<std::string>({kTtsAudioDeviceId}),
-      AudioFilterFactory::TTS_AUDIO_FILTER, AudioContentType::kCommunication));
+      AudioContentType::kCommunication, kNumOutputChannels,
+      pipeline_parser.GetPipelineByDeviceId(kTtsAudioDeviceId)));
   filter_groups_.push_back(base::MakeUnique<FilterGroup>(
       std::unordered_set<std::string>(
           {::media::AudioDeviceDescription::kDefaultDeviceId,
            kLocalAudioDeviceId, ""}),
-      AudioFilterFactory::MEDIA_AUDIO_FILTER, AudioContentType::kMedia));
+      AudioContentType::kMedia, kNumOutputChannels,
+      pipeline_parser.GetPipelineByDeviceId(
+          ::media::AudioDeviceDescription::kDefaultDeviceId)));
 
+  // TODO(bshaya): Add support for final mix AudioPostProcessor.
   DefineAlsaParameters();
 }
 
 void StreamMixerAlsa::ResetTaskRunnerForTest() {
   mixer_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 void StreamMixerAlsa::DefineAlsaParameters() {
   // Get the ALSA output configuration from the command line.
   alsa_buffer_size_ = GetSwitchValueNonNegativeInt(
@@ skipping 245 matching lines @@
     if (err < 0) {
       LOG(ERROR) << "Error setting ALSA playback parameters: "
                  << alsa_->StrError(err);
       SignalError();
       return;
     }
   }
 
   // Initialize filters
   for (auto&& filter_group : filter_groups_) {
-    filter_group->Initialize(output_samples_per_second_,
-                             ::media::SampleFormat::kSampleFormatS32);
+    filter_group->Initialize(output_samples_per_second_);
   }
 
   RETURN_REPORT_ERROR(PcmPrepare, pcm_);
   RETURN_REPORT_ERROR(PcmStatusMalloc, &pcm_status_);
 
   rendering_delay_.timestamp_microseconds = kNoTimestamp;
   rendering_delay_.delay_microseconds = 0;
 
   state_ = kStateNormalPlayback;
 }
@@ skipping 366 matching lines @@
   }
   UpdateRenderingDelay(frames);
   for (auto&& input : inputs_)
     input->AfterWriteFrames(rendering_delay_);
 }
 
 void StreamMixerAlsa::UpdateRenderingDelay(int newly_pushed_frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   CHECK_PCM_INITIALIZED();
 
+  // TODO(bshaya): Add rendering delay from post-processors.
   if (alsa_->PcmStatus(pcm_, pcm_status_) != 0 ||
       alsa_->PcmStatusGetState(pcm_status_) != SND_PCM_STATE_RUNNING) {
     rendering_delay_.timestamp_microseconds = kNoTimestamp;
     rendering_delay_.delay_microseconds = 0;
     return;
   }
 
   snd_htimestamp_t status_timestamp = {};
   alsa_->PcmStatusGetHtstamp(pcm_status_, &status_timestamp);
   rendering_delay_.timestamp_microseconds =
@@ skipping 79 matching lines @@
 
   for (auto&& filter : filter_groups_) {
     if (filter->content_type() == type) {
       filter->set_volume(effective_volume);
     }
   }
 }
 
 }  // namespace media
 }  // namespace chromecast