Reland 7976047 to fix the alsa output scheduling for low latency audio.

media/audio/linux/alsa_output.cc

 // Copyright (c) 2011 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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe -- we assume that
 //   client thread - creates the object and calls the public APIs.
 //   message loop thread - executes all the internal tasks including querying
 //      the data source for more data, writing to the alsa device, and closing
@@ skipping 40 matching lines @@
 #include "media/audio/linux/alsa_util.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #include "media/audio/linux/audio_manager_linux.h"
 #include "media/base/data_buffer.h"
 #include "media/base/seekable_buffer.h"
 
 // Amount of time to wait if we've exhausted the data source.  This is to avoid
 // busy looping.
 static const uint32 kNoDataSleepMilliseconds = 10;
 
+// Mininum interval between OnMoreData() calls.
+const uint32 kMinIntervalBetweenOnMoreDataCallsInMs = 5;
+
 // According to the linux nanosleep manpage, nanosleep on linux can miss the
 // deadline by up to 10ms because the kernel timeslice is 10ms.  Give a 2x
 // buffer to compensate for the timeslice, and any additional slowdowns.
 static const uint32 kSleepErrorMilliseconds = 20;
 
 // Set to 0 during debugging if you want error messages due to underrun
 // events or other recoverable errors.
 #if defined(NDEBUG)
 static const int kPcmRecoverIsSilent = 1;
 #else
@@ skipping 269 matching lines @@
     buffer_.reset(new media::SeekableBuffer(0, output_packet_size));
 
     // Get alsa buffer size.
     snd_pcm_uframes_t buffer_size;
     snd_pcm_uframes_t period_size;
     int error = wrapper_->PcmGetParams(playback_handle_, &buffer_size,
                                        &period_size);
     if (error < 0) {
       LOG(ERROR) << "Failed to get playback buffer size from ALSA: "
                  << wrapper_->StrError(error);
-      alsa_buffer_frames_ = frames_per_packet_;
+      // Buffer size is at least twice of packet size.
+      alsa_buffer_frames_ = frames_per_packet_ * 2;

[Raymond Toy (Google), 2011/11/11 22:01:25]

Why is this twice now when it used to be the same?  Is it because our time
interval is no 5 ms instead of 10?

     } else {
       alsa_buffer_frames_ = buffer_size;
     }
   }
 }
 
 void AlsaPcmOutputStream::StartTask() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
@@ skipping 59 matching lines @@
 
   // If stopped, simulate a 0-lengthed packet.
   if (stop_stream_) {
     buffer_->Clear();
     *source_exhausted = true;
     return;
   }
 
   *source_exhausted = false;
 
-  // Request more data if we have capacity.
-  if (buffer_->forward_capacity() > buffer_->forward_bytes()) {
+  // Request more data only when we run out of data in the buffer, because
+  // WritePacket() comsumes only the current chunk of data.
+  if (!buffer_->forward_bytes()) {
     // Before making a request to source for data we need to determine the
     // delay (in bytes) for the requested data to be played.
 
     uint32 buffer_delay = buffer_->forward_bytes() * bytes_per_frame_ /
         bytes_per_output_frame_;
 
     uint32 hardware_delay = GetCurrentDelay() * bytes_per_frame_;
 
     scoped_refptr<media::DataBuffer> packet =
         new media::DataBuffer(packet_size_);
@@ skipping 148 matching lines @@
   ScheduleNextWrite(source_exhausted);
 }
 
 void AlsaPcmOutputStream::ScheduleNextWrite(bool source_exhausted) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
     return;
   }
 
-  // Next write is scheduled for the moment when half of the buffer is
-  // available.
   uint32 frames_avail_wanted = alsa_buffer_frames_ / 2;
   uint32 available_frames = GetAvailableFrames();
-  uint32 next_fill_time_ms = 0;
+  uint32 frames_in_buffer = buffer_->forward_bytes() / bytes_per_output_frame_;
 
-  // It's possible to have more frames available than what we want, in which
-  // case we'll leave our |next_fill_time_ms| at 0ms.
-  if (available_frames < frames_avail_wanted) {
-    uint32 frames_until_empty_enough = frames_avail_wanted - available_frames;
-    next_fill_time_ms =
-        FramesToMillis(frames_until_empty_enough, sample_rate_);
-  }
+  // Next write is initially scheduled for the moment when half of a packet
+  // has been played out.
+  uint32 next_fill_time_ms =
+      FramesToMillis(frames_per_packet_ / 2, sample_rate_);
 
-  // Adjust for timer resolution issues.
-  if (next_fill_time_ms < kSleepErrorMilliseconds) {
+  if (frames_in_buffer && (frames_in_buffer <= available_frames)) {
+    // There is data in the current buffer, consume them immediately if we have
+    // enough space in the soundcard.
     next_fill_time_ms = 0;
   } else {
-    next_fill_time_ms -= kSleepErrorMilliseconds;
+    // Otherwise schedule the next write for the moment when half of the alsa
+    // buffer becomes available.
+    if (available_frames < frames_avail_wanted) {
+      uint32 frames_until_empty_enough = frames_avail_wanted - available_frames;
+      next_fill_time_ms =
+          FramesToMillis(frames_until_empty_enough, sample_rate_);
+
+      // Adjust for time resolution.
+      if (next_fill_time_ms > kNoDataSleepMilliseconds)
+        next_fill_time_ms -= kNoDataSleepMilliseconds;
+
+      // Avoid back-to-back writing.
+      if (next_fill_time_ms < kMinIntervalBetweenOnMoreDataCallsInMs)
+        next_fill_time_ms = kMinIntervalBetweenOnMoreDataCallsInMs;
+    } else if ((available_frames == alsa_buffer_frames_)) {
+      // Buffer is empty, invoke next write immediately.
+      next_fill_time_ms = 0;
+    }
   }
 
   // Avoid busy looping if the data source is exhausted.
   if (source_exhausted) {
     next_fill_time_ms = std::max(next_fill_time_ms, kNoDataSleepMilliseconds);
   }
 
   // Only schedule more reads/writes if we are still in the playing state.
   if (state() == kIsPlaying) {
     if (next_fill_time_ms == 0) {
@@ skipping 241 matching lines @@
     source_callback_->OnError(this, code);
   }
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   source_callback_ = callback;
 }