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

media/audio/audio_device_thread.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_device_thread.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 // simpler than SimpleThread (no synchronization in Start, etc) and supports
 // joining the thread handle asynchronously via a provided message loop even
 // after the Thread object itself has been deleted.
 class AudioDeviceThread::Thread
     : public PlatformThread::Delegate,
       public base::RefCountedThreadSafe<AudioDeviceThread::Thread> {
  public:
   Thread(AudioDeviceThread::Callback* callback,
          base::SyncSocket::Handle socket,
          const char* thread_name,
-         bool synchronized_buffers);
+         bool synchronized_buffers,
+         bool input);
 
   void Start();
 
   // Stops the thread.  If |loop_for_join| is non-NULL, the function posts
   // a task to join (close) the thread handle later instead of waiting for
   // the thread.  If loop_for_join is NULL, then the function waits
   // synchronously for the thread to terminate.
   void Stop(base::MessageLoop* loop_for_join);
 
  private:
   friend class base::RefCountedThreadSafe<AudioDeviceThread::Thread>;
   ~Thread() override;
 
   // Overrides from PlatformThread::Delegate.
   void ThreadMain() override;
 
   // Runs the loop that reads from the socket.
   void Run();
 
  private:
   base::PlatformThreadHandle thread_;
   AudioDeviceThread::Callback* callback_;
   base::CancelableSyncSocket socket_;
   base::Lock callback_lock_;
   const char* thread_name_;
   const bool synchronized_buffers_;
+  const bool input_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 // AudioDeviceThread implementation
 
 AudioDeviceThread::AudioDeviceThread() {
 }
 
 AudioDeviceThread::~AudioDeviceThread() { DCHECK(!thread_.get()); }
 
 void AudioDeviceThread::Start(AudioDeviceThread::Callback* callback,
                               base::SyncSocket::Handle socket,
                               const char* thread_name,
-                              bool synchronized_buffers) {
+                              bool synchronized_buffers,
+                              bool input) {
   base::AutoLock auto_lock(thread_lock_);
   CHECK(!thread_.get());
-  thread_ = new AudioDeviceThread::Thread(
-      callback, socket, thread_name, synchronized_buffers);
+  thread_ = new AudioDeviceThread::Thread(callback, socket, thread_name,
+                                          synchronized_buffers, input);
   thread_->Start();
 }
 
 void AudioDeviceThread::Stop(base::MessageLoop* loop_for_join) {
   base::AutoLock auto_lock(thread_lock_);
   if (thread_.get()) {
     thread_->Stop(loop_for_join);
     thread_ = NULL;
   }
 }
 
 bool AudioDeviceThread::IsStopped() {
   base::AutoLock auto_lock(thread_lock_);
   return !thread_.get();
 }
 
 // AudioDeviceThread::Thread implementation
 AudioDeviceThread::Thread::Thread(AudioDeviceThread::Callback* callback,
                                   base::SyncSocket::Handle socket,
                                   const char* thread_name,
-                                  bool synchronized_buffers)
+                                  bool synchronized_buffers,
+                                  bool input)
     : thread_(),
       callback_(callback),
       socket_(socket),
       thread_name_(thread_name),
-      synchronized_buffers_(synchronized_buffers) {
-}
+      synchronized_buffers_(synchronized_buffers),
+      input_(input) {}
 
 AudioDeviceThread::Thread::~Thread() {
   DCHECK(thread_.is_null());
 }
 
 void AudioDeviceThread::Thread::Start() {
   base::AutoLock auto_lock(callback_lock_);
   DCHECK(thread_.is_null());
   // This reference will be released when the thread exists.
   AddRef();
@@ skipping 42 matching lines @@
   Run();
 
   // Release the reference for the thread. Note that after this, the Thread
   // instance will most likely be deleted.
   Release();
 }
 
 void AudioDeviceThread::Thread::Run() {
   uint32 buffer_index = 0;
   while (true) {
-    uint32 pending_data = 0;
-    size_t bytes_read = socket_.Receive(&pending_data, sizeof(pending_data));
-    if (bytes_read != sizeof(pending_data))
-      break;
+    if (input_) {
+      uint32_t pending_data = 0;
+      size_t bytes_read = socket_.Receive(&pending_data, sizeof(pending_data));
+      if (bytes_read != sizeof(pending_data))
+        break;
 
-    // kuint32max is a special signal which is returned after the browser
-    // stops the output device in response to a renderer side request.
-    //
-    // Avoid running Process() for the paused signal, we still need to update
-    // the buffer index if |synchronized_buffers_| is true though.
-    //
-    // See comments in AudioOutputController::DoPause() for details on why.
-    if (pending_data != kuint32max) {
       base::AutoLock auto_lock(callback_lock_);
       if (callback_)
         callback_->Process(pending_data);
+    } else {
+      uint64_t data = 0;

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

if you don't want to use a struct, you can also use an array of two uint32_t's.

[DaleCurtis, 2015/12/01 18:12:46]

Long ago we were worried anything more than 4 bytes might lead to being
descheduled, crogers@ felt pretty strongly about this, I don't know if it's
actually an issue though.

[tommi (sloooow) - chröme, 2015/12/01 19:03:31]

Would it work to use the shared memory buffer instead?

[DaleCurtis, 2015/12/01 20:06:48]

That's what we do for input I believe.

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

Good to know. We can use the shared memory. Yes we do use it for input, with the
difference that in that case the meta data goes along with the data. Here it
goes in different directions. I'll upload a new patch with this tomorrow.

+      size_t bytes_read = socket_.Receive(&data, sizeof(data));
+      if (bytes_read != sizeof(data))
+        break;
+
+      uint32_t pending_data = static_cast<uint32_t>((data >> 32) & 0xffffffff);
+      uint32_t frames_skipped = static_cast<uint32_t>(data & 0xffffffff);
+
+      base::AutoLock auto_lock(callback_lock_);
+      if (callback_) {
+        if (frames_skipped > 0)
+          callback_->FramesSkipped(frames_skipped);
+
+        // kuint32max is a special signal which is returned after the browser
+        // stops the output device in response to a renderer side request.
+        //
+        // Avoid running Process() for the paused signal, we still need to
+        // update the buffer index if |synchronized_buffers_| is true though.
+        //
+        // See comments in AudioOutputController::DoPause() for details on why.
+        if (pending_data != kuint32max)
+          callback_->Process(pending_data);
+      }
     }
 
     // The usage of |synchronized_buffers_| differs between input and output
     // cases.
     // Input:
     // Let the other end know that we have read data, so that it can verify
     // it doesn't overwrite any data before read. The |buffer_index| value is
     // not used. For more details, see AudioInputSyncWriter::Write().
     // Output:
     // Let the other end know which buffer we just filled. The |buffer_index| is
@@ skipping 31 matching lines @@
 }
 
 AudioDeviceThread::Callback::~Callback() {}
 
 void AudioDeviceThread::Callback::InitializeOnAudioThread() {
   MapSharedMemory();
   CHECK(shared_memory_.memory());
 }
 
 }  // namespace media.