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

content/browser/renderer_host/media/audio_sync_reader.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 "content/browser/renderer_host/media/audio_sync_reader.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/common/content_switches.h"
 #include "media/audio/audio_parameters.h"
 
 using media::AudioBus;
+using media::AudioOutputBuffer;
 
 namespace {
 
 // Used to log if any audio glitches have been detected during an audio session.
 // Elements in this enum should not be added, deleted or rearranged.
 enum AudioGlitchResult {
   AUDIO_RENDERER_NO_AUDIO_GLITCHES = 0,
   AUDIO_RENDERER_AUDIO_GLITCHES = 1,
   AUDIO_RENDERER_AUDIO_GLITCHES_MAX = AUDIO_RENDERER_AUDIO_GLITCHES
 };
@@ skipping 16 matching lines @@
       packet_size_(shared_memory_->requested_size()),
       renderer_callback_count_(0),
       renderer_missed_callback_count_(0),
 #if defined(OS_MACOSX)
       maximum_wait_time_(params.GetBufferDuration() / 2),
 #else
       // TODO(dalecurtis): Investigate if we can reduce this on all platforms.
       maximum_wait_time_(base::TimeDelta::FromMilliseconds(20)),
 #endif
       buffer_index_(0) {
-  DCHECK_EQ(packet_size_, AudioBus::CalculateMemorySize(params));
-  output_bus_ = AudioBus::WrapMemory(params, shared_memory->memory());
+  DCHECK_EQ(static_cast<size_t>(packet_size_),
+            sizeof(media::AudioOutputBufferParameters) +
+                AudioBus::CalculateMemorySize(params));
+  AudioOutputBuffer* buffer =
+      reinterpret_cast<AudioOutputBuffer*>(shared_memory_->memory());
+  output_bus_ = AudioBus::WrapMemory(params, buffer->audio);
   output_bus_->Zero();
 }
 
 AudioSyncReader::~AudioSyncReader() {
   if (!renderer_callback_count_)
     return;
 
   // Recording the percentage of deadline misses gives us a rough overview of
   // how many users might be running into audio glitches.
   int percentage_missed =
       100.0 * renderer_missed_callback_count_ / renderer_callback_count_;
   UMA_HISTOGRAM_PERCENTAGE(
       "Media.AudioRendererMissedDeadline", percentage_missed);
 
   // Add more detailed information regarding detected audio glitches where
   // a non-zero value of |renderer_missed_callback_count_| is added to the
   // AUDIO_RENDERER_AUDIO_GLITCHES bin.
   renderer_missed_callback_count_ > 0 ?
       LogAudioGlitchResult(AUDIO_RENDERER_AUDIO_GLITCHES) :
       LogAudioGlitchResult(AUDIO_RENDERER_NO_AUDIO_GLITCHES);
   std::string log_string =
       base::StringPrintf("ASR: number of detected audio glitches=%d",
                          static_cast<int>(renderer_missed_callback_count_));
   MediaStreamManager::SendMessageToNativeLog(log_string);
   DVLOG(1) << log_string;
 }
 
 // media::AudioOutputController::SyncReader implementations.
-void AudioSyncReader::UpdatePendingBytes(uint32 bytes) {
+void AudioSyncReader::UpdatePendingBytes(uint32_t bytes,
+                                         uint32_t frames_skipped) {
+  // Increase the number of skipped frames stored in shared memory. We don't
+  // send it over the socket since sending more than 4 bytes might lead to being
+  // descheduled. The reading side will zero it when consumed.
+  AudioOutputBuffer* buffer =
+      reinterpret_cast<AudioOutputBuffer*>(shared_memory_->memory());
+  buffer->params.frames_skipped += frames_skipped;
+
   // Zero out the entire output buffer to avoid stuttering/repeating-buffers
   // in the anomalous case if the renderer is unable to keep up with real-time.
   output_bus_->Zero();
+
   socket_->Send(&bytes, sizeof(bytes));
   ++buffer_index_;
 }
 
 void AudioSyncReader::Read(AudioBus* dest) {
   ++renderer_callback_count_;
   if (!WaitUntilDataIsReady()) {
     ++renderer_missed_callback_count_;
     if (renderer_missed_callback_count_ <= 100) {
       LOG(WARNING) << "AudioSyncReader::Read timed out, audio glitch count="
@@ skipping 74 matching lines @@
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(1000),
                                50);
     return false;
   }
 
   return true;
 }
 
 }  // namespace content