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)

[jeffbrown, 2015/11/04 20:33:42]

This to me looks like an opportunity to define a new class to abstract platform
audio sink concerns.

[johngro, 2015/11/06 20:22:06]

Acknowledged.

We should talk sometime.  I'd like to understand more about your approach to
doing this.  

+  // 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; }
+
+  audio::AlsaOutput* alsa_out =
+    static_cast<audio::AlsaOutput*>(audio_out.get());

[jeffbrown, 2015/11/04 20:33:42]

Did you "git cl format"?  I think this is supposed to be 4 spaces or reflow into
something equally hideous.

[johngro, 2015/11/06 20:22:06]

Done.

Solved this a different way.  A long time ago, I used to have the output manager
in just mojo::media, and the audio:: scope was needed, but it no longer is. 
Removing that makes stuff fit on one line.

Oddly enough, I cannot find clear guidance in the public style guide about what
to do if an assignment (or any other operation) exceeds the 80 col length.  I'm
not sure what git CL format chooses to do, but AFAICT there are not a lot of
strict rules here besides use your best judgement and be consistent.

+  DCHECK(alsa_out);
+
+  LpcmMediaTypeDetailsPtr config(LpcmMediaTypeDetails::New());
+  DCHECK(config);

[jeffbrown, 2015/11/04 20:33:42]

Might be able to omit this DCHECK.  Seems like the sort of thing the Mojo
bindings should do internally whenever New() fails.  (I really hate checking the
result of new...)

[johngro, 2015/11/06 20:22:06]

The problem here is that this is not a call to operator new().  It's a call to a
function someone wrote called New, which (in theory) could have extra side
effects.  IOW - its great that the mojo/chrome global new has been overloaded to
DCHECK if allocation fails, but this function could succeed to allocate and
still return NULL.

In this case, however, I know that this is machine generated code which should
Never Do This, so I'll remove the check.

+  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