Fix Linux audio playback for short files

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
 //
 // 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 377 matching lines @@
   }
 }
 
 void AlsaPcmOutputStream::StartTask() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
     return;
   }
 
+  if (shared_data_.state() != kIsPlaying) {
+    return;
+  }
+
+  // Before starting, the buffer might have audio from previous user of this
+  // device.
+  buffer_->Clear();

[scherkus (not reviewing), 2011/04/11 18:22:39]

final question: are we sure this won't clobber any previous sound?

[davejcool, 2011/04/13 01:24:05]

If there is something in buffer_, it must be from the previous usage of this
stream, and is invalid.  Only after starting is the first ScheduleNextWrite()
called, so the buffer_ can't have anything we need in it yet for the stream
currently starting, but it could have something leftover from the previous usage
of this stream.

At this time we expect the buffer to be zero length, if it's not, it will throw
off our computation of the hardware_delay in BufferPacket().  

+
   // When starting again, drop all packets in the device and prepare it again
   // incase we are restarting from a pause state and need to flush old data.
   int error = wrapper_->PcmDrop(playback_handle_);
   if (error < 0 && error != -EAGAIN) {
     LOG(ERROR) << "Failure clearing playback device ("
                << wrapper_->PcmName(playback_handle_) << "): "
                << wrapper_->StrError(error);
     stop_stream_ = true;
     return;
   }
@@ skipping 123 matching lines @@
 
 void AlsaPcmOutputStream::WritePacket() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // If the device is in error, just eat the bytes.
   if (stop_stream_) {
     buffer_->Clear();
     return;
   }
 
+  if (shared_data_.state() == kIsStopped) {
+    return;
+  }
+
   CHECK_EQ(buffer_->forward_bytes() % bytes_per_output_frame_, 0u);
 
   const uint8* buffer_data;
   size_t buffer_size;
   if (buffer_->GetCurrentChunk(&buffer_data, &buffer_size)) {
     buffer_size = buffer_size - (buffer_size % bytes_per_output_frame_);
     snd_pcm_sframes_t frames = buffer_size / bytes_per_output_frame_;
 
     DCHECK_GT(frames, 0);
 
@@ skipping 21 matching lines @@
     } else {
       if (frames_written > frames) {
         LOG(WARNING)
             << "snd_pcm_writei() has written more frame that we asked.";
         frames_written = frames;
       }
 
       // Seek forward in the buffer after we've written some data to ALSA.
       buffer_->Seek(frames_written * bytes_per_output_frame_);
     }
+  } else {
+    // If nothing left to write and playback hasn't started yet, start it now.
+    // This ensures that shorter sounds will still play.
+    if ((wrapper_->PcmState(playback_handle_) == SND_PCM_STATE_PREPARED) &&
+        GetCurrentDelay() > 0) {
+      wrapper_->PcmStart(playback_handle_);
+    }
   }
 }
 
 void AlsaPcmOutputStream::WriteTask() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
     return;
   }
 
+  if (shared_data_.state() == kIsStopped) {
+    return;
+  }
+
   bool source_exhausted;
   BufferPacket(&source_exhausted);
   WritePacket();
 
   ScheduleNextWrite(source_exhausted);
 }
 
 void AlsaPcmOutputStream::ScheduleNextWrite(bool source_exhausted) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
@@ skipping 311 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_);
   base::AutoLock l(lock_);
   source_callback_ = callback;
 }