Assume pending buffered bytes is zero when ALSA has underrun.

media/audio/linux/alsa_output.cc

 // Copyright (c) 2010 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
 //
 // The AlsaPcmOutputStream object's internal state is accessed by two threads:
 //
 //   client thread - creates the object and calls the public APIs.
 //   message loop thread - executes all the internal tasks including querying
@@ skipping 456 matching lines @@
   // If stopped, simulate a 0-lengthed packet.
   if (stop_stream_) {
     packet->used = packet->size = 0;
     return;
   }
 
   // Request more data if we don't have any cached.
   if (packet->used >= packet->size) {
     // Before making a request to source for data. We need to determine the
     // delay (in bytes) for the requested data to be played.
-    snd_pcm_sframes_t delay;
-    int error = wrapper_->PcmDelay(playback_handle_, &delay);
-    if (error < 0) {
-      error = wrapper_->PcmRecover(playback_handle_,
-                                   error,
-                                   kPcmRecoverIsSilent);
-      if (error < 0) {
-        LOG(ERROR) << "Failed querying delay: " << wrapper_->StrError(error);
+    snd_pcm_sframes_t delay = 0;
+
+    // Don't query ALSA's delay if we have underrun since it'll be jammed at
+    // some non-zero value and potentially even negative!
+    if (wrapper_->PcmState(playback_handle_) != SND_PCM_STATE_XRUN) {
+      int error = wrapper_->PcmDelay(playback_handle_, &delay);
+      if (error >= 0) {
+        // Convert frames to bytes, but watch out for those negatives!
+        delay = (delay < 0 ? 0 : delay) * bytes_per_output_frame_;
+      } else {
+        // Assume a delay of zero and attempt to recover the device.
+        delay = 0;
+        error = wrapper_->PcmRecover(playback_handle_,
+                                     error,
+                                     kPcmRecoverIsSilent);
+        if (error < 0) {
+          LOG(ERROR) << "Failed querying delay: " << wrapper_->StrError(error);
+        }
       }
-
-      // TODO(hclam): If we cannot query the delay, we may want to stop
-      // the playback and report an error.
-      delay = 0;
-    } else {
-      delay *= bytes_per_output_frame_;
     }
 
     packet->used = 0;
     packet->size = shared_data_.OnMoreData(this, packet->buffer.get(),
                                            packet->capacity, delay);
     CHECK(packet->size <= packet->capacity) << "Data source overran buffer.";
 
     // This should not happen, but incase it does, drop any trailing bytes
     // that aren't large enough to make a frame.  Without this, packet writing
     // may stall because the last few bytes in the packet may never get used by
@@ skipping 456 matching lines @@
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::SharedData::set_source_callback(
     AudioSourceCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), state_transition_loop_);
   AutoLock l(lock_);
   source_callback_ = callback;
 }