Fixes in AlsaPcmOutputStream.

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 66 matching lines @@
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
 #include "media/audio/audio_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;
 
 // 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;
 
@@ skipping 272 matching lines @@
 void AlsaPcmOutputStream::GetVolume(double* volume) {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
 
   *volume = shared_data_.volume();
 }
 
 void AlsaPcmOutputStream::OpenTask(uint32 packet_size) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // Initialize the configuration variables.
-  frames_per_packet_ = packet_size / bytes_per_frame_;
+  packet_size_ = packet_size;
+  frames_per_packet_ = packet_size_ / bytes_per_frame_;
 
   // Try to open the device.
   micros_per_packet_ =
       FramesToMicros(packet_size / bytes_per_frame_, sample_rate_);
   latency_micros_ = std::max(AlsaPcmOutputStream::kMinLatencyMicros,
                              micros_per_packet_ * 2);
   if (requested_device_name_ == kAutoSelectDevice) {
     playback_handle_ = AutoSelectDevice(latency_micros_);
     if (playback_handle_) {
       LOG(INFO) << "Auto-selected device: " << device_name_;
     }
   } else {
     device_name_ = requested_device_name_;
     playback_handle_ = OpenDevice(device_name_, channels_, latency_micros_);
   }
 
   // Finish initializing the stream if the device was opened successfully.
   if (playback_handle_ == NULL) {
     stop_stream_ = true;
   } else {
-    packet_.reset(new Packet(packet_size));
-    if (should_downmix_) {
-      bytes_per_output_frame_ = 2 * bytes_per_sample_;
+    bytes_per_output_frame_ = should_downmix_ ? 2 * bytes_per_sample_ :
+        bytes_per_frame_;
+    uint32 output_packet_size = frames_per_packet_ * bytes_per_output_frame_;
+    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_;
+    } else {
+      alsa_buffer_frames_ = buffer_size;
     }
   }
 }
 
 void AlsaPcmOutputStream::StartTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (stop_stream_) {
     return;
   }
@@ skipping 11 matching lines @@
 
   error = wrapper_->PcmPrepare(playback_handle_);
   if (error < 0 && error != -EAGAIN) {
     LOG(ERROR) << "Failure preparing stream ("
                << wrapper_->PcmName(playback_handle_) << "): "
                << wrapper_->StrError(error);
     stop_stream_ = true;
     return;
   }
 
-  // Do a best-effort pre-roll to fill the buffer.  Use integer rounding to find
-  // the maximum number of full packets that can fit into the buffer.
-  //
-  // TODO(ajwong): Handle EAGAIN.
-  const uint32 num_preroll = latency_micros_ / micros_per_packet_;
-  for (uint32 i = 0; i < num_preroll; ++i) {
-    BufferPacket(packet_.get());
-    WritePacket(packet_.get());
-  }
-
-  ScheduleNextWrite(packet_.get());
+  ScheduleNextWrite();
 }
 
 void AlsaPcmOutputStream::CloseTask() {
   // NOTE: Keep this function idempotent to handle errors that might cause
   // multiple CloseTasks to be posted.
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // Shutdown the audio device.
   if (playback_handle_ && !CloseDevice(playback_handle_)) {
     LOG(WARNING) << "Unable to close audio device. Leaking handle.";
   }
   playback_handle_ = NULL;
 
   // Release the buffer.
-  packet_.reset();
+  buffer_.reset();
 
   // Signal anything that might already be scheduled to stop.
   stop_stream_ = true;
 }
 
-void AlsaPcmOutputStream::BufferPacket(Packet* packet) {
+void AlsaPcmOutputStream::BufferPacket() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // If stopped, simulate a 0-lengthed packet.
   if (stop_stream_) {
-    packet->used = packet->size = 0;
+    buffer_->Clear();
     return;
   }
 
-  // Request more data if we don't have any cached.
-  if (packet->used >= packet->size) {
+  // Request more data if we have capacity.
+  if (buffer_->forward_capacity() > 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.
-    snd_pcm_sframes_t delay = 0;
+    snd_pcm_sframes_t delay = buffer_->forward_bytes() * bytes_per_frame_ /
+        bytes_per_output_frame_ + GetCurrentDelay() * bytes_per_output_frame_;
 
-    // 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);
-        }
-      }
-    }
-
-    packet->used = 0;
-    packet->size = shared_data_.OnMoreData(this, packet->buffer.get(),
-                                           packet->capacity, delay);
-    CHECK(packet->size <= packet->capacity) << "Data source overran buffer.";
+    media::DataBuffer* packet = new media::DataBuffer(packet_size_);
+    size_t packet_size =
+        shared_data_.OnMoreData(this, packet->GetWritableData(),
+                                packet->GetBufferSize(), delay);
+    CHECK(packet_size <= packet->GetBufferSize()) <<
+        "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
     // WritePacket.
-    DCHECK(packet->size % bytes_per_frame_ == 0);
-    packet->size = (packet->size / bytes_per_frame_) * bytes_per_frame_;
+    DCHECK(packet_size % bytes_per_frame_ == 0);
+    packet_size = (packet_size / bytes_per_frame_) * bytes_per_frame_;
 
     if (should_downmix_) {
-      if (media::FoldChannels(packet->buffer.get(),
-                              packet->size,
+      if (media::FoldChannels(packet->GetWritableData(),
+                              packet_size,
                               channels_,
                               bytes_per_sample_,
                               shared_data_.volume())) {
         // Adjust packet size for downmix.
-        packet->size =
-            packet->size / bytes_per_frame_ * bytes_per_output_frame_;
+        packet_size =
+            packet_size / bytes_per_frame_ * bytes_per_output_frame_;
       } else {
         LOG(ERROR) << "Folding failed";
       }
     } else {
       // TODO(ajwong): Handle other channel orderings.
 
       // Handle channel order for 5.0 audio.
       if (channels_ == 5) {
         if (bytes_per_sample_ == 1) {
-          Swizzle50Layout(reinterpret_cast<uint8*>(packet->buffer.get()),
-                          packet->size);
+          Swizzle50Layout(packet->GetWritableData(), packet_size);
         } else if (bytes_per_sample_ == 2) {
-          Swizzle50Layout(reinterpret_cast<int16*>(packet->buffer.get()),
-                          packet->size);
+          Swizzle50Layout(packet->GetWritableData(), packet_size);
         } else if (bytes_per_sample_ == 4) {
-          Swizzle50Layout(reinterpret_cast<int32*>(packet->buffer.get()),
-                          packet->size);
+          Swizzle50Layout(packet->GetWritableData(), packet_size);
         }
       }
 
       // Handle channel order for 5.1 audio.
       if (channels_ == 6) {
         if (bytes_per_sample_ == 1) {
-          Swizzle51Layout(reinterpret_cast<uint8*>(packet->buffer.get()),
-                          packet->size);
+          Swizzle51Layout(packet->GetWritableData(), packet_size);
         } else if (bytes_per_sample_ == 2) {
-          Swizzle51Layout(reinterpret_cast<int16*>(packet->buffer.get()),
-                          packet->size);
+          Swizzle51Layout(packet->GetWritableData(), packet_size);
         } else if (bytes_per_sample_ == 4) {
-          Swizzle51Layout(reinterpret_cast<int32*>(packet->buffer.get()),
-                          packet->size);
+          Swizzle51Layout(packet->GetWritableData(), packet_size);
         }
       }
 
-      media::AdjustVolume(packet->buffer.get(),
-                          packet->size,
+      media::AdjustVolume(packet->GetWritableData(),
+                          packet_size,
                           channels_,
                           bytes_per_sample_,
                           shared_data_.volume());
+
+      packet->SetDataSize(packet_size);
+
+      // Add the packet to the buffer.
+      buffer_->Append(packet);
     }
   }
 }
 
-void AlsaPcmOutputStream::WritePacket(Packet* packet) {
+void AlsaPcmOutputStream::WritePacket() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  CHECK(packet->size % bytes_per_output_frame_ == 0);
-
   // If the device is in error, just eat the bytes.
   if (stop_stream_) {
-    packet->used = packet->size;
+    buffer_->Clear();
     return;
   }
 
-  if (packet->used < packet->size) {
-    char* buffer_pos = packet->buffer.get() + packet->used;
-    snd_pcm_sframes_t frames = FramesInPacket(*packet, bytes_per_output_frame_);
+  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);
 
     snd_pcm_sframes_t frames_written =
-        wrapper_->PcmWritei(playback_handle_, buffer_pos, frames);
+        wrapper_->PcmWritei(playback_handle_, buffer_data, frames);
     if (frames_written < 0) {
       // Attempt once to immediately recover from EINTR,
       // EPIPE (overrun/underrun), ESTRPIPE (stream suspended).  WritePacket
       // will eventually be called again, so eventual recovery will happen if
       // muliple retries are required.
       frames_written = wrapper_->PcmRecover(playback_handle_,
                                             frames_written,
                                             kPcmRecoverIsSilent);
     }
 
     if (frames_written < 0) {
       // TODO(ajwong): Is EAGAIN the only error we want to except from stopping
       // the pcm playback?
       if (frames_written != -EAGAIN) {
         LOG(ERROR) << "Failed to write to pcm device: "
                    << wrapper_->StrError(frames_written);
         shared_data_.OnError(this, frames_written);
         stop_stream_ = true;
       }
     } else {
-      packet->used += frames_written * bytes_per_output_frame_;
+      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_);
     }
   }
 }
 
 void AlsaPcmOutputStream::WriteTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (stop_stream_) {
     return;
   }
 
-  BufferPacket(packet_.get());
-  WritePacket(packet_.get());
+  BufferPacket();
+  WritePacket();
 
-  ScheduleNextWrite(packet_.get());
+  ScheduleNextWrite();
 }
 
-void AlsaPcmOutputStream::ScheduleNextWrite(Packet* current_packet) {
+void AlsaPcmOutputStream::ScheduleNextWrite() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (stop_stream_) {
     return;
   }
 
-  // Calculate when we should have enough buffer for another packet of data.
-  // Make sure to take into consideration down-mixing.
-  uint32 frames_leftover =
-      FramesInPacket(*current_packet, bytes_per_output_frame_);
-  uint32 frames_avail_wanted =
-      (frames_leftover > 0) ? frames_leftover : frames_per_packet_;
+  // 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;
 
   // 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_);
   }
 
   // Adjust for timer resolution issues.
   if (next_fill_time_ms < kSleepErrorMilliseconds) {
     next_fill_time_ms = 0;
   } else {
     next_fill_time_ms -= kSleepErrorMilliseconds;
   }
 
   // Avoid busy looping if the data source is exhausted.
-  if (current_packet->size == 0) {
+  if (buffer_->forward_bytes() == 0) {
     next_fill_time_ms = std::max(next_fill_time_ms, kNoDataSleepMilliseconds);
   }
 
-  // Wake up sooner than should be necessary to avoid stutter.
-  next_fill_time_ms /= 2;  // TODO(fbarchard): Remove this hack.
-
   // Only schedule more reads/writes if we are still in the playing state.
   if (shared_data_.state() == kIsPlaying) {
     if (next_fill_time_ms == 0) {
       message_loop_->PostTask(
           FROM_HERE,
           NewRunnableMethod(this, &AlsaPcmOutputStream::WriteTask));
     } else {
       // TODO(ajwong): Measure the reliability of the delay interval.  Use
       // base/histogram.h.
       message_loop_->PostDelayedTask(
           FROM_HERE,
           NewRunnableMethod(this, &AlsaPcmOutputStream::WriteTask),
           next_fill_time_ms);
     }
   }
 }
 
-uint32 AlsaPcmOutputStream::FramesInPacket(const Packet& packet,
-                                           uint32 bytes_per_frame) {
-  return (packet.size - packet.used) / bytes_per_frame;
-}
-
 uint32 AlsaPcmOutputStream::FramesToMicros(uint32 frames, uint32 sample_rate) {
   return frames * base::Time::kMicrosecondsPerSecond / sample_rate;
 }
 
 uint32 AlsaPcmOutputStream::FramesToMillis(uint32 frames, uint32 sample_rate) {
   return frames * base::Time::kMillisecondsPerSecond / sample_rate;
 }
 
 std::string AlsaPcmOutputStream::FindDeviceForChannels(uint32 channels) {
   // Constants specified by the ALSA API for device hints.
@@ skipping 107 matching lines @@
   }
   if (available_frames < 0) {
     LOG(ERROR) << "Failed querying available frames. Assuming 0: "
                << wrapper_->StrError(available_frames);
     return 0;
   }
 
   return available_frames;
 }
 
+snd_pcm_sframes_t AlsaPcmOutputStream::GetCurrentDelay() {
+  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) {
+      // 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);
+      }
+    }
+    if (delay < 0)
+      delay = 0;
+  }
+  return delay;
+}
+
 snd_pcm_t* AlsaPcmOutputStream::AutoSelectDevice(unsigned int latency) {
   // For auto-selection:
   //   1) Attempt to open a device that best matches the number of channels
   //      requested.
   //   2) If that fails, attempt the "plug:" version of it incase ALSA can
   //      remap do some software conversion to make it work.
   //   3) Fallback to kDefaultDevice.
   //   4) If that fails too, try the "plug:" version of kDefaultDevice.
   //   5) Give up.
   snd_pcm_t* handle = NULL;
@@ skipping 145 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;
 }