[Chromecast] Fix fade-out frames in ALSA mixer

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 51 matching lines @@
     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),
       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_) {
-    double resample_ratio = static_cast<double>(input_samples_per_second_) /
-                            mixer_->output_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,
+        kNumOutputChannels, resample_ratio_, kDefaultReadSize,
         base::Bind(&StreamMixerAlsaInputImpl::ReadCB, base::Unretained(this))));
     resampler_->PrimeWithSilence();
   }
   mixer_rendering_delay_ = mixer_rendering_delay;
   fade_out_frames_total_ = NormalFadeFrames();
   fade_frames_remaining_ = NormalFadeFrames();
 }
 
 void StreamMixerAlsaInputImpl::PreventDelegateCalls() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
@@ skipping 11 matching lines @@
   delete_cb_ = delete_cb;
   if (state_ != kStateNormalPlayback && state_ != kStateFadingOut &&
       state_ != kStateGotEos) {
     DeleteThis();
     return;
   }
 
   {
     base::AutoLock lock(queue_lock_);
     if (state_ == kStateGotEos) {
-      fade_out_frames_total_ = queued_frames_including_resampler_;
-      fade_frames_remaining_ = queued_frames_including_resampler_;
+      fade_out_frames_total_ =
+          queued_frames_including_resampler_ / resample_ratio_;
+      fade_frames_remaining_ =
+          queued_frames_including_resampler_ / resample_ratio_;
     } else if (state_ == kStateNormalPlayback) {
       fade_out_frames_total_ =
-          std::min(static_cast<int>(queued_frames_including_resampler_),
+          std::min(static_cast<int>(queued_frames_including_resampler_ /
+                                    resample_ratio_),
                    NormalFadeFrames());
       fade_frames_remaining_ = fade_out_frames_total_;
     }
   }
 
   state_ = kStateFinalFade;
   if (fade_frames_remaining_ == 0) {
     DeleteThis();
   } else {
     // Tell the mixer that some more data might be available (since when fading
@@ skipping 50 matching lines @@
     const MediaPipelineBackendAlsa::RenderingDelay& delay) {
   RUN_ON_CALLER_THREAD(PostPcmCallback, delay);
   delegate_->OnWritePcmCompletion(MediaPipelineBackendAlsa::kBufferSuccess,
                                   delay);
 }
 
 void StreamMixerAlsaInputImpl::DidQueueData(bool end_of_stream) {
   RUN_ON_MIXER_THREAD(DidQueueData, end_of_stream);
   DCHECK(!IsDeleting());
   if (end_of_stream) {
+    LOG(INFO) << "End of stream for " << this;
     state_ = kStateGotEos;
   } else if (state_ == kStateUninitialized) {
     state_ = kStateNormalPlayback;
   }
   mixer_->OnFramesQueued();
 }
 
 void StreamMixerAlsaInputImpl::AfterWriteFrames(
     const MediaPipelineBackendAlsa::RenderingDelay& mixer_rendering_delay) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   double resampler_queued_frames =
       (resampler_ ? resampler_->BufferedFrames() : 0);
 
   bool queued_more_data = false;
   MediaPipelineBackendAlsa::RenderingDelay total_delay;
   {
     base::AutoLock lock(queue_lock_);
     mixer_rendering_delay_ = mixer_rendering_delay;
     queued_frames_ = 0;
-    for (const auto& data : queue_)
+    for (const auto& data : queue_) {
       queued_frames_ +=
           data->data_size() / (kNumOutputChannels * sizeof(float));
+    }
     queued_frames_ -= current_buffer_offset_;
     DCHECK_GE(queued_frames_, 0);
     queued_frames_including_resampler_ =
         queued_frames_ + resampler_queued_frames;
 
     if (pending_data_ && queued_frames_ < max_queued_frames_) {
       scoped_refptr<DecoderBufferBase> data = pending_data_;
       pending_data_ = nullptr;
       total_delay = QueueData(data);
       queued_more_data = true;
-      if (data->end_of_stream())
+      if (data->end_of_stream()) {
+        LOG(INFO) << "End of stream for " << this;
         state_ = kStateGotEos;
+      }
     }
   }
 
   if (queued_more_data)
     PostPcmCallback(total_delay);
 }
 
 int StreamMixerAlsaInputImpl::MaxReadSize() {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
   if (state_ == kStatePaused || state_ == kStateDeleted)
     return kPausedReadSamples;
   if (state_ == kStateFinalFade)
     return fade_frames_remaining_;
 
   int queued_frames;
   {
     base::AutoLock lock(queue_lock_);
     if (state_ == kStateGotEos)
-      return std::max(static_cast<int>(queued_frames_including_resampler_),
+      return std::max(static_cast<int>(queued_frames_including_resampler_ /
+                                       resample_ratio_),
                       kDefaultReadSize);
     queued_frames = queued_frames_;
   }
 
   int available_frames = 0;
   if (resampler_) {
     int num_chunks = queued_frames / kDefaultReadSize;
     available_frames = resampler_->ChunkSize() * num_chunks;
   } else {
     available_frames = queued_frames;
@@ skipping 74 matching lines @@
     if (buffer) {
       const float* buffer_samples =
           reinterpret_cast<const float*>(buffer->data());
       for (int i = 0; i < kNumOutputChannels; ++i) {
         const float* buffer_channel = buffer_samples + (buffer_frames * i);
         memcpy(output->channel(i) + frames_filled,
                buffer_channel + buffer_offset, frames_to_copy * sizeof(float));
       }
       frames_left -= frames_to_copy;
       frames_filled += frames_to_copy;
-      LOG_IF(WARNING, zeroed_frames_ > 0) << "Filled a total of "
-                                          << zeroed_frames_ << " frames with 0";
+      LOG_IF(WARNING, state_ != kStateFinalFade && zeroed_frames_ > 0)
+          << "Filled a total of " << zeroed_frames_ << " frames with 0";
       zeroed_frames_ = 0;
     } else {
       // No data left in queue; fill remaining frames with zeros.
-      LOG_IF(WARNING, zeroed_frames_ == 0) << "Starting to fill frames with 0";
+      LOG_IF(WARNING, state_ != kStateFinalFade && zeroed_frames_ == 0)
+          << "Starting to fill frames with 0";
       zeroed_frames_ += frames_left;
       output->ZeroFramesPartial(frames_filled, frames_left);
       frames_filled += frames_left;
       frames_left = 0;
       break;
     }
   }
 
   DCHECK_EQ(0, frames_left);
   DCHECK_EQ(frames, frames_filled);
@@ skipping 91 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) << this << ": stream volume = " << multiplier;
   DCHECK(!IsDeleting());
   if (multiplier > 1.0f)
     multiplier = 1.0f;
   if (multiplier < 0.0f)
     multiplier = 0.0f;
   volume_multiplier_ = multiplier;
 }
 
 }  // namespace media
 }  // namespace chromecast