Rename AlsaRawmidi to AlsaCard and include the count of midi devices instead of duplicating

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 <stdlib.h>
 #include <algorithm>
 #include <string>
@@ skipping 225 matching lines @@
       FROM_HERE, base::Bind(&MidiManagerAlsa::SendMidiData,
                             base::Unretained(this), port_index, data),
       delay);
 
   // Acknowledge send.
   send_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&MidiManagerClient::AccumulateMidiBytesSent,
                             base::Unretained(client), data.size()));
 }
 
-MidiManagerAlsa::AlsaRawmidi::AlsaRawmidi(const MidiManagerAlsa* outer,
-                                          const std::string& alsa_name,
-                                          const std::string& alsa_longname,
-                                          const std::string& alsa_driver,
-                                          int card_index)
+MidiManagerAlsa::AlsaCard::AlsaCard(const MidiManagerAlsa* outer,
+                                    const std::string& alsa_name,
+                                    const std::string& alsa_longname,
+                                    const std::string& alsa_driver,
+                                    int card_index,
+                                    int midi_count)
     : alsa_name_(alsa_name),
       alsa_longname_(alsa_longname),
-      alsa_driver_(alsa_driver) {
+      alsa_driver_(alsa_driver),
+      midi_count_(midi_count) {
   // Get udev properties if available.
   std::string vendor;
   std::string vendor_from_database;
 
 #if defined(USE_UDEV)
   const std::string sysname = base::StringPrintf("card%i", card_index);
   device::ScopedUdevDevicePtr udev_device(
       device::udev_device_new_from_subsystem_sysname(
           outer->udev_.get(), kSoundClass, sysname.c_str()));
 
@@ skipping 26 matching lines @@
 
   // Get the usb interface number.
   usb_interface_num_ =
       device::UdevDeviceGetPropertyValue(udev_device.get(), kUsbInterfaceNum);
 #endif  // defined(USE_UDEV)
 
   manufacturer_ = ExtractManufacturerString(
       vendor, vendor_id_, vendor_from_database, alsa_name, alsa_longname);
 }
 
-MidiManagerAlsa::AlsaRawmidi::~AlsaRawmidi() {
+MidiManagerAlsa::AlsaCard::~AlsaCard() {
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::alsa_name() const {
+const std::string MidiManagerAlsa::AlsaCard::alsa_name() const {
   return alsa_name_;
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::alsa_longname() const {
+const std::string MidiManagerAlsa::AlsaCard::alsa_longname() const {
   return alsa_longname_;
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::manufacturer() const {
+const std::string MidiManagerAlsa::AlsaCard::manufacturer() const {
   return manufacturer_;
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::alsa_driver() const {
+const std::string MidiManagerAlsa::AlsaCard::alsa_driver() const {
   return alsa_driver_;
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::path() const {
+const std::string MidiManagerAlsa::AlsaCard::path() const {
   return path_;
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::bus() const {
+const std::string MidiManagerAlsa::AlsaCard::bus() const {
   return bus_;
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::vendor_id() const {
+const std::string MidiManagerAlsa::AlsaCard::vendor_id() const {
   return vendor_id_;
 }
 
-const std::string MidiManagerAlsa::AlsaRawmidi::id() const {
+const std::string MidiManagerAlsa::AlsaCard::id() const {
   std::string id = vendor_id_;
   if (!model_id_.empty())
     id += ":" + model_id_;
   if (!usb_interface_num_.empty())
     id += ":" + usb_interface_num_;
   return id;
 }
 
+const int MidiManagerAlsa::AlsaCard::midi_count() const {
+  return midi_count_;
+}
+
 // static
-std::string MidiManagerAlsa::AlsaRawmidi::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 86 matching lines @@
 //               mapping and just use a UUID or other random string.
 //               http://crbug.com/465320
 std::string MidiManagerAlsa::AlsaPortMetadata::OpaqueKey() const {
   uint8 hash[crypto::kSHA256Length];
   crypto::SHA256HashString(JSONValue(), &hash, sizeof(hash));
   return base::HexEncode(&hash, sizeof(hash));
 }
 
 // TODO(agoode): Add a client->card/rawmidi mapping to the kernel to avoid
 //               needing to probe in this way.
-ScopedVector<MidiManagerAlsa::AlsaRawmidi> MidiManagerAlsa::AllAlsaRawmidis() {
-  ScopedVector<AlsaRawmidi> devices;
+ScopedVector<MidiManagerAlsa::AlsaCard> MidiManagerAlsa::AllMidiCards() {
+  ScopedVector<AlsaCard> devices;
   snd_ctl_card_info_t* card;
   snd_hwdep_info_t* hwdep;
   snd_ctl_card_info_alloca(&card);
   snd_hwdep_info_alloca(&hwdep);
   for (int card_index = -1; !snd_card_next(&card_index) && card_index >= 0;) {
+    int midi_count = 0;
     const std::string id = base::StringPrintf("hw:CARD=%i", card_index);
     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);
       continue;
     }
     err = snd_ctl_card_info(handle, card);
     if (err != 0) {
       VLOG(1) << "snd_ctl_card_info fails: " << snd_strerror(err);
       snd_ctl_close(handle);
       continue;
     }
     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).
     for (int device = -1;
-         !snd_ctl_rawmidi_next_device(handle, &device) && device >= 0;) {
-      devices.push_back(
-          new AlsaRawmidi(this, name, longname, driver, card_index));
-    }
+         !snd_ctl_rawmidi_next_device(handle, &device) && device >= 0;)
+      ++midi_count;
 
-    // Count any hwdep synths that become MIDI devices.
+    // 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;) {
       snd_ctl_hwdep_info(handle, hwdep);
       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)
-        devices.push_back(
-            new AlsaRawmidi(this, name, longname, driver, card_index));
+        ++midi_count;
     }
+
+    if (midi_count > 0)
+      devices.push_back(
+          new AlsaCard(this, name, longname, driver, card_index, midi_count));
     snd_ctl_close(handle);
   }
 
   return devices.Pass();
 }
 
 void MidiManagerAlsa::EnumeratePorts() {
-  ScopedVector<AlsaRawmidi> devices = AllAlsaRawmidis();
+  ScopedVector<AlsaCard> cards = AllMidiCards();
+  std::vector<const AlsaCard*> devices;
+  for (const auto* card : cards) {
+    // Insert 1 AlsaCard per number of MIDI devices.
+    for (int n = 0; n < card->midi_count(); ++n)
+      devices.push_back(card);
+  }
 
   snd_seq_port_subscribe_t* subs;
   snd_seq_port_subscribe_alloca(&subs);
 
   int in_client_id = snd_seq_client_id(in_client_);
 
   // Enumerate all clients.
   snd_seq_client_info_t* client_info;
   snd_seq_client_info_alloca(&client_info);
   snd_seq_port_info_t* port_info;
@@ skipping 17 matching lines @@
 
     std::string manufacturer;
     std::string driver;
     std::string path;
     std::string bus;
     std::string vendor_id;
     std::string id;
     std::string card_name;
     std::string card_longname;
 
-    // Join kernel clients against the list of AlsaRawmidis.
+    // Join kernel clients against the list of AlsaCards.
     // In the current ALSA kernel implementation, kernel clients match the
-    // kernel devices in the same order, for devices with client_id over
+    // kernel devices in the same order, for clients with client_id over
     // kMinimumClientIdForCards.
     if ((snd_seq_client_info_get_type(client_info) == SND_SEQ_KERNEL_CLIENT) &&
         (current_device < devices.size()) &&
         (client_id >= kMinimumClientIdForCards)) {
-      const AlsaRawmidi* device = devices[current_device];
+      const AlsaCard* device = devices[current_device];
       manufacturer = device->manufacturer();
       driver = device->alsa_driver();
       path = device->path();
       bus = device->bus();
       vendor_id = device->vendor_id();
       id = device->id();
       card_name = device->alsa_name();
       card_longname = device->alsa_longname();
       current_device++;
     }
@@ skipping 121 matching lines @@
   }
 
   // Handle announce events.
   if (event->source.client == SND_SEQ_CLIENT_SYSTEM &&
       event->source.port == SND_SEQ_PORT_SYSTEM_ANNOUNCE) {
     switch (event->type) {
       case SND_SEQ_EVENT_CLIENT_START:
         // TODO(agoode): rescan hardware devices.
         break;
 
+      case SND_SEQ_EVENT_PORT_START:
+        // TODO(agoode): add port.
+        break;
+
       case SND_SEQ_EVENT_CLIENT_EXIT:
         // Check for disconnection of our "out" client. This means "shut down".
         if (event->data.addr.client == out_client_id_)
           return;
 
         // TODO(agoode): remove all ports for a client.
         break;
 
-      case SND_SEQ_EVENT_PORT_START:
-        // TODO(agoode): add port.
-        break;
-
       case SND_SEQ_EVENT_PORT_EXIT:
         // TODO(agoode): remove port.
         break;
     }
+  } else {
+    ProcessSingleEvent(event, timestamp);
   }
 
-  ProcessSingleEvent(event, timestamp);
-
   // Do again.
   ScheduleEventLoop();
 }
 
 void MidiManagerAlsa::ProcessSingleEvent(snd_seq_event_t* event,
                                          double timestamp) {
-  std::map<int, uint32>::iterator source_it =
-      source_map_.find(AddrToInt(&event->source));
+  auto source_it = source_map_.find(AddrToInt(&event->source));
   if (source_it != source_map_.end()) {
     uint32 source = source_it->second;
     if (event->type == SND_SEQ_EVENT_SYSEX) {
       // Special! Variable-length sysex.
       ReceiveMidiData(source, static_cast<const uint8*>(event->data.ext.ptr),
                       event->data.ext.len, timestamp);
     } else {
       // Otherwise, decode this and send that on.
       unsigned char buf[12];
       long count = snd_midi_event_decode(decoder_, buf, sizeof(buf), event);
       if (count <= 0) {
         if (count != -ENOENT) {
           // ENOENT means that it's not a MIDI message, which is not an
           // error, but other negative values are errors for us.
           VLOG(1) << "snd_midi_event_decoder fails " << snd_strerror(count);
           // TODO(agoode): Record this failure.
         }
       } else {
         ReceiveMidiData(source, buf, count, timestamp);
       }
     }
   }
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace media