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"
@@ skipping 33 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(packet_size_, sizeof(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

[tommi (sloooow) - chröme, 2015/12/08 08:34:51]

why do we increase the number of skipped frames?
I would have expected just to set how many have been skipped directly and not
accumulate.

[Henrik Grunell, 2015/12/08 09:30:34]

Afaict, there is a possibility that we write more than once before the render
side has read the data. That would happen if it takes a very long time for it to
execute, WaitUntilDataIsReady times out on this side, and this function is
called again before the other side is done putting the previously requested data
in the shared memory. In that case we'd overwrite and lose information about
those skipped frames.

[tommi (sloooow) - chröme, 2015/12/08 10:08:09]

Do we still overwrite in that case? I thought we would rather drop buffers in
that case until we know for sure it's safe to write.  However, in this case
though, don't we also need to account for the buffers that we (and not the OS)
are skipping?

[Henrik Grunell, 2015/12/08 11:12:32]

If Wait...() times out, we'll give the OS an empty buffer instead. So we're not
really skipping any data, since we still requested that buffer. (Skipping means
we did not and will not ask for the data.) On the render side it will just write
data to the buffer, it doesn't know about what has been read or not.

[tommi (sloooow) - chröme, 2015/12/08 11:43:02]

I think I'm out of brain power... can you help me get back on track? Here's what
I got so far:

* We are only aware of frames_skipped for input (audio capture)
* This CL is about getting that information "upwards", i.e. from the OS layer
and to the upper layers that get audio from the microphone/capture device.

Yet, somehow we're now talking about giving the OS an empty buffer for _output_.
 Can you help me connect the dots?

[tommi (sloooow) - chröme, 2015/12/08 12:27:39]

Got some brain power back :)  I realize now that I was stuck thinking about
input, but it's actually output where we are aware of the skipped frames.  The
comments make sense now that I finally managed to wrap my head around this (yes,
I know I did this myself initially!)

[Henrik Grunell, 2015/12/08 12:56:10]

:) I'm glad you could.

+  // 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