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

media/audio/audio_output_device.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_device.h"
 
 #include "base/callback_helpers.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 10 matching lines @@
  public:
   AudioThreadCallback(const AudioParameters& audio_parameters,
                       base::SharedMemoryHandle memory,
                       int memory_length,
                       AudioRendererSink::RenderCallback* render_callback);
   ~AudioThreadCallback() override;
 
   void MapSharedMemory() override;
 
   // Called whenever we receive notifications about pending data.
-  void Process(uint32 pending_data) override;
+  void Process(uint32_t pending_data) override;
+
+  void FramesSkipped(uint32_t frames_skipped) override;
 
  private:
   AudioRendererSink::RenderCallback* render_callback_;
   scoped_ptr<AudioBus> output_bus_;
   uint64 callback_num_;
+
+  // Stores the number of frames skipped by the consumer. Used and cleared in
+  // Process().

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

nit: and modified in FramesSkipped

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

Done.

+  uint32_t frames_skipped_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioOutputDevice::AudioOutputDevice(
     scoped_ptr<AudioOutputIPC> ipc,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin)
     : ScopedTaskRunnerObserver(io_task_runner),
@@ skipping 300 matching lines @@
   // details.
   {
     base::AutoLock auto_lock(audio_thread_lock_);
     if (stopping_hack_)
       return;
 
     DCHECK(audio_thread_.IsStopped());
     audio_callback_.reset(new AudioOutputDevice::AudioThreadCallback(
         audio_parameters_, handle, length, callback_));
     audio_thread_.Start(audio_callback_.get(), socket_handle,
-                        "AudioOutputDevice", true);
+                        "AudioOutputDevice", true, false);
     state_ = PAUSED;
 
     // We handle the case where Play() and/or Pause() may have been called
     // multiple times before OnStreamCreated() gets called.
     if (play_on_start_)
       PlayOnIOThread();
   }
 }
 
 void AudioOutputDevice::OnIPCClosed() {
@@ skipping 12 matching lines @@
 
 // AudioOutputDevice::AudioThreadCallback
 
 AudioOutputDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     AudioRendererSink::RenderCallback* render_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length, 1),
       render_callback_(render_callback),
-      callback_num_(0) {}
+      callback_num_(0),
+      frames_skipped_(0) {}
 
 AudioOutputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioOutputDevice::AudioThreadCallback::MapSharedMemory() {
   CHECK_EQ(total_segments_, 1);
   CHECK(shared_memory_.Map(memory_length_));
   DCHECK_EQ(memory_length_, AudioBus::CalculateMemorySize(audio_parameters_));
 
   output_bus_ =
       AudioBus::WrapMemory(audio_parameters_, shared_memory_.memory());
 }
 
 // Called whenever we receive notifications about pending data.
-void AudioOutputDevice::AudioThreadCallback::Process(uint32 pending_data) {
+void AudioOutputDevice::AudioThreadCallback::Process(uint32_t pending_data) {
   // Convert the number of pending bytes in the render buffer into milliseconds.
   int audio_delay_milliseconds = pending_data / bytes_per_ms_;
 
   callback_num_++;
   TRACE_EVENT1("audio", "AudioOutputDevice::FireRenderCallback",
                "callback_num", callback_num_);
 
   // When playback starts, we get an immediate callback to Process to make sure
   // that we have some data, we'll get another one after the device is awake and
   // ingesting data, which is what we want to track with this trace.
   if (callback_num_ == 2) {
     TRACE_EVENT_ASYNC_END0("audio", "StartingPlayback", this);
   }
 
+  // Inform about skipped frames if any.
+  if (frames_skipped_ > 0) {
+    render_callback_->OnFramesSkipped(frames_skipped_);
+    frames_skipped_ = 0;
+  }
+
   // Update the audio-delay measurement then ask client to render audio.  Since
   // |output_bus_| is wrapping the shared memory the Render() call is writing
   // directly into the shared memory.
   render_callback_->Render(output_bus_.get(), audio_delay_milliseconds);
 }
 
+void AudioOutputDevice::AudioThreadCallback::FramesSkipped(

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

thread check (must be on the same thread as Process is called on)

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

The contract with AudioDeviceThread is that all callbacks will run on the same
thread. (See ADT class comment.) I can still add a thread check  of course.
Better safe than sorry?

+    uint32_t frames_skipped) {
+  frames_skipped_ += frames_skipped;
+}
+
 }  // namespace media.