[Chromecast] Improve rendering delay accuracy by tracking partial samples

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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 129 matching lines @@
     return;
   }
 
   {
     base::AutoLock lock(queue_lock_);
     if (state_ == kStateGotEos) {
       fade_out_frames_total_ = queued_frames_including_resampler_;
       fade_frames_remaining_ = queued_frames_including_resampler_;
     } else if (state_ == kStateNormalPlayback) {
       fade_out_frames_total_ =
-          std::min(queued_frames_including_resampler_, NormalFadeFrames());
+          std::min(static_cast<int>(queued_frames_including_resampler_),
+                   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
     // out, we can drain the queue completely).
@@ skipping 31 matching lines @@
   queue_lock_.AssertAcquired();
   if (!data->end_of_stream()) {
     int frames =
         data->data_size() / (mixer_->num_output_channels() * sizeof(float));
     queue_.push_back(data);
     queued_frames_ += frames;
     queued_frames_including_resampler_ += frames;
   }
 
   MediaPipelineBackendAlsa::RenderingDelay delay = mixer_rendering_delay_;
-  delay.delay_microseconds +=
-      static_cast<int64_t>(queued_frames_including_resampler_) *
-      base::Time::kMicrosecondsPerSecond / input_samples_per_second_;
+  delay.delay_microseconds += static_cast<int64_t>(
+      queued_frames_including_resampler_ * base::Time::kMicrosecondsPerSecond /
+      input_samples_per_second_);
   return delay;
 }
 
 void StreamMixerAlsaInputImpl::PostPcmCallback(
     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) {
     state_ = kStateGotEos;
   } else if (state_ == kStateUninitialized) {
     state_ = kStateNormalPlayback;
   }
   mixer_->OnFramesQueued();
 }
 
 void StreamMixerAlsaInputImpl::AfterWriteFrames(
     const MediaPipelineBackendAlsa::RenderingDelay& mixer_rendering_delay) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
-  int resampler_queued_frames = (resampler_ ? resampler_->BufferedFrames() : 0);
+  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_)
       queued_frames_ +=
           data->data_size() / (mixer_->num_output_channels() * sizeof(float));
@@ skipping 20 matching lines @@
   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(queued_frames_including_resampler_, kDefaultReadSize);
+      return std::max(static_cast<int>(queued_frames_including_resampler_),
+                      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 198 matching lines @@
   DCHECK(!IsDeleting());
   if (multiplier > 1.0f)
     multiplier = 1.0f;
   if (multiplier < 0.0f)
     multiplier = 0.0f;
   volume_multiplier_ = multiplier;
 }
 
 }  // namespace media
 }  // namespace chromecast