[chromecast] Slew stream volume changes in StreamMixerAlsa.

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 38 matching lines @@
 const int kNumOutputChannels = 2;
 const int64_t kMaxInputQueueUs = 90000;
 const int64_t kFadeMs = 15;
 // Number of samples to report as readable when paused. When paused, the mixer
 // will still pull this many frames each time it tries to write frames, but we
 // fill the frames with silence.
 const int kPausedReadSamples = 512;
 const int kDefaultReadSize = ::media::SincResampler::kDefaultRequestSize;
 const int64_t kNoTimestamp = std::numeric_limits<int64_t>::min();
 
+const int kMaxSlewTimeUpMs = 100;
+const int kMaxSlewTimeDownMs = 100;
+
 }  // namespace
 
 StreamMixerAlsaInputImpl::StreamMixerAlsaInputImpl(
     StreamMixerAlsaInput::Delegate* delegate,
     int input_samples_per_second,
     bool primary,
     StreamMixerAlsa* mixer)
     : delegate_(delegate),
       input_samples_per_second_(input_samples_per_second),
       primary_(primary),
       mixer_(mixer),
       mixer_task_runner_(mixer_->task_runner()),
       caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       resample_ratio_(1.0),
       state_(kStateUninitialized),
-      volume_multiplier_(1.0f),
+      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),
       weak_factory_(this) {
   LOG(INFO) << "Create " << this;
   DCHECK(delegate_);
   DCHECK(mixer_);
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 StreamMixerAlsaInputImpl::~StreamMixerAlsaInputImpl() {
   LOG(INFO) << "Destroy " << this;
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
 }
 
 int StreamMixerAlsaInputImpl::input_samples_per_second() const {
   return input_samples_per_second_;
 }
 
-float StreamMixerAlsaInputImpl::volume_multiplier() const {
-  return volume_multiplier_;
-}
-
 bool StreamMixerAlsaInputImpl::primary() const {
   return primary_;
 }
 
 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::PreventDelegateCalls() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   weak_factory_.InvalidateWeakPtrs();
 
   base::AutoLock lock(queue_lock_);
@@ skipping 362 matching lines @@
 }
 
 void StreamMixerAlsaInputImpl::SetVolumeMultiplier(float multiplier) {
   RUN_ON_MIXER_THREAD(SetVolumeMultiplier, multiplier);
   LOG(INFO) << this << ": stream volume = " << multiplier;
   DCHECK(!IsDeleting());
   if (multiplier > 1.0f)
     multiplier = 1.0f;
   if (multiplier < 0.0f)
     multiplier = 0.0f;
-  volume_multiplier_ = multiplier;
+  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