Revert of [Chromecast] Process streams with different post-processing.

chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.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_input_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 47 matching lines @@
 
 const int kMaxSlewTimeUpMs = 15;
 const int kMaxSlewTimeDownMs = 15;
 
 }  // namespace
 
 StreamMixerAlsaInputImpl::StreamMixerAlsaInputImpl(
     StreamMixerAlsaInput::Delegate* delegate,
     int input_samples_per_second,
     bool primary,
-    const std::string& device_id,
     StreamMixerAlsa* mixer)
     : delegate_(delegate),
       input_samples_per_second_(input_samples_per_second),
       primary_(primary),
-      device_id_(device_id),
       mixer_(mixer),
-      filter_group_(nullptr),
       mixer_task_runner_(mixer_->task_runner()),
       caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       resample_ratio_(1.0),
       state_(kStateUninitialized),
       slew_volume_(kMaxSlewTimeUpMs, kMaxSlewTimeDownMs),
       queued_frames_(0),
       queued_frames_including_resampler_(0),
       current_buffer_offset_(0),
       max_queued_frames_(kMaxInputQueueUs * input_samples_per_second /
                          base::Time::kMicrosecondsPerSecond),
       fade_frames_remaining_(0),
       fade_out_frames_total_(0),
       zeroed_frames_(0),
       is_underflowing_(false),
       weak_factory_(this) {
-  LOG(INFO) << "Create " << device_id_ << " (" << this << ")";
+  LOG(INFO) << "Create " << this;
   DCHECK(delegate_);
   DCHECK(mixer_);
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 StreamMixerAlsaInputImpl::~StreamMixerAlsaInputImpl() {
-  LOG(INFO) << "Destroy " << device_id_ << " (" << this << ")";
+  LOG(INFO) << "Destroy " << this;
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
 }
 
 int StreamMixerAlsaInputImpl::input_samples_per_second() const {
   return input_samples_per_second_;
 }
 
 bool StreamMixerAlsaInputImpl::primary() const {
   return primary_;
 }
 
-std::string StreamMixerAlsaInputImpl::device_id() const {
-  return device_id_;
-}
-
 bool StreamMixerAlsaInputImpl::IsDeleting() const {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   return (state_ == kStateFinalFade || state_ == kStateDeleted);
 }
 
 void StreamMixerAlsaInputImpl::Initialize(
     const MediaPipelineBackendAlsa::RenderingDelay& mixer_rendering_delay) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   DCHECK(!IsDeleting());
   if (mixer_->output_samples_per_second() != input_samples_per_second_) {
     resample_ratio_ = static_cast<double>(input_samples_per_second_) /
                       mixer_->output_samples_per_second();
     resampler_.reset(new ::media::MultiChannelResampler(
         kNumOutputChannels, resample_ratio_, kDefaultReadSize,
         base::Bind(&StreamMixerAlsaInputImpl::ReadCB, base::Unretained(this))));
     resampler_->PrimeWithSilence();
   }
   slew_volume_.SetSampleRate(mixer_->output_samples_per_second());
   mixer_rendering_delay_ = mixer_rendering_delay;
   fade_out_frames_total_ = NormalFadeFrames();
   fade_frames_remaining_ = NormalFadeFrames();
 }
 
-void StreamMixerAlsaInputImpl::set_filter_group(FilterGroup* filter_group) {
-  filter_group_ = filter_group;
-}
-
-FilterGroup* StreamMixerAlsaInputImpl::filter_group() {
-  return filter_group_;
-}
-
 void StreamMixerAlsaInputImpl::PreventDelegateCalls() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   weak_factory_.InvalidateWeakPtrs();
 
   base::AutoLock lock(queue_lock_);
   pending_data_ = nullptr;
 }
 
 void StreamMixerAlsaInputImpl::PrepareToDelete(
     const OnReadyToDeleteCb& delete_cb) {
@@ skipping 279 matching lines @@
 int StreamMixerAlsaInputImpl::NormalFadeFrames() {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   int frames = (mixer_->output_samples_per_second() * kFadeMs /
                 base::Time::kMillisecondsPerSecond) -
                1;
   return std::max(frames, 0);
 }
 
 void StreamMixerAlsaInputImpl::FadeIn(::media::AudioBus* dest, int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
+  LOG(INFO) << "Fading in, " << fade_frames_remaining_ << " frames remaining";
   float fade_in_frames = mixer_->output_samples_per_second() * kFadeMs /
                          base::Time::kMillisecondsPerSecond;
   for (int f = 0; f < frames && fade_frames_remaining_; ++f) {
     float fade_multiplier = 1.0 - fade_frames_remaining_ / fade_in_frames;
     for (int c = 0; c < kNumOutputChannels; ++c)
       dest->channel(c)[f] *= fade_multiplier;
     --fade_frames_remaining_;
   }
 }
 
 void StreamMixerAlsaInputImpl::FadeOut(::media::AudioBus* dest, int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
+  LOG(INFO) << "Fading out, " << fade_frames_remaining_ << " frames remaining";
   int f = 0;
   for (; f < frames && fade_frames_remaining_; ++f) {
     float fade_multiplier =
         fade_frames_remaining_ / static_cast<float>(fade_out_frames_total_);
     for (int c = 0; c < kNumOutputChannels; ++c)
       dest->channel(c)[f] *= fade_multiplier;
     --fade_frames_remaining_;
   }
   // Zero remaining frames
   for (; f < frames; ++f) {
@@ skipping 55 matching lines @@
 
   if (state_ == kStateFadingOut) {
     // Tell the mixer that some more data might be available (since when fading
     // out, we can drain the queue completely).
     mixer_->OnFramesQueued();
   }
 }
 
 void StreamMixerAlsaInputImpl::SetVolumeMultiplier(float multiplier) {
   RUN_ON_MIXER_THREAD(SetVolumeMultiplier, multiplier);
-  LOG(INFO) << device_id_ << "(" << this << "): stream volume = " << multiplier;
+  LOG(INFO) << this << ": stream volume = " << multiplier;
   DCHECK(!IsDeleting());
   if (multiplier > 1.0f)
     multiplier = 1.0f;
   if (multiplier < 0.0f)
     multiplier = 0.0f;
   slew_volume_.SetVolume(multiplier);
 }
 
 void StreamMixerAlsaInputImpl::VolumeScaleAccumulate(bool repeat_transition,
                                                      const float* src,
                                                      int frames,
                                                      float* dest) {
   slew_volume_.ProcessFMAC(repeat_transition, src, frames, dest);
 }
 
 }  // namespace media
 }  // namespace chromecast