MidiManagerAlsa: Enable manufacturer again, now with hotplug

media/midi/midi_manager_alsa.cc

 // Copyright 2014 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/midi/midi_manager_alsa.h"
 
 #include <alsa/asoundlib.h>
 #include <poll.h>
 #include <stdlib.h>
 #include <algorithm>
@@ skipping 19 matching lines @@
 namespace midi {
 
 namespace {
 
 // Per-output buffer. This can be smaller, but then large sysex messages
 // will be (harmlessly) split across multiple seq events. This should
 // not have any real practical effect, except perhaps to slightly reorder
 // realtime messages with respect to sysex.
 const size_t kSendBufferSize = 256;
 
+// Minimum client id for which we will have ALSA card devices for. When we
+// are searching for card devices (used to get the path, id, and manufacturer),
+// we don't want to get confused by kernel clients that do not have a card.
+// See seq_clientmgr.c in the ALSA code for this.
+// TODO(agoode): Add proper client -> card export from the kernel to avoid
+//               hardcoding.
+const int kMinimumClientIdForCards = 16;
+
 // ALSA constants.
 const char kAlsaHw[] = "hw";
 
 // udev constants.
 const char kUdev[] = "udev";
 const char kUdevSubsystemSound[] = "sound";
 const char kUdevPropertySoundInitialized[] = "SOUND_INITIALIZED";
 const char kUdevActionChange[] = "change";
 const char kUdevActionRemove[] = "remove";
 
+const char kUdevIdVendor[] = "ID_VENDOR";
+const char kUdevIdVendorEnc[] = "ID_VENDOR_ENC";
+const char kUdevIdVendorFromDatabase[] = "ID_VENDOR_FROM_DATABASE";
+const char kUdevIdVendorId[] = "ID_VENDOR_ID";
+const char kUdevIdModelId[] = "ID_MODEL_ID";
+const char kUdevIdBus[] = "ID_BUS";
+const char kUdevIdPath[] = "ID_PATH";
+const char kUdevIdUsbInterfaceNum[] = "ID_USB_INTERFACE_NUM";
+const char kUdevIdSerialShort[] = "ID_SERIAL_SHORT";
+
+const char kSysattrVendorName[] = "vendor_name";
+const char kSysattrVendor[] = "vendor";
+const char kSysattrModel[] = "model";
+const char kSysattrGuid[] = "guid";
+
+const char kCardSyspath[] = "/card";
+
 // Constants for the capabilities we search for in inputs and outputs.
 // See http://www.alsa-project.org/alsa-doc/alsa-lib/seq.html.
 const unsigned int kRequiredInputPortCaps =
     SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
 const unsigned int kRequiredOutputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
 
 const unsigned int kCreateOutputPortCaps =
     SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_NO_EXPORT;
 const unsigned int kCreateInputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_NO_EXPORT;
 const unsigned int kCreatePortType =
     SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION;
 
 int AddrToInt(int client, int port) {
   return (client << 8) | port;
 }
 
+bool IsCardKernelClient(snd_seq_client_type_t type, int client_id) {
+  return (type == SND_SEQ_KERNEL_CLIENT) &&
+         (client_id >= kMinimumClientIdForCards);
+}
+
+// TODO(agoode): Move this to device/udev_linux.
+const std::string UdevDeviceGetPropertyOrSysattr(
+    struct udev_device* udev_device,
+    const char* property_key,
+    const char* sysattr_key) {
+  // First try the property.
+  std::string value =
+      device::UdevDeviceGetPropertyValue(udev_device, property_key);
+
+  // If no property, look for sysattrs and walk up the parent devices too.
+  while (value.empty() && udev_device) {
+    value = device::UdevDeviceGetSysattrValue(udev_device, sysattr_key);
+    udev_device = device::udev_device_get_parent(udev_device);
+  }
+  return value;
+}
+
+int GetCardNumber(udev_device* dev) {
+  const char* syspath = device::udev_device_get_syspath(dev);
+  if (!syspath)
+    return -1;
+
+  std::string syspath_str(syspath);
+  size_t i = syspath_str.rfind(kCardSyspath);
+  if (i == std::string::npos)
+    return -1;
+
+  int number;
+  if (!base::StringToInt(syspath_str.substr(i + strlen(kCardSyspath)), &number))
+    return -1;
+  return number;
+}
+
 void SetStringIfNonEmpty(base::DictionaryValue* value,
                          const std::string& path,
                          const std::string& in_value) {
   if (!in_value.empty())
     value->SetString(path, in_value);
 }
 
 }  // namespace
 
 MidiManagerAlsa::MidiManagerAlsa()
     : in_client_(NULL),
       out_client_(NULL),
       out_client_id_(-1),
       in_port_id_(-1),
+      alsa_cards_deleter_(&alsa_cards_),
+      alsa_card_midi_count_(0),
       decoder_(NULL),
       udev_(device::udev_new()),
       send_thread_("MidiSendThread"),
       event_thread_("MidiEventThread"),
       event_thread_shutdown_(false) {
   // Initialize decoder.
   snd_midi_event_new(0, &decoder_);
   snd_midi_event_no_status(decoder_, 1);
 }
 
@@ skipping 396 matching lines @@
       break;
     case MidiPort::Type::kOutput:
       web_port_index = num_output_ports_++;
       break;
   }
   port->set_web_port_index(web_port_index);
   ports()->push_back(port.Pass());
   return web_port_index;
 }
 
-MidiManagerAlsa::AlsaSeqState::AlsaSeqState() : clients_deleter_(&clients_) {
+MidiManagerAlsa::AlsaSeqState::AlsaSeqState()
+    : clients_deleter_(&clients_), kernel_client_count_(0) {
 }
 
 MidiManagerAlsa::AlsaSeqState::~AlsaSeqState() {
 }
 
 void MidiManagerAlsa::AlsaSeqState::ClientStart(int client_id,
                                                 const std::string& client_name,
                                                 snd_seq_client_type_t type) {
   ClientExit(client_id);
   clients_[client_id] = new Client(client_name, type);
+  if (IsCardKernelClient(type, client_id))
+    ++kernel_client_count_;
 }
 
 bool MidiManagerAlsa::AlsaSeqState::ClientStarted(int client_id) {
   return clients_.find(client_id) != clients_.end();
 }
 
 void MidiManagerAlsa::AlsaSeqState::ClientExit(int client_id) {
   auto it = clients_.find(client_id);
   if (it != clients_.end()) {
+    if (IsCardKernelClient(it->second->type(), client_id))
+      --kernel_client_count_;
     delete it->second;
     clients_.erase(it);
   }
 }
 
 void MidiManagerAlsa::AlsaSeqState::PortStart(
     int client_id,
     int port_id,
     const std::string& port_name,
     MidiManagerAlsa::AlsaSeqState::PortDirection direction,
@@ skipping 12 matching lines @@
 
 snd_seq_client_type_t MidiManagerAlsa::AlsaSeqState::ClientType(
     int client_id) const {
   auto it = clients_.find(client_id);
   if (it == clients_.end())
     return SND_SEQ_USER_CLIENT;
   return it->second->type();
 }
 
 scoped_ptr<MidiManagerAlsa::TemporaryMidiPortState>
-MidiManagerAlsa::AlsaSeqState::ToMidiPortState() {
+MidiManagerAlsa::AlsaSeqState::ToMidiPortState(const AlsaCardMap& alsa_cards) {
   scoped_ptr<MidiManagerAlsa::TemporaryMidiPortState> midi_ports(
       new TemporaryMidiPortState);
-  // TODO(agoode): Use information from udev as well.
+  // TODO(agoode): Use more information from udev, to allow hardware matching.
+  // See http://crbug.com/486471.
+  auto card_it = alsa_cards.begin();
 
+  int card_midi_device = -1;
   for (const auto& client_pair : clients_) {
     int client_id = client_pair.first;
     const auto& client = client_pair.second;
 
     // Get client metadata.
     const std::string client_name = client->name();
     std::string manufacturer;
     std::string driver;
     std::string path;
     std::string id;
     std::string serial;
     std::string card_name;
     std::string card_longname;
     int midi_device = -1;
 
+    if (IsCardKernelClient(client->type(), client_id)) {
+      auto& card = card_it->second;
+      if (card_midi_device == -1)
+        card_midi_device = 0;
+
+      manufacturer = card->manufacturer();
+      midi_device = card_midi_device;
+
+      ++card_midi_device;
+      if (card_midi_device >= card->midi_device_count()) {
+        card_midi_device = -1;
+        ++card_it;
+      }
+    }
+
     for (const auto& port_pair : *client) {
       int port_id = port_pair.first;
       const auto& port = port_pair.second;
 
       if (port->midi()) {
         std::string version;
         if (!driver.empty()) {
           version = driver + " / ";
         }
         version +=
@@ skipping 75 matching lines @@
 MidiManagerAlsa::AlsaSeqState::Client::PortMap::const_iterator
 MidiManagerAlsa::AlsaSeqState::Client::begin() const {
   return ports_.begin();
 }
 
 MidiManagerAlsa::AlsaSeqState::Client::PortMap::const_iterator
 MidiManagerAlsa::AlsaSeqState::Client::end() const {
   return ports_.end();
 }
 
+MidiManagerAlsa::AlsaCard::AlsaCard(udev_device* dev,
+                                    const std::string& alsa_name,
+                                    const std::string& alsa_longname,
+                                    const std::string& alsa_driver,
+                                    int midi_device_count)
+    : alsa_name_(alsa_name),
+      alsa_longname_(alsa_longname),
+      alsa_driver_(alsa_driver),
+      midi_device_count_(midi_device_count) {
+  // Try to get the vendor string. Sometimes it is encoded.
+  std::string vendor = device::UdevDecodeString(
+      device::UdevDeviceGetPropertyValue(dev, kUdevIdVendorEnc));
+  // Sometimes it is not encoded.
+  if (vendor.empty())
+    vendor =
+        UdevDeviceGetPropertyOrSysattr(dev, kUdevIdVendor, kSysattrVendorName);
+  // Also get the vendor string from the hardware database.
+  std::string vendor_from_database =
+      device::UdevDeviceGetPropertyValue(dev, kUdevIdVendorFromDatabase);
+
+  // Get the device path.
+  path_ = device::UdevDeviceGetPropertyValue(dev, kUdevIdPath);
+  // Get the bus.
+  bus_ = device::UdevDeviceGetPropertyValue(dev, kUdevIdBus);
+
+  // Get the "serial" number. (Often untrustable or missing.)
+  serial_ =
+      UdevDeviceGetPropertyOrSysattr(dev, kUdevIdSerialShort, kSysattrGuid);
+
+  // Get the vendor id, by either property or sysattr.
+  vendor_id_ =
+      UdevDeviceGetPropertyOrSysattr(dev, kUdevIdVendorId, kSysattrVendor);
+  // Get the model id, by either property or sysattr.
+  model_id_ =
+      UdevDeviceGetPropertyOrSysattr(dev, kUdevIdModelId, kSysattrModel);
+  // Get the usb interface number.
+  usb_interface_num_ =
+      device::UdevDeviceGetPropertyValue(dev, kUdevIdUsbInterfaceNum);
+  manufacturer_ = ExtractManufacturerString(
+      vendor, vendor_id_, vendor_from_database, alsa_name, alsa_longname);
+}
+
+MidiManagerAlsa::AlsaCard::~AlsaCard() {
+}
+
 // static
-std::string MidiManagerAlsa::ExtractManufacturerString(
+std::string MidiManagerAlsa::AlsaCard::ExtractManufacturerString(
     const std::string& udev_id_vendor,
     const std::string& udev_id_vendor_id,
     const std::string& udev_id_vendor_from_database,
     const std::string& alsa_name,
     const std::string& alsa_longname) {
   // Let's try to determine the manufacturer. Here is the ordered preference
   // in extraction:
   //  1. Vendor name from the hardware device string, from udev properties
   //     or sysattrs.
   //  2. Vendor name from the udev database (property ID_VENDOR_FROM_DATABASE).
@@ skipping 239 matching lines @@
                                               kUdevPropertySoundInitialized))
     return;
 
   // Get the action. If no action, then we are doing first time enumeration
   // and the device is treated as new.
   const char* action = device::udev_device_get_action(dev);
   if (!action)
     action = kUdevActionChange;
 
   if (strcmp(action, kUdevActionChange) == 0) {
-    // TODO(agoode): add
+    AddCard(dev);
+    // Generate Web MIDI events.
+    UpdatePortStateAndGenerateEvents();
   } else if (strcmp(action, kUdevActionRemove) == 0) {
-    // TODO(agoode): remove
+    RemoveCard(GetCardNumber(dev));
+    // Generate Web MIDI events.
+    UpdatePortStateAndGenerateEvents();
   }
 }
 
+void MidiManagerAlsa::AddCard(udev_device* dev) {
+  int number = GetCardNumber(dev);
+  if (number == -1)
+    return;
+
+  RemoveCard(number);
+
+  snd_ctl_card_info_t* card;
+  snd_hwdep_info_t* hwdep;
+  snd_ctl_card_info_alloca(&card);
+  snd_hwdep_info_alloca(&hwdep);
+  const std::string id = base::StringPrintf("hw:CARD=%i", number);
+  snd_ctl_t* handle;
+  int err = snd_ctl_open(&handle, id.c_str(), 0);
+  if (err != 0) {
+    VLOG(1) << "snd_ctl_open fails: " << snd_strerror(err);
+    return;
+  }
+  err = snd_ctl_card_info(handle, card);
+  if (err != 0) {
+    VLOG(1) << "snd_ctl_card_info fails: " << snd_strerror(err);
+    snd_ctl_close(handle);
+    return;
+  }
+  std::string name = snd_ctl_card_info_get_name(card);
+  std::string longname = snd_ctl_card_info_get_longname(card);
+  std::string driver = snd_ctl_card_info_get_driver(card);
+
+  // Count rawmidi devices (not subdevices).
+  int midi_count = 0;
+  for (int device = -1;
+       !snd_ctl_rawmidi_next_device(handle, &device) && device >= 0;)
+    ++midi_count;
+
+  // Count any hwdep synths that become MIDI devices outside of rawmidi.
+  //
+  // Explanation:
+  // Any kernel driver can create an ALSA client (visible to us).
+  // With modern hardware, only rawmidi devices do this. Kernel
+  // drivers create rawmidi devices and the rawmidi subsystem makes
+  // the seq clients. But the OPL3 driver is special, it does not
+  // make a rawmidi device but a seq client directly. (This is the
+  // only one to worry about in the kernel code, as of 2015-03-23.)
+  //
+  // OPL3 is very old (but still possible to get in new
+  // hardware). It is unlikely that new drivers would not use
+  // rawmidi and defeat our heuristic.
+  //
+  // Longer term, support should be added in the kernel to expose a
+  // direct link from card->client (or client->card) so that all
+  // these heuristics will be obsolete.  Once that is there, we can
+  // assume our old heuristics will work on old kernels and the new
+  // robust code will be used on new. Then we will not need to worry
+  // about changes to kernel internals breaking our code.
+  // See the TODO above at kMinimumClientIdForCards.
+  for (int device = -1;
+       !snd_ctl_hwdep_next_device(handle, &device) && device >= 0;) {
+    err = snd_ctl_hwdep_info(handle, hwdep);
+    if (err != 0) {
+      VLOG(1) << "snd_ctl_hwdep_info fails: " << snd_strerror(err);
+      continue;
+    }
+    snd_hwdep_iface_t iface = snd_hwdep_info_get_iface(hwdep);
+    if (iface == SND_HWDEP_IFACE_OPL2 || iface == SND_HWDEP_IFACE_OPL3 ||
+        iface == SND_HWDEP_IFACE_OPL4)
+      ++midi_count;
+  }
+  snd_ctl_close(handle);
+
+  if (midi_count > 0)
+    alsa_cards_[number] = new AlsaCard(dev, name, longname, driver, midi_count);
+  alsa_card_midi_count_ += midi_count;
+}
+
+void MidiManagerAlsa::RemoveCard(int number) {
+  auto it = alsa_cards_.find(number);
+  if (it == alsa_cards_.end())
+    return;
+
+  alsa_card_midi_count_ -= it->second->midi_device_count();
+  delete it->second;
+  alsa_cards_.erase(it);
+}
+
 void MidiManagerAlsa::UpdatePortStateAndGenerateEvents() {
+  if (alsa_card_midi_count_ != alsa_seq_state_.kernel_client_count())

[Takashi Toyoshima, 2015/05/11 12:32:04]

Can you add some comments to know what this check means?

[Adam Goode, 2015/05/11 15:17:25]

Yes. I also renamed the variables to be more clear.

+    return;
+
   // Generate new port state.
-  auto new_port_state = alsa_seq_state_.ToMidiPortState();
+  auto new_port_state = alsa_seq_state_.ToMidiPortState(alsa_cards_);
 
   // Disconnect any connected old ports that are now missing.
   for (auto* old_port : port_state_) {
     if (old_port->connected() &&
         (new_port_state->FindConnected(*old_port) == new_port_state->end())) {
       old_port->set_connected(false);
       uint32 web_port_index = old_port->web_port_index();
       switch (old_port->type()) {
         case MidiPort::Type::kInput:
           source_map_.erase(
@@ skipping 187 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media