Simplified AudioOutputStream interface.

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 214 matching lines @@
                                          AudioManagerLinux* manager,
                                          MessageLoop* message_loop)
     : shared_data_(MessageLoop::current()),
       requested_device_name_(device_name),
       pcm_format_(alsa_util::BitsToFormat(params.bits_per_sample)),
       channels_(params.channels),
       sample_rate_(params.sample_rate),
       bytes_per_sample_(params.bits_per_sample / 8),
       bytes_per_frame_(channels_ * params.bits_per_sample / 8),
       should_downmix_(false),
-      latency_micros_(0),
-      micros_per_packet_(0),
+      packet_size_(params.GetPacketSize()),
+      micros_per_packet_(FramesToMicros(
+          params.samples_per_packet, sample_rate_)),
+      latency_micros_(std::max(AlsaPcmOutputStream::kMinLatencyMicros,
+                               micros_per_packet_ * 2)),
       bytes_per_output_frame_(bytes_per_frame_),
       alsa_buffer_frames_(0),
       stop_stream_(false),
       wrapper_(wrapper),
       manager_(manager),
       playback_handle_(NULL),
-      frames_per_packet_(0),
+      frames_per_packet_(packet_size_ / bytes_per_frame_),
       client_thread_loop_(MessageLoop::current()),
       message_loop_(message_loop) {
 
   // Sanity check input values.
   if ((params.sample_rate > kAlsaMaxSampleRate) || (params.sample_rate <= 0)) {
     LOG(WARNING) << "Unsupported audio frequency.";
     shared_data_.TransitionTo(kInError);
   }
 
   if (AudioParameters::AUDIO_PCM_LINEAR != params.format) {
@@ skipping 10 matching lines @@
 AlsaPcmOutputStream::~AlsaPcmOutputStream() {
   InternalState state = shared_data_.state();
   DCHECK(state == kCreated || state == kIsClosed || state == kInError);
 
   // TODO(ajwong): Ensure that CloseTask has been called and the
   // playback handle released by DCHECKing that playback_handle_ is NULL.
   // Currently, because of Bug 18217, there is a race condition on destruction
   // where the stream is not always stopped and closed, causing this to fail.
 }
 
-bool AlsaPcmOutputStream::Open(uint32 packet_size) {
+bool AlsaPcmOutputStream::Open() {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
 
-  DCHECK_EQ(0U, packet_size % bytes_per_frame_)
-      << "Buffers should end on a frame boundary. Frame size: "
-      << bytes_per_frame_;
-
   if (shared_data_.state() == kInError) {
     return false;
   }
 
   if (!shared_data_.CanTransitionTo(kIsOpened)) {
     NOTREACHED() << "Invalid state: " << shared_data_.state();
     return false;
   }
 
   // We do not need to check if the transition was successful because
   // CanTransitionTo() was checked above, and it is assumed that this
   // object's public API is only called on one thread so the state cannot
   // transition out from under us.
   shared_data_.TransitionTo(kIsOpened);
   message_loop_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &AlsaPcmOutputStream::OpenTask, packet_size));
+      NewRunnableMethod(this, &AlsaPcmOutputStream::OpenTask));
 
   return true;
 }
 
 void AlsaPcmOutputStream::Close() {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
 
   // Sanity check that the transition occurs correctly.  It is safe to
   // continue anyways because all operations for closing are idempotent.
   if (shared_data_.TransitionTo(kIsClosed) != kIsClosed) {
     NOTREACHED() << "Unable to transition Closed.";
   }
 
-  // Signal our successful close, and disassociate the source callback.
-  shared_data_.OnClose(this);
-  shared_data_.set_source_callback(NULL);
-
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AlsaPcmOutputStream::CloseTask));
 
   // Signal to the manager that we're closed and can be removed.  Since
   // we just posted a CloseTask to the message loop, we won't be deleted
   // immediately, but it will happen soon afterwards.
   manager()->ReleaseOutputStream(this);
 }
 
 void AlsaPcmOutputStream::Start(AudioSourceCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
 
   CHECK(callback);
 
   shared_data_.set_source_callback(callback);
 
   // Only post the task if we can enter the playing state.
   if (shared_data_.TransitionTo(kIsPlaying) == kIsPlaying) {
     message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &AlsaPcmOutputStream::StartTask));
   }
 }
 
 void AlsaPcmOutputStream::Stop() {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
 
+  // Reset the callback, so that it is not called anymore.
+  shared_data_.set_source_callback(NULL);
+
   shared_data_.TransitionTo(kIsStopped);
 }
 
 void AlsaPcmOutputStream::SetVolume(double volume) {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
 
   shared_data_.set_volume(static_cast<float>(volume));
 }
 
 void AlsaPcmOutputStream::GetVolume(double* volume) {
   DCHECK_EQ(MessageLoop::current(), client_thread_loop_);
 
   *volume = shared_data_.volume();
 }
 
-void AlsaPcmOutputStream::OpenTask(uint32 packet_size) {
+void AlsaPcmOutputStream::OpenTask() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
-  // Initialize the configuration variables.
-  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_)
       VLOG(1) << "Auto-selected device: " << device_name_;
   } else {
     device_name_ = requested_device_name_;
     playback_handle_ = alsa_util::OpenPlaybackDevice(wrapper_,
                                                      device_name_.c_str(),
                                                      channels_, sample_rate_,
                                                      pcm_format_,
@@ skipping 533 matching lines @@
     AudioOutputStream* stream, uint8* dest, uint32 max_size,
     AudioBuffersState buffers_state) {
   AutoLock l(lock_);
   if (source_callback_) {
     return source_callback_->OnMoreData(stream, dest, max_size, buffers_state);
   }
 
   return 0;
 }
 
-void AlsaPcmOutputStream::SharedData::OnClose(AudioOutputStream* stream) {
-  AutoLock l(lock_);
-  if (source_callback_) {
-    source_callback_->OnClose(stream);
-  }
-}
-
 void AlsaPcmOutputStream::SharedData::OnError(AudioOutputStream* stream,
                                               int code) {
   AutoLock l(lock_);
   if (source_callback_) {
     source_callback_->OnError(stream, code);
   }
 }
 
 // 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;
 }