[Chromecast] Fix AudioVideoPipelineDeviceTest failures

chromecast/media/cma/backend/alsa/audio_decoder_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/audio_decoder_alsa.h"
 
 #include <time.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 200 matching lines @@
 }
 
 bool AudioDecoderAlsa::SetConfig(const AudioConfig& config) {
   TRACE_FUNCTION_ENTRY0();
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (!IsValidConfig(config)) {
     LOG(ERROR) << "Invalid audio config passed to SetConfig";
     return false;
   }
 
-  if (!rate_shifter_ ||
-      config.samples_per_second != config_.samples_per_second) {
+  bool changed_sample_rate =
+      (config.samples_per_second != config_.samples_per_second);
+
+  if (!rate_shifter_ || changed_sample_rate) {
     CreateRateShifter(config.samples_per_second);
   }
 
-  if (mixer_input_ && config.samples_per_second != config_.samples_per_second) {
+  if (mixer_input_ && changed_sample_rate) {
     // Destroy the old input first to ensure that the mixer output sample rate
     // is updated.
     mixer_input_.reset();
     mixer_input_.reset(new StreamMixerAlsaInput(
         this, config.samples_per_second, backend_->Primary()));
     mixer_input_->SetVolumeMultiplier(volume_multiplier_);
     pending_output_frames_ = kNoPendingOutput;
   }
 
   config_ = config;
   decoder_.reset();
   CreateDecoder();
 
-  if (pending_buffer_complete_ && !rate_shifter_->IsQueueFull()) {
+  if (pending_buffer_complete_ && changed_sample_rate) {

[slan, 2017/01/06 01:14:47]

This code is now liable to call OnPushBufferComplete when the rate_shifter_'s
queue is full. Is that OK?

[kmackay, 2017/01/06 01:21:04]

In this case, the rate shifter was just (re)created, so its queue must be empty.

     pending_buffer_complete_ = false;
     delegate_->OnPushBufferComplete(MediaPipelineBackendAlsa::kBufferSuccess);
   }
   return true;
 }
 
 void AudioDecoderAlsa::CreateDecoder() {
   DCHECK(!decoder_);
   DCHECK(IsValidConfig(config_));
 
@@ skipping 80 matching lines @@
   }
   if (mixer_error_) {
     delegate_->OnPushBufferComplete(MediaPipelineBackendAlsa::kBufferFailed);
     return;
   }
 
   Statistics delta;
   delta.decoded_bytes = input_bytes;
   UpdateStatistics(delta);
 
+  pending_buffer_complete_ = true;
   if (decoded->end_of_stream()) {
     got_eos_ = true;
   } else {
     int input_frames = decoded->data_size() / (kNumChannels * sizeof(float));
 
     DCHECK(!rate_shifter_info_.empty());
     RateShifterInfo* rate_info = &rate_shifter_info_.front();
     // Bypass rate shifter if the rate is 1.0, and there are no frames queued
     // in the rate shifter.
     if (rate_info->rate == 1.0 && rate_shifter_->frames_buffered() == 0 &&
         pending_output_frames_ == kNoPendingOutput) {
       DCHECK_EQ(rate_info->output_frames, rate_info->input_frames);
-      pending_buffer_complete_ = true;
       pending_output_frames_ = input_frames;
       if (got_eos_) {
         DCHECK(!pushed_eos_);
         pushed_eos_ = true;
       }
       mixer_input_->WritePcm(decoded);
       return;
     }
 
     // Otherwise, queue data into the rate shifter, and then try to push the
     // rate-shifted data.
     const uint8_t* channels[kNumChannels] = {
         decoded->data(), decoded->data() + input_frames * sizeof(float)};
     scoped_refptr<::media::AudioBuffer> buffer = ::media::AudioBuffer::CopyFrom(
         ::media::kSampleFormatPlanarF32, ::media::CHANNEL_LAYOUT_STEREO,
         kNumChannels, config_.samples_per_second, input_frames, channels,
         base::TimeDelta());
     rate_shifter_->EnqueueBuffer(buffer);
     rate_shifter_info_.back().input_frames += input_frames;
   }
 
   PushRateShifted();
   DCHECK(!rate_shifter_info_.empty());
-  // Can't check got_eos_ here, since it may have already been reset by a call
-  // to Stop().
-  if (decoded->end_of_stream() || (!rate_shifter_->IsQueueFull() &&
-                                   rate_shifter_info_.front().rate != 1.0)) {
+  CheckBufferComplete();
+}
+
+void AudioDecoderAlsa::CheckBufferComplete() {
+  if (!pending_buffer_complete_) {
+    return;
+  }
+
+  bool rate_shifter_queue_full = rate_shifter_->IsQueueFull();
+  DCHECK(!rate_shifter_info_.empty());
+  if (rate_shifter_info_.front().rate == 1.0) {
+    // If the current rate is 1.0, drain any data in the rate shifter before
+    // calling PushBufferComplete, so that the next PushBuffer call can skip the
+    // rate shifter entirely.
+    rate_shifter_queue_full = (rate_shifter_->frames_buffered() > 0 ||
+                               pending_output_frames_ != kNoPendingOutput);
+  }
+
+  if (pushed_eos_ || !rate_shifter_queue_full) {
+    pending_buffer_complete_ = false;
     delegate_->OnPushBufferComplete(MediaPipelineBackendAlsa::kBufferSuccess);
-  } else {
-    pending_buffer_complete_ = true;
   }
 }
 
 void AudioDecoderAlsa::PushRateShifted() {
   DCHECK(mixer_input_);
 
-  if (pending_output_frames_ != kNoPendingOutput) {
+  if (pushed_eos_ || pending_output_frames_ != kNoPendingOutput) {
     return;
   }
 
   if (got_eos_) {
     // Push some silence into the rate shifter so we can get out any remaining
     // rate-shifted data.
     rate_shifter_->EnqueueBuffer(::media::AudioBuffer::CreateEmptyBuffer(
         ::media::CHANNEL_LAYOUT_STEREO, kNumChannels,
         config_.samples_per_second, kSilenceBufferFrames, base::TimeDelta()));
   }
@@ skipping 84 matching lines @@
 }
 
 void AudioDecoderAlsa::OnWritePcmCompletion(BufferStatus status,
                                             const RenderingDelay& delay) {
   TRACE_FUNCTION_ENTRY0();
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(MediaPipelineBackendAlsa::kBufferSuccess, status);
   pending_output_frames_ = kNoPendingOutput;
   last_mixer_delay_ = delay;
 
-  if (pushed_eos_) {
-    if (pending_buffer_complete_) {
-      pending_buffer_complete_ = false;
-      delegate_->OnPushBufferComplete(MediaPipelineBackendAlsa::kBufferSuccess);
-    }
-    delegate_->OnEndOfStream();
-  } else {
-    task_runner_->PostTask(FROM_HERE, base::Bind(&AudioDecoderAlsa::PushMorePcm,
-                                                 weak_factory_.GetWeakPtr()));
-  }
+  task_runner_->PostTask(FROM_HERE, base::Bind(&AudioDecoderAlsa::PushMorePcm,
+                                               weak_factory_.GetWeakPtr()));
 }
 
 void AudioDecoderAlsa::PushMorePcm() {
   PushRateShifted();
 
   DCHECK(!rate_shifter_info_.empty());
-  if (pending_buffer_complete_) {
-    double rate = rate_shifter_info_.front().rate;
-    if ((rate == 1.0 && pending_output_frames_ == kNoPendingOutput) ||
-        (rate != 1.0 && !rate_shifter_->IsQueueFull())) {
-      pending_buffer_complete_ = false;
-      delegate_->OnPushBufferComplete(MediaPipelineBackendAlsa::kBufferSuccess);
-    }
+  CheckBufferComplete();
+
+  if (pushed_eos_) {
+    delegate_->OnEndOfStream();
   }
 }
 
 void AudioDecoderAlsa::OnMixerError(MixerError error) {
   TRACE_FUNCTION_ENTRY0();
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (error != MixerError::kInputIgnored)
     LOG(ERROR) << "Mixer error occurred.";
   mixer_error_ = true;
   delegate_->OnDecoderError();
 }
 
 }  // namespace media
 }  // namespace chromecast