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

media/audio/mac/audio_auhal_mac.cc

 // Copyright 2013 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/mac/audio_auhal_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 186 matching lines @@
 // be contended in the middle of stream processing here (starting and stopping
 // the stream are ok) because this is running on a real-time thread.
 OSStatus AUHALStream::Render(
     AudioUnitRenderActionFlags* flags,
     const AudioTimeStamp* output_time_stamp,
     UInt32 bus_number,
     UInt32 number_of_frames,
     AudioBufferList* data) {
   TRACE_EVENT0("audio", "AUHALStream::Render");
 
-  UpdatePlayoutTimestamp(output_time_stamp);
+  UInt32 lost_frames = UpdatePlayoutTimestampAndStats(output_time_stamp);
+
+  // Inform the source about any skipped (lost) frames. If we use a fifo this
+  // will be out of sync with the fifo pulls (different buffer sizes), so we do
+  // it here and not in ProvideInput().
+  if (lost_frames > 0) {
+    base::AutoLock auto_lock(source_lock_);
+    if (source_)
+      source_->OnSkippedData(lost_frames);
+  }
 
   // If the stream parameters change for any reason, we need to insert a FIFO
   // since the OnMoreData() pipeline can't handle frame size changes.
   if (number_of_frames != number_of_frames_) {
     // Create a FIFO on the fly to handle any discrepancies in callback rates.
     if (!audio_fifo_) {
       number_of_frames_requested_ = number_of_frames;
       DVLOG(1) << "Audio frame size changed from " << number_of_frames_
                << " to " << number_of_frames
                << "; adding FIFO to compensate.";
@@ skipping 121 matching lines @@
   // the bots, probably less so in the wild.
   if (now_ns > output_time_ns)
     return 0;
 
   double delay_frames = static_cast<double>
       (1e-9 * (output_time_ns - now_ns) * output_format_.mSampleRate);
 
   return (delay_frames + hardware_latency_frames_);
 }
 
-void AUHALStream::UpdatePlayoutTimestamp(const AudioTimeStamp* timestamp) {
+UInt32 AUHALStream::UpdatePlayoutTimestampAndStats(
+    const AudioTimeStamp* timestamp) {
   if ((timestamp->mFlags & kAudioTimeStampSampleTimeValid) == 0)
     return;
 
+  UInt32 lost_frames = 0;
   if (last_sample_time_) {
     DCHECK_NE(0U, last_number_of_frames_);
     UInt32 diff =
         static_cast<UInt32>(timestamp->mSampleTime - last_sample_time_);
     if (diff != last_number_of_frames_) {
       DCHECK_GT(diff, last_number_of_frames_);
       // We're being asked to render samples post what we expected. Update the
       // glitch count etc and keep a record of the largest glitch.
-      auto lost_frames = diff - last_number_of_frames_;
+      lost_frames = diff - last_number_of_frames_;
       total_lost_frames_ += lost_frames;
       if (lost_frames > largest_glitch_frames_)
         largest_glitch_frames_ = lost_frames;
       ++glitches_detected_;
     }
   }
 
   // Store the last sample time for use next time we get called back.
   last_sample_time_ = timestamp->mSampleTime;
+
+  return lost_frames;
 }
 
 void AUHALStream::ReportAndResetStats() {
   if (!last_sample_time_)
     return;  // No stats gathered to report.
 
   // A value of 0 indicates that we got the buffer size we asked for.
   UMA_HISTOGRAM_COUNTS("Media.Audio.Render.FramesRequested",
                        number_of_frames_requested_);
   // Even if there aren't any glitches, we want to record it to get a feel for
@@ skipping 157 matching lines @@
   OSStatus result = AudioUnitUninitialize(audio_unit_);
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "AudioUnitUninitialize() failed.";
   result = AudioComponentInstanceDispose(audio_unit_);
   OSSTATUS_DLOG_IF(ERROR, result != noErr, result)
       << "AudioComponentInstanceDispose() failed.";
   audio_unit_ = 0;
 }
 
 }  // namespace media