Add an ALSA output to the motown audio server.

services/media/audio/audio_output_manager.cc

 // Copyright 2015 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.
 
 #include <string>
 
 #include "services/media/audio/audio_output.h"
 #include "services/media/audio/audio_output_manager.h"
 #include "services/media/audio/audio_server_impl.h"
 #include "services/media/audio/audio_track_to_output_link.h"
 #include "services/media/audio/platform/generic/throttle_output.h"
+#if defined(OS_LINUX)
+#include "services/media/audio/platform/linux/alsa_output.h"
+#endif
 
 namespace mojo {
 namespace media {
 namespace audio {
 
 static constexpr size_t  THREAD_POOL_SZ = 2;
 static const std::string THREAD_PREFIX("AudioMixer");
 
 AudioOutputManager::AudioOutputManager(AudioServerImpl* server)
   : server_(server) {
 }
 
 AudioOutputManager::~AudioOutputManager() {
   Shutdown();
   DCHECK_EQ(outputs_.size(), 0u);
   DCHECK(!thread_pool_);
 }
 
+void AudioOutputManager::CreateAlsaOutputs() {
+#if defined(OS_LINUX)
+  // TODO(johngro): Do better than this.  If we really want to support
+  // Linux/ALSA as a platform, we should be creating one output for each
+  // physical output in the system, matching our configuration to the physical
+  // output's configuration, and disabling resampling at the ALSA level.
+  //
+  // If we could own the output entirely and bypass the mixer to achieve lower
+  // latency, that would be even better.
+  AudioOutputPtr audio_out(audio::AlsaOutput::New(this));
+  if (!audio_out) { return; }
+
+  AlsaOutput* alsa_out = static_cast<AlsaOutput*>(audio_out.get());
+  DCHECK(alsa_out);
+
+  LpcmMediaTypeDetailsPtr config(LpcmMediaTypeDetails::New());
+  config->frames_per_second = 48000;
+  config->samples_per_frame = 2;
+  config->sample_format = LpcmSampleFormat::SIGNED_16;
+
+  if (alsa_out->Configure(config.Pass()) != MediaResult::OK) {
+    return;
+  }
+
+  outputs_.emplace(audio_out);
+#endif
+}
+
 MediaResult AudioOutputManager::Init() {
   // Step #1: Initialize the mixing thread pool.
   //
   // TODO(johngro): make the thread pool size proportional to the maximum
   // number of cores available in the system.
   //
   // TODO(johngro): make sure that the threads are executed at an elevated
   // priority, not the default priority.
   thread_pool_ = new base::SequencedWorkerPool(THREAD_POOL_SZ, THREAD_PREFIX);
 
   // Step #2: Instantiate all of the built-in audio output devices.
   //
   // TODO(johngro): Come up with a better way of doing this based on our
   // platform.  Right now, we just create some hardcoded default outputs and
   // leave it at that.
   outputs_.emplace(audio::ThrottleOutput::New(this));
+  CreateAlsaOutputs();
 
   // Step #3: Being monitoring for plug/unplug events for pluggable audio
   // output devices.
   //
   // TODO(johngro): Implement step #3.  Right now, the details are behind
   // hot-plug monitoring are TBD, so the feature is not implemented.
 
   // Step #4: Attempt to initialize each of the audio outputs we have created,
   // then kick off the callback engine for each of them.
   for (auto iter = outputs_.begin(); iter != outputs_.end(); ) {
@@ skipping 85 matching lines @@
 void AudioOutputManager::ScheduleMessageLoopTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   DCHECK(server_);
   server_->ScheduleMessageLoopTask(from_here, task);
 }
 
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo