Delay delivery of audio input data.

media/audio/mac/audio_input_mac.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/mac/audio_input_mac.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "media/audio/audio_manager_base.h"
@@ skipping 174 matching lines @@
     UInt32 num_packets,
     const AudioStreamPacketDescription* packet_desc) {
   DCHECK_EQ(audio_queue_, audio_queue);
   DCHECK(audio_buffer->mAudioData);
   if (!callback_) {
     // This can happen if Stop() was called without start.
     DCHECK_EQ(0U, audio_buffer->mAudioDataByteSize);
     return;
   }
 
-  if (audio_buffer->mAudioDataByteSize)
+  if (audio_buffer->mAudioDataByteSize) {
+    // The AudioQueue API may use a large internal buffer and repeatedly call us
+    // back to back once that internal buffer is filled.  When this happens the
+    // renderer client does not have enough time to read data back from the
+    // shared memory before the next write comes along.  If HandleInputBuffer()
+    // is called too frequently, Sleep() to simulate realtime input and ensure
+    // the shared memory doesn't get trampled.
+    base::TimeDelta elapsed = base::Time::Now() - last_fill_;
+    base::TimeDelta buffer_length = base::TimeDelta::FromMilliseconds(
+       audio_buffer->mAudioDataByteSize * base::Time::kMillisecondsPerSecond /
+       static_cast<float>(format_.mBytesPerFrame * format_.mSampleRate));
+    if (elapsed < buffer_length)
+      base::PlatformThread::Sleep(buffer_length - elapsed);

[Chris Rogers, 2012/12/06 23:19:55]

As we discussed in offline, this is really a stop-gap very quick-fix solution
until we can switch Pepper and speech input API over to the low-latency input
path (along with something like AudioInputResampler).

We need to add a comment here to that affect, along with a bug number.

Because, these "sleep" types of fixes are not good as permanent solutions.

I would also calculate the (buffer_length - elapsed) as a separate variable
which you can sanity check to be within a reasonable range before calling
Sleep().

[DaleCurtis, 2012/12/06 23:41:07]

Added a comment. As discussed offline, the calling pattern makes it such that
the sleep is always necessary and the value is already sanitized to some effect.

+
     callback_->OnData(this,
                       reinterpret_cast<const uint8*>(audio_buffer->mAudioData),
                       audio_buffer->mAudioDataByteSize,
                       audio_buffer->mAudioDataByteSize,
                       0.0);
+
+    last_fill_ = base::Time::Now();
+  }
   // Recycle the buffer.
   OSStatus err = QueueNextBuffer(audio_buffer);
   if (err != noErr) {
     if (err == kAudioQueueErr_EnqueueDuringReset) {
       // This is the error you get if you try to enqueue a buffer and the
       // queue has been closed. Not really a problem if indeed the queue
       // has been closed.
       // TODO(joth): PCMQueueOutAudioOutputStream uses callback_ to provide an
       // extra guard for this situation, but it seems to introduce more
       // complications than it solves (memory barrier issues accessing it from
       // multiple threads, looses the means to indicate OnClosed to client).
       // Should determine if we need to do something equivalent here.
       return;
     }
     HandleError(err);
   }
 }
 
 }  // namespace media