Forward the number of skipped frames by the OS in audio playout.

media/audio/audio_output_controller.cc

 // Copyright (c) 2012 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 "media/audio/audio_output_controller.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/task_runner_util.h"
@@ skipping 18 matching lines @@
       stream_(NULL),
       diverting_to_stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
       sync_reader_(sync_reader),
       message_loop_(audio_manager->GetTaskRunner()),
       power_monitor_(
           params.sample_rate(),
           TimeDelta::FromMilliseconds(kPowerMeasurementTimeConstantMillis)),
       on_more_io_data_called_(0),
-      ignore_errors_during_stop_close_(false) {
+      ignore_errors_during_stop_close_(false),
+      frames_skipped_(0) {
   DCHECK(audio_manager);
   DCHECK(handler_);
   DCHECK(sync_reader_);
   DCHECK(message_loop_.get());
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);
 }
 
@@ skipping 103 matching lines @@
 void AudioOutputController::DoPlay() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.PlayTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoPlay");
 
   // We can start from created or paused state.
   if (state_ != kCreated && state_ != kPaused)
     return;
 
   // Ask for first packet.
-  sync_reader_->UpdatePendingBytes(0);
+  sync_reader_->UpdatePendingBytes(0, 0);
 
   state_ = kPlaying;
 
   stream_->Start(this);
 
   // For UMA tracking purposes, start the wedge detection timer.  This allows us
   // to record statistics about the number of wedged playbacks in the field.
   //
   // WedgeCheck() will look to see if |on_more_io_data_called_| is true after
   // the timeout expires.  Care must be taken to ensure the wedge check delay is
@@ skipping 32 matching lines @@
   TRACE_EVENT0("audio", "AudioOutputController::DoPause");
 
   StopStream();
 
   if (state_ != kPaused)
     return;
 
   // Let the renderer know we've stopped.  Necessary to let PPAPI clients know
   // audio has been shutdown.  TODO(dalecurtis): This stinks.  PPAPI should have
   // a better way to know when it should exit PPB_Audio_Shared::Run().
-  sync_reader_->UpdatePendingBytes(kuint32max);
+  sync_reader_->UpdatePendingBytes(kuint32max, 0);
 
   handler_->OnPaused();
 }
 
 void AudioOutputController::DoClose() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CloseTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoClose");
 
   if (state_ != kClosed) {
@@ skipping 59 matching lines @@
   // Indicate that we haven't wedged (at least not indefinitely, WedgeCheck()
   // may have already fired if OnMoreData() took an abnormal amount of time).
   // Since this thread is the only writer of |on_more_io_data_called_| once the
   // thread starts, its safe to compare and then increment.
   if (base::AtomicRefCountIsZero(&on_more_io_data_called_))
     base::AtomicRefCountInc(&on_more_io_data_called_);
 
   sync_reader_->Read(dest);
 
   const int frames = dest->frames();
-  sync_reader_->UpdatePendingBytes(base::saturated_cast<uint32>(
-      total_bytes_delay + frames * params_.GetBytesPerFrame()));
+  sync_reader_->UpdatePendingBytes(
+      base::saturated_cast<uint32>(total_bytes_delay +

[tommi (sloooow) - chröme, 2015/12/01 13:34:25]

this saturated cast looks like a hack. :-/

Can we at least pull it out of this expression since total_bytes_delay is
already the right type, and do:

uint32_t frame_bytes = base::saturated_cast<uint32>(frames *
params_.GetBytesPerFrame());
sync_reader_->UpdatePendingBytes(total_bytes_delay + frame_bytes);

Even so, frame_bytes should never overflow, so maybe we could do something more
drastic if it ever does (if we need to).

[Henrik Grunell, 2015/12/03 17:01:07]

Agree, I don't know why we would fear it overflowing.

+                                   frames * params_.GetBytesPerFrame()),
+      frames_skipped_);
+  frames_skipped_ = 0;
 
   if (will_monitor_audio_levels())
     power_monitor_.Scan(*dest, frames);
 
   return frames;
 }
 
+void AudioOutputController::OnSkippedData(uint32 frames_skipped) {

[tommi (sloooow) - chröme, 2015/12/01 13:34:25]

thread check

[Henrik Grunell, 2015/12/03 17:01:06]

Done.

+  // Store the number of skipped frames, will be passed to the provider in
+  // OnMoreData().
+  frames_skipped_ += frames_skipped;
+}
+
 void AudioOutputController::OnError(AudioOutputStream* stream) {
   {
     base::AutoLock auto_lock(error_lock_);
     if (ignore_errors_during_stop_close_)
       return;
   }
 
   // Handle error on the audio controller thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoReportError, this));
@@ skipping 108 matching lines @@
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media