Share one thread between all AudioOutputControllers instead of creating one per stream.

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 358 matching lines @@
   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) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  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);
@@ skipping 25 matching lines @@
       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_);
+  DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
     return;
   }
 
   // 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 ("
@@ skipping 11 matching lines @@
     stop_stream_ = true;
     return;
   }
 
   ScheduleNextWrite(false);
 }
 
 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_);
+  DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // 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.
   buffer_.reset();
 
   // Signal anything that might already be scheduled to stop.
   stop_stream_ = true;
 }
 
 void AlsaPcmOutputStream::BufferPacket(bool* source_exhausted) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // If stopped, simulate a 0-lengthed packet.
   if (stop_stream_) {
     buffer_->Clear();
     *source_exhausted = true;
     return;
   }
 
   *source_exhausted = false;
 
@@ skipping 67 matching lines @@
       packet->SetDataSize(packet_size);
       // Add the packet to the buffer.
       buffer_->Append(packet);
     } else {
       *source_exhausted = true;
     }
   }
 }
 
 void AlsaPcmOutputStream::WritePacket() {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // If the device is in error, just eat the bytes.
   if (stop_stream_) {
     buffer_->Clear();
     return;
   }
 
   CHECK_EQ(buffer_->forward_bytes() % bytes_per_output_frame_, 0u);
 
   const uint8* buffer_data;
@@ skipping 32 matching lines @@
         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_);
+  DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
     return;
   }
 
   bool source_exhausted;
   BufferPacket(&source_exhausted);
   WritePacket();
 
   ScheduleNextWrite(source_exhausted);
 }
 
 void AlsaPcmOutputStream::ScheduleNextWrite(bool source_exhausted) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  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;
@@ skipping 132 matching lines @@
   if (error < 0) {
     LOG(ERROR) << "Error closing audio device (" << name << "): "
                << wrapper_->StrError(error);
     return false;
   }
 
   return true;
 }
 
 snd_pcm_sframes_t AlsaPcmOutputStream::GetAvailableFrames() {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (stop_stream_) {
     return 0;
   }
 
   // Find the number of frames queued in the sound device.
   snd_pcm_sframes_t available_frames =
       wrapper_->PcmAvailUpdate(playback_handle_);
   if (available_frames  < 0) {
     available_frames = wrapper_->PcmRecover(playback_handle_,
@@ skipping 167 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;
 }