Output device enumeration for Alsa, plus unit test.

media/audio/linux/audio_manager_linux.cc

 // Copyright (c) 2012 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 "media/audio/linux/audio_manager_linux.h"
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
 
 // Default sample rate for input and output streams.
 static const int kDefaultSampleRate = 48000;
 
 // Since "default", "pulse" and "dmix" devices are virtual devices mapped to
 // real devices, we remove them from the list to avoiding duplicate counting.
 // In addition, note that we support no more than 2 channels for recording,
 // hence surround devices are not stored in the list.
 static const char* kInvalidAudioInputDevices[] = {
   "default",
+  "dmix",
   "null",
   "pulse",
-  "dmix",
   "surround",
 };
 
 enum LinuxAudioIO {
   kPulse,
   kAlsa,
   kCras,
   kAudioIOMax  // Must always be last!
 };
 
@@ skipping 40 matching lines @@
   Shutdown();
 }
 
 void AudioManagerLinux::ShowAudioInputSettings() {
   ShowLinuxAudioInputSettings();
 }
 
 void AudioManagerLinux::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
-  GetAlsaAudioInputDevices(device_names);
+  GetAlsaAudioDevices(kStreamCapture, device_names);
+}
+
+void AudioManagerLinux::GetAudioOutputDeviceNames(
+    media::AudioDeviceNames* device_names) {
+  DCHECK(device_names->empty());
+  GetAlsaAudioDevices(kStreamPlayback, device_names);
 }
 
 AudioParameters AudioManagerLinux::GetInputStreamParameters(
     const std::string& device_id) {
   static const int kDefaultInputBufferSize = 1024;
 
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
       kDefaultSampleRate, 16, kDefaultInputBufferSize);
 }
 
-void AudioManagerLinux::GetAlsaAudioInputDevices(
+void AudioManagerLinux::GetAlsaAudioDevices(
+    StreamType type,
     media::AudioDeviceNames* device_names) {
   // Constants specified by the ALSA API for device hints.
   static const char kPcmInterfaceName[] = "pcm";
   int card = -1;
 
   // Loop through the sound cards to get ALSA device hints.
   while (!wrapper_->CardNext(&card) && card >= 0) {
     void** hints = NULL;
     int error = wrapper_->DeviceNameHint(card, kPcmInterfaceName, &hints);
     if (!error) {
-      GetAlsaDevicesInfo(hints, device_names);
+      GetAlsaDevicesInfo(type, hints, device_names);
 
       // Destroy the hints now that we're done with it.
       wrapper_->DeviceNameFreeHint(hints);
     } else {
-      DLOG(WARNING) << "GetAudioInputDevices: unable to get device hints: "
+      DLOG(WARNING) << "GetAlsaAudioDevices: unable to get device hints: "
                     << wrapper_->StrError(error);
     }
   }
 }
 
 void AudioManagerLinux::GetAlsaDevicesInfo(
-    void** hints, media::AudioDeviceNames* device_names) {
+    AudioManagerLinux::StreamType type,
+    void** hints,
+    media::AudioDeviceNames* device_names) {
   static const char kIoHintName[] = "IOID";
   static const char kNameHintName[] = "NAME";
   static const char kDescriptionHintName[] = "DESC";
-  static const char kOutputDevice[] = "Output";
+
+  const char* unwanted_device_type = UnwantedDeviceTypeWhenEnumerating(type);
 
   for (void** hint_iter = hints; *hint_iter != NULL; hint_iter++) {
-    // Only examine devices that are input capable.  Valid values are
+    // Only examine devices of the right type.  Valid values are
     // "Input", "Output", and NULL which means both input and output.
     scoped_ptr_malloc<char> io(wrapper_->DeviceNameGetHint(*hint_iter,
                                                            kIoHintName));
-    if (io != NULL && strcmp(kOutputDevice, io.get()) == 0)
+    if (io != NULL && strcmp(unwanted_device_type, io.get()) == 0)
       continue;
 
-    // Found an input device, prepend the default device since we always want
-    // it to be on the top of the list for all platforms. And there is no
-    // duplicate counting here since it is only done if the list is still empty.
-    // Note, pulse has exclusively opened the default device, so we must open
-    // the device via the "default" moniker.
+    // Found a device, prepend the default device since we always want
+    // it to be on the top of the list for all platforms. And there is
+    // no duplicate counting here since it is only done if the list is
+    // still empty.  Note, pulse has exclusively opened the default
+    // device, so we must open the device via the "default" moniker.
     if (device_names->empty()) {
       device_names->push_front(media::AudioDeviceName(
           AudioManagerBase::kDefaultDeviceName,
           AudioManagerBase::kDefaultDeviceId));
     }
 
     // Get the unique device name for the device.
     scoped_ptr_malloc<char> unique_device_name(
         wrapper_->DeviceNameGetHint(*hint_iter, kNameHintName));
 
     // Find out if the device is available.
-    if (IsAlsaDeviceAvailable(unique_device_name.get())) {
+    if (IsAlsaDeviceAvailable(type, unique_device_name.get())) {
       // Get the description for the device.
       scoped_ptr_malloc<char> desc(wrapper_->DeviceNameGetHint(
           *hint_iter, kDescriptionHintName));
 
       media::AudioDeviceName name;
       name.unique_id = unique_device_name.get();
       if (desc) {
         // Use the more user friendly description as name.
         // Replace '\n' with '-'.
         char* pret = strchr(desc.get(), '\n');
         if (pret)
           *pret = '-';
         name.device_name = desc.get();
       } else {
         // Virtual devices don't necessarily have descriptions.
         // Use their names instead.
         name.device_name = unique_device_name.get();
       }
 
       // Store the device information.
       device_names->push_back(name);
     }
   }
 }
 
-bool AudioManagerLinux::IsAlsaDeviceAvailable(const char* device_name) {
+bool AudioManagerLinux::IsAlsaDeviceAvailable(

[tommi (sloooow) - chröme, 2013/09/04 14:32:51]

nit: looks like this could also be a static utility function

[Jói, 2013/09/04 15:32:22]

Becuase of the use of StreamType this has the same tradeoffs as with
UnwantedDeviceTypeWhenEnumerating.

I made both this and UnwantedDeviceTypeWhenEnumerating static though, no need to
waste a good this pointer.

+    AudioManagerLinux::StreamType type,
+    const char* device_name) {
   if (!device_name)
     return false;
 
-  // Check if the device is in the list of invalid devices.
-  for (size_t i = 0; i < arraysize(kInvalidAudioInputDevices); ++i) {
-    if (strncmp(kInvalidAudioInputDevices[i], device_name,
-                strlen(kInvalidAudioInputDevices[i])) == 0)
-      return false;
+  if (type == kStreamCapture) {
+    // Check if the device is in the list of invalid devices.
+    for (size_t i = 0; i < arraysize(kInvalidAudioInputDevices); ++i) {
+      if (strncmp(kInvalidAudioInputDevices[i], device_name,

[tommi (sloooow) - chröme, 2013/09/04 14:32:51]

Don't we also have to check that the length of the strings are equal or is the
intent to do prefix matching?

also as an absolute-ocd-nit, it would be nice to use the arraysize() approach
like you do below for the kInvalidAudioInputDevices[] array (in which case it'd
be an array of a string+length type).

[Jói, 2013/09/04 15:32:22]

Prefix matching is the intent. I added a comment.
I already tried that :)  Can't make it a fixed-size two-dimensional array since
the strings are of different lengths.

[tommi (sloooow) - chröme, 2013/09/04 16:43:52]

Great. thanks.
ah, I see.  What about something like:

#define INVALID_AUDIO_DEVICE_ENTRY(entry) \
    { entry, arraysize(entry) - 1}
struct {
  const char* name;
  const int length;
} const kInvalidAudioInputDevices[] = {
  INVALID_AUDIO_DEVICE_ENTRY("default"),
  INVALID_AUDIO_DEVICE_ENTRY("foo"),
  ...
};
#undef INVALID_AUDIO_DEVICE_ENTRY

+                  strlen(kInvalidAudioInputDevices[i])) == 0)
+        return false;
+    }
+
+    return true;
+  } else {
+    DCHECK_EQ(kStreamPlayback, type);
+    // We prefer the device type that maps straight to hardware but
+    // goes through software conversion if needed (e.g. incompatible
+    // sample rate).
+    // TODO(joi): Should we prefer "hw" instead?
+    static const char kDeviceTypeDesired[] = "plughw";
+    return strncmp(kDeviceTypeDesired,
+                   device_name,
+                   arraysize(kDeviceTypeDesired) - 1) == 0;
   }
-
-  return true;
 }
 
-bool AudioManagerLinux::HasAnyAlsaAudioDevice(StreamType stream) {
+const char* AudioManagerLinux::UnwantedDeviceTypeWhenEnumerating(
+    AudioManagerLinux::StreamType wanted_type) {
+  return wanted_type == kStreamPlayback ? "Input" : "Output";
+}
+
+bool AudioManagerLinux::HasAnyAlsaAudioDevice(
+    AudioManagerLinux::StreamType stream) {
   static const char kPcmInterfaceName[] = "pcm";
   static const char kIoHintName[] = "IOID";
-  const char* kNotWantedDevice =
-      (stream == kStreamPlayback ? "Input" : "Output");
   void** hints = NULL;
   bool has_device = false;
   int card = -1;
 
   // Loop through the sound cards.
   // Don't use snd_device_name_hint(-1,..) since there is a access violation
   // inside this ALSA API with libasound.so.2.0.0.
   while (!wrapper_->CardNext(&card) && (card >= 0) && !has_device) {
     int error = wrapper_->DeviceNameHint(card, kPcmInterfaceName, &hints);
     if (!error) {
       for (void** hint_iter = hints; *hint_iter != NULL; hint_iter++) {
         // Only examine devices that are |stream| capable.  Valid values are
         // "Input", "Output", and NULL which means both input and output.
         scoped_ptr_malloc<char> io(wrapper_->DeviceNameGetHint(*hint_iter,
                                                                kIoHintName));
-        if (io != NULL && strcmp(kNotWantedDevice, io.get()) == 0)
+        const char* unwanted_type = UnwantedDeviceTypeWhenEnumerating(stream);
+        if (io != NULL && strcmp(unwanted_type, io.get()) == 0)
           continue;  // Wrong type, skip the device.
 
         // Found an input device.
         has_device = true;
         break;
       }
 
       // Destroy the hints now that we're done with it.
       wrapper_->DeviceNameFreeHint(hints);
       hints = NULL;
@@ skipping 99 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("Media.LinuxAudioIO", kPulse, kAudioIOMax);
     return manager;
   }
 #endif
 
   UMA_HISTOGRAM_ENUMERATION("Media.LinuxAudioIO", kAlsa, kAudioIOMax);
   return new AudioManagerLinux();
 }
 
 }  // namespace media