Use seq instead of rawmidi for MidiManagerAlsa

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>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "media/midi/midi_port_info.h"
 
 namespace media {
 
 namespace {
 
-const size_t kReceiveBufferSize = 4096;
-const unsigned short kPollEventMask = POLLIN | POLLERR | POLLNVAL;
+const size_t kSendBufferSize = 64;
+const unsigned int kRequiredInputPortCaps =
+    SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;

[Takashi Toyoshima, 2014/05/07 04:38:28]

Having a link to http://www.alsa-project.org/alsa-doc/alsa-lib/seq.html or
something as a comment seems to be useful.

[Adam Goode, 2014/05/08 03:00:53]

Done.

+const unsigned int kRequiredOutputPortCaps =
+    SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
+
+int AddrToInt(const snd_seq_addr_t* addr) {
+  return (addr->client << 8) | addr->port;
+}
 
 }  // namespace
 
-class MidiManagerAlsa::MidiDeviceInfo
-    : public base::RefCounted<MidiDeviceInfo> {
- public:
-  MidiDeviceInfo(MidiManagerAlsa* manager,
-                 const std::string& bus_id,
-                 snd_ctl_card_info_t* card,
-                 const snd_rawmidi_info_t* midi,
-                 int device) {
-    opened_ = !snd_rawmidi_open(&midi_in_, &midi_out_, bus_id.c_str(), 0);
-    if (!opened_)
-      return;
-
-    const std::string id = base::StringPrintf("%s:%d", bus_id.c_str(), device);
-    const std::string name = snd_rawmidi_info_get_name(midi);
-    // We assume that card longname is in the format of
-    // "<manufacturer> <name> at <bus>". Otherwise, we give up to detect
-    // a manufacturer name here.
-    std::string manufacturer;
-    const std::string card_name = snd_ctl_card_info_get_longname(card);
-    size_t name_index = card_name.find(name);
-    if (std::string::npos != name_index)
-      manufacturer = card_name.substr(0, name_index - 1);
-    const std::string version =
-        base::StringPrintf("%s / ALSA library version %d.%d.%d",
-                           snd_ctl_card_info_get_driver(card),
-                           SND_LIB_MAJOR, SND_LIB_MINOR, SND_LIB_SUBMINOR);
-    port_info_ = MidiPortInfo(id, manufacturer, name, version);
-  }
-
-  void Send(MidiManagerClient* client, const std::vector<uint8>& data) {
-    ssize_t result = snd_rawmidi_write(
-        midi_out_, reinterpret_cast<const void*>(&data[0]), data.size());
-    if (static_cast<size_t>(result) != data.size()) {
-      // TODO(toyoshim): Handle device disconnection.
-      VLOG(1) << "snd_rawmidi_write fails: " << strerror(-result);
-    }
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&MidiManagerClient::AccumulateMidiBytesSent,
-                   base::Unretained(client), data.size()));
-  }
-
-  // Read input data from a MIDI input device which is ready to read through
-  // the ALSA library. Called from EventLoop() and read data will be sent to
-  // blink through MIDIManager base class.
-  size_t Receive(uint8* data, size_t length) {
-    return snd_rawmidi_read(midi_in_, reinterpret_cast<void*>(data), length);
-  }
-
-  const MidiPortInfo& GetMidiPortInfo() const { return port_info_; }
-
-  // Get the number of descriptors which is required to call poll() on the
-  // device. The ALSA library always returns 1 here now, but it may be changed
-  // in the future.
-  int GetPollDescriptorsCount() {
-    return snd_rawmidi_poll_descriptors_count(midi_in_);
-  }
-
-  // Following API initializes pollfds for polling the device, and returns the
-  // number of descriptors they are initialized. It must be the same value with
-  // snd_rawmidi_poll_descriptors_count().
-  int SetupPollDescriptors(struct pollfd* pfds, unsigned int count) {
-    return snd_rawmidi_poll_descriptors(midi_in_, pfds, count);
-  }
-
-  unsigned short GetPollDescriptorsRevents(struct pollfd* pfds) {
-    unsigned short revents;
-    snd_rawmidi_poll_descriptors_revents(midi_in_,
-                                         pfds,
-                                         GetPollDescriptorsCount(),
-                                         &revents);
-    return revents;
-  }
-
-  bool IsOpened() const { return opened_; }
-
- private:
-  friend class base::RefCounted<MidiDeviceInfo>;
-  virtual ~MidiDeviceInfo() {
-    if (opened_) {
-      snd_rawmidi_close(midi_in_);
-      snd_rawmidi_close(midi_out_);
-    }
-  }
-
-  bool opened_;
-  MidiPortInfo port_info_;
-  snd_rawmidi_t* midi_in_;
-  snd_rawmidi_t* midi_out_;
-
-  DISALLOW_COPY_AND_ASSIGN(MidiDeviceInfo);
-};
-
 MidiManagerAlsa::MidiManagerAlsa()
-    : send_thread_("MidiSendThread"),
-      event_thread_("MidiEventThread") {
-  for (size_t i = 0; i < arraysize(pipe_fd_); ++i)
-    pipe_fd_[i] = -1;
+    : in_client_(NULL),
+      out_client_(NULL),
+      out_client_id_(-1),
+      in_port_(-1),
+      decoder_(NULL),
+      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);
 }
 
 void MidiManagerAlsa::StartInitialization() {

[Takashi Toyoshima, 2014/05/07 04:38:28]

Now that StartInitialization() can be performed asynchronously, can you run
following initialization code on the event thread? It will be like EventReset()
running via PostTask at the end of this function.

StartInitialization() is called on the I/O thread. Blocking calls and heavy
processing like encryption are forbidden on the thread. Actually, my original
code is using snd_ctl_open() that may call open(), and it was not recommended.

[Adam Goode, 2014/05/08 03:00:53]

I don't think I can do this on the event thread, since the destructor runs on
the browser thread. Actually this code already looks wrong because
Thread::Start() and Thread::Stop() have to be called from the same thread, and
we are calling Start() on the I/O thread here and Stop() on the browser thread.

What I think I want is the other half to StartInitialization
(StartDeinitialization?), called from the I/O thread. Then I can move some of
the destructor code there. Or is there a better way?

[Takashi Toyoshima, 2014/05/16 19:31:52]

Hum... you are right. And other MidiManager* implementations have the same
problem.
Bad news is that I/O thread is already stopped when ~MidiManagerAlsa is called.
Can you add "crbug.com/374341" to your comment at line 60?

[Adam Goode, 2014/05/25 04:57:05]

Done.

-  // Enumerate only hardware MIDI devices because software MIDIs running in
-  // the browser process is not secure.
-  snd_ctl_card_info_t* card;
-  snd_rawmidi_info_t* midi_out;
-  snd_rawmidi_info_t* midi_in;
-  snd_ctl_card_info_alloca(&card);
-  snd_rawmidi_info_alloca(&midi_out);
-  snd_rawmidi_info_alloca(&midi_in);
-  for (int index = -1; !snd_card_next(&index) && index >= 0; ) {
-    const std::string id = base::StringPrintf("hw:CARD=%i", 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);
+  // Create client handles.
+  int err = snd_seq_open(&in_client_, "hw", SND_SEQ_OPEN_INPUT, 0);
+  if (err != 0) {
+    VLOG(1) << "snd_seq_open fails: " << snd_strerror(err);
+    // Nothing to close, just return failure.
+    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+  }
+  int in_client_id = snd_seq_client_id(in_client_);
+  err = snd_seq_open(&out_client_, "hw", SND_SEQ_OPEN_OUTPUT, 0);
+  if (err != 0) {
+    VLOG(1) << "snd_seq_open fails: " << snd_strerror(err);
+    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+  }
+  out_client_id_ = snd_seq_client_id(out_client_);
+
+  // Name the clients.
+  err = snd_seq_set_client_name(in_client_, "Google Chrome (input)");

[Takashi Toyoshima, 2014/05/07 04:38:28]

Can you remove "Google" from the strings?
_mac.cc also used "Google Chrome", but I changed it recently since this code is
also used by Chromium, or other derived projects. So, containing "Google" is not
correct. I think using "Chrome" instead of "Chromium" is ok since Chromium
project uses the word "Chrome" here and there, e.g. binary name for Linux is
chrome.

[Adam Goode, 2014/05/08 03:00:53]

Done.

+  if (err != 0) {
+    VLOG(1) << "snd_seq_set_client_name fails: " << snd_strerror(err);
+    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+  }
+  err = snd_seq_set_client_name(out_client_, "Google Chrome (output)");

[Takashi Toyoshima, 2014/05/07 04:38:28]

ditto

[Adam Goode, 2014/05/08 03:00:53]

Done.

+  if (err != 0) {
+    VLOG(1) << "snd_seq_set_client_name fails: " << snd_strerror(err);
+    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+  }
+
+  // Create input port.
+  in_port_ = snd_seq_create_simple_port(in_client_, NULL,
+                                        SND_SEQ_PORT_CAP_WRITE |
+                                        SND_SEQ_PORT_CAP_NO_EXPORT,
+                                        SND_SEQ_PORT_TYPE_MIDI_GENERIC |
+                                        SND_SEQ_PORT_TYPE_APPLICATION);
+  if (in_port_ < 0) {
+    VLOG(1) << "snd_seq_create_simple_port fails: " << snd_strerror(in_port_);
+    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+  }
+
+  // Subscribe to the announce port.
+  snd_seq_port_subscribe_t* subs;
+  snd_seq_port_subscribe_alloca(&subs);
+  snd_seq_addr_t announce_sender;
+  snd_seq_addr_t announce_dest;
+  announce_sender.client = SND_SEQ_CLIENT_SYSTEM;
+  announce_sender.port = SND_SEQ_PORT_SYSTEM_ANNOUNCE;
+  announce_dest.client = in_client_id;
+  announce_dest.port = in_port_;
+  snd_seq_port_subscribe_set_sender(subs, &announce_sender);
+  snd_seq_port_subscribe_set_dest(subs, &announce_dest);
+  err = snd_seq_subscribe_port(in_client_, subs);
+  if (err != 0) {
+    VLOG(1) << "snd_seq_subscribe_port on the announce port fails: "
+            << snd_strerror(err);
+    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+  }
+
+  // Enumerate all ports in all clients.
+  snd_seq_client_info_t* client_info;
+  snd_seq_client_info_alloca(&client_info);
+  snd_seq_port_info_t* port_info;
+  snd_seq_port_info_alloca(&port_info);
+
+  snd_seq_client_info_set_client(client_info, -1);
+  // Enumerate clients.
+  uint32 current_input = 0;
+  while (!snd_seq_query_next_client(in_client_, client_info)) {
+    int client_id = snd_seq_client_info_get_client(client_info);
+    if ((client_id == in_client_id) || (client_id == out_client_id_)) {
+      // Skip our own clients.
       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;
-    }
-    for (int device = -1;
-        !snd_ctl_rawmidi_next_device(handle, &device) && device >= 0; ) {
-      bool output;
-      bool input;
-      snd_rawmidi_info_set_device(midi_out, device);
-      snd_rawmidi_info_set_subdevice(midi_out, 0);
-      snd_rawmidi_info_set_stream(midi_out, SND_RAWMIDI_STREAM_OUTPUT);
-      output = snd_ctl_rawmidi_info(handle, midi_out) == 0;
-      snd_rawmidi_info_set_device(midi_in, device);
-      snd_rawmidi_info_set_subdevice(midi_in, 0);
-      snd_rawmidi_info_set_stream(midi_in, SND_RAWMIDI_STREAM_INPUT);
-      input = snd_ctl_rawmidi_info(handle, midi_in) == 0;
-      if (!output && !input)
-        continue;
-      scoped_refptr<MidiDeviceInfo> port = new MidiDeviceInfo(
-          this, id, card, output ? midi_out : midi_in, device);
-      if (!port->IsOpened()) {
-        VLOG(1) << "MidiDeviceInfo open fails";
-        continue;
+    snd_seq_port_info_set_client(port_info, client_id);
+    snd_seq_port_info_set_port(port_info, -1);
+    // Enumerate ports.
+    while (!snd_seq_query_next_port(in_client_, port_info)) {
+      unsigned int port_type = snd_seq_port_info_get_type(port_info);
+      if (port_type & SND_SEQ_PORT_TYPE_MIDI_GENERIC) {
+        const snd_seq_addr_t* addr = snd_seq_port_info_get_addr(port_info);
+        const std::string name = snd_seq_port_info_get_name(port_info);
+        const std::string id = base::StringPrintf("%d:%d %s",
+                                                  addr->client,
+                                                  addr->port,
+                                                  name.c_str());
+
+        unsigned int caps = snd_seq_port_info_get_capability(port_info);
+        if ((caps & kRequiredInputPortCaps) == kRequiredInputPortCaps) {
+          // Subscribe to this port.
+          const snd_seq_addr_t* sender = snd_seq_port_info_get_addr(port_info);
+          snd_seq_addr_t dest;
+          dest.client = snd_seq_client_id(in_client_);
+          dest.port = in_port_;
+          snd_seq_port_subscribe_set_sender(subs, sender);
+          snd_seq_port_subscribe_set_dest(subs, &dest);
+          err = snd_seq_subscribe_port(in_client_, subs);
+          if (err != 0) {
+            VLOG(1) << "snd_seq_subscribe_port fails: " << snd_strerror(err);
+          } else {
+            source_map_[AddrToInt(sender)] = current_input++;
+            AddInputPort(MidiPortInfo(id, "", name, ""));
+          }
+        }
+        if ((caps & kRequiredOutputPortCaps) == kRequiredOutputPortCaps) {
+          // Create a port for us to send on.
+          int out_port =
+              snd_seq_create_simple_port(out_client_, NULL,
+                                         SND_SEQ_PORT_CAP_READ |
+                                         SND_SEQ_PORT_CAP_NO_EXPORT,
+                                         SND_SEQ_PORT_TYPE_MIDI_GENERIC |
+                                         SND_SEQ_PORT_TYPE_APPLICATION);
+          if (out_port < 0) {
+            VLOG(1) << "snd_seq_create_simple_port fails: "
+                    << snd_strerror(out_port);
+            // Skip this output port for now.
+            continue;
+          }
+
+          // Activate port subscription.
+          snd_seq_addr_t sender;
+          const snd_seq_addr_t* dest = snd_seq_port_info_get_addr(port_info);
+          sender.client = snd_seq_client_id(out_client_);
+          sender.port = out_port;
+          snd_seq_port_subscribe_set_sender(subs, &sender);
+          snd_seq_port_subscribe_set_dest(subs, dest);
+          err = snd_seq_subscribe_port(out_client_, subs);
+          if (err != 0) {
+            VLOG(1) << "snd_seq_subscribe_port fails: " << snd_strerror(err);
+            snd_seq_delete_simple_port(out_client_, out_port);
+          } else {
+            snd_midi_event_t* encoder;
+            snd_midi_event_new(kSendBufferSize, &encoder);
+            encoders_.push_back(encoder);
+            out_ports_.push_back(out_port);
+            AddOutputPort(MidiPortInfo(id, "", name, ""));

[Takashi Toyoshima, 2014/05/07 04:38:28]

Can you try to get a manufacturer string and generate a version string as I did
for USB devices?
We want to use the same name and manufacturer in all platforms as we can as
possible especially for USB devices. Of course, there is no perfect way to get
the same name, and difficult heuristics is not needed.

[Adam Goode, 2014/05/08 03:00:53]

I will look into this. It is complex to do. I think I will also look into adding
the clean way to do this into the kernel.

+          }
+        }
       }
-      if (input) {
-        in_devices_.push_back(port);
-        AddInputPort(port->GetMidiPortInfo());
-      }
-      if (output) {
-        out_devices_.push_back(port);
-        AddOutputPort(port->GetMidiPortInfo());
-      }
-    }
-    snd_ctl_close(handle);
-  }
-
-  if (pipe(pipe_fd_) < 0) {
-    VPLOG(1) << "pipe() failed";
-    CompleteInitialization(MIDI_INITIALIZATION_ERROR);
-  } else {
-    event_thread_.Start();
-    event_thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&MidiManagerAlsa::EventReset, base::Unretained(this)));
-    CompleteInitialization(MIDI_OK);
-  }
+    }
+  }
+
+  event_thread_.Start();
+  event_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&MidiManagerAlsa::EventReset, base::Unretained(this)));
+
+  CompleteInitialization(MIDI_OK);
 }
 
 MidiManagerAlsa::~MidiManagerAlsa() {
-  // Send a shutdown message to awake |event_thread_| from poll().
-  if (pipe_fd_[1] >= 0)
-    HANDLE_EINTR(write(pipe_fd_[1], "Q", 1));
-
-  // Stop receiving messages.
+  // Tell the event thread it will soon be time to shut down.
+  shutdown_mu_.Acquire();

[Takashi Toyoshima, 2014/05/07 04:38:28]

option: It's up to you, but I feel using AutoLock with {} scope is more popular
and safe.

[Adam Goode, 2014/05/08 03:00:53]

Done.

+  event_thread_shutdown_ = true;
+  shutdown_mu_.Release();
+
+  // Stop the send thread.
+  send_thread_.Stop();
+
+  // Close the out client. This will trigger the event thread to stop,
+  // because of SND_SEQ_EVENT_CLIENT_EXIT.
+  if (out_client_) {
+    snd_seq_close(out_client_);
+  }
+
+  // Wait for the event thread to stop.
   event_thread_.Stop();
 
-  for (int i = 0; i < 2; ++i) {
-    if (pipe_fd_[i] >= 0)
-      close(pipe_fd_[i]);
-  }
-  send_thread_.Stop();
+  // Close the in client.
+  if (in_client_) {

[Takashi Toyoshima, 2014/05/07 04:38:28]

Usually chromium style omit {} for a one line clause.

[Adam Goode, 2014/05/08 03:00:53]

Done.

+    snd_seq_close(in_client_);
+  }
+
+  // Free the decoder.
+  snd_midi_event_free(decoder_);
+
+  // Free the encoders.
+  for (EncoderList::iterator i = encoders_.begin(); i != encoders_.end(); ++i) {
+    snd_midi_event_free(*i);

[Takashi Toyoshima, 2014/05/07 04:38:28]

ditto

[Adam Goode, 2014/05/08 03:00:53]

Done.

+  }
+}
+
+void MidiManagerAlsa::SendMidiData(uint32 port_index,
+                                   const std::vector<uint8>& data) {
+  DCHECK(send_thread_.message_loop_proxy()->BelongsToCurrentThread());
+
+  snd_midi_event_t* encoder = encoders_[port_index];
+  for (unsigned int i = 0; i < data.size(); i++) {
+    snd_seq_event_t event;
+    int result = snd_midi_event_encode_byte(encoder, data[i], &event);
+    if (result == 1) {
+      // Full event, send it.
+      snd_seq_ev_set_source(&event, out_ports_[port_index]);
+      snd_seq_ev_set_subs(&event);
+      snd_seq_ev_set_direct(&event);
+      snd_seq_event_output_direct(out_client_, &event);
+    }
+  }
 }
 
 void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
                                            uint32 port_index,
                                            const std::vector<uint8>& data,
                                            double timestamp) {
-  if (out_devices_.size() <= port_index)
+  if (out_ports_.size() <= port_index)
     return;
 
+  if (!send_thread_.IsRunning())
+    send_thread_.Start();
+
+  // Compute delay.
   base::TimeDelta delay;
   if (timestamp != 0.0) {
-    base::TimeTicks time_to_send =
-        base::TimeTicks() + base::TimeDelta::FromMicroseconds(
-            timestamp * base::Time::kMicrosecondsPerSecond);
-    delay = std::max(time_to_send - base::TimeTicks::Now(), base::TimeDelta());
-  }
-
-  if (!send_thread_.IsRunning())
-    send_thread_.Start();
-
-  scoped_refptr<MidiDeviceInfo> device = out_devices_[port_index];
+    delay =
+        base::TimeDelta::FromSecondsD(timestamp) -
+        (base::TimeTicks::HighResNow() - base::TimeTicks());
+  }
+
   send_thread_.message_loop()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&MidiDeviceInfo::Send, device, client, data),
-      delay);
+      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()));
 }
 
 void MidiManagerAlsa::EventReset() {
-  CHECK_GE(pipe_fd_[0], 0);
-
-  // Sum up descriptors which are needed to poll input devices and a shutdown
-  // message.
-  // Keep the first one descriptor for a shutdown message.
-  size_t poll_fds_size = 1;
-  for (size_t i = 0; i < in_devices_.size(); ++i)
-    poll_fds_size += in_devices_[i]->GetPollDescriptorsCount();
-  poll_fds_.resize(poll_fds_size);
-
-  // Setup struct pollfd to poll input MIDI devices and a shutdown message.
-  // The first pollfd is for a shutdown message.
-  poll_fds_[0].fd = pipe_fd_[0];
-  poll_fds_[0].events = kPollEventMask;
-  int fds_index = 1;
-  for (size_t i = 0; i < in_devices_.size(); ++i) {
-    fds_index += in_devices_[i]->SetupPollDescriptors(
-        &poll_fds_[fds_index], poll_fds_.size() - fds_index);
-  }
-
   event_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::EventLoop, base::Unretained(this)));
 }
 
 void MidiManagerAlsa::EventLoop() {
-  if (HANDLE_EINTR(poll(&poll_fds_[0], poll_fds_.size(), -1)) < 0) {
-    VPLOG(1) << "Couldn't poll(). Stop to poll input MIDI devices.";
-    // TODO(toyoshim): Handle device disconnection, and try to reconnect?
-    return;
-  }
-
-  // Check timestamp as soon as possible because the API requires accurate
-  // timestamp as possible. It will be useful for recording MIDI events.
-  base::TimeTicks now = base::TimeTicks::HighResNow();
-
-  // Is this thread going to be shutdown?
-  if (poll_fds_[0].revents & kPollEventMask)
-    return;
-
   // Read available incoming MIDI data.
-  int fds_index = 1;
-  uint8 buffer[kReceiveBufferSize];
-
-  for (size_t i = 0; i < in_devices_.size(); ++i) {
-    unsigned short revents =
-        in_devices_[i]->GetPollDescriptorsRevents(&poll_fds_[fds_index]);
-    if (revents & (POLLERR | POLLNVAL)) {
-      // TODO(toyoshim): Handle device disconnection.
-      VLOG(1) << "snd_rawmidi_descriptors_revents fails";
-      poll_fds_[fds_index].events = 0;
-    }
-    if (revents & POLLIN) {
-      size_t read_size = in_devices_[i]->Receive(buffer, kReceiveBufferSize);
-      ReceiveMidiData(i, buffer, read_size, now);
-    }
-    fds_index += in_devices_[i]->GetPollDescriptorsCount();
+  snd_seq_event_t* event;
+  int err = snd_seq_event_input(in_client_, &event);
+  double timestamp =
+      (base::TimeTicks::HighResNow() - base::TimeTicks()).InSecondsF();
+  if (err == -ENOSPC) {
+    VLOG(1) << "snd_seq_event_input detected buffer overrun";
+
+      // We've lost events: check another way to see if we need to shut down.

[Takashi Toyoshima, 2014/05/07 04:38:28]

Why do you check shutdown here? I mean why only for ENOSPC.

Anyway, Thread::Stop() post a task to stop event loop gracefully, so we do not
need to have special code for stopping the loop. But, I'm afraid that if we do
not have any coming events, snd_seq_event_input() may block forever, and until
returning from it, the thread can not be stopped. It will make Chrome shutdown
hang-up. Does ALSA have a API to post a dummy event to the subscriber to unblock
snd_seq_event_input() call quickly?

[Adam Goode, 2014/05/08 03:00:53]

This is only for the case where we miss the shutdown event
(SND_SEQ_EVENT_CLIENT_EXIT) because of a FIFO buffer overrun in the kernel. The
typical shutdown code is below. We also want this logic when we support hotplug
devices so we can trigger a full rescan if we lose messages.
Yes, see the "else" clause below. 'Check for disconnection of out client. This
means "shut down".'

[Takashi Toyoshima, 2014/05/16 19:31:52]

Ah, I see. I understand how shutdown works.
Thanks.

+      base::AutoLock lock(shutdown_mu_);
+      if (event_thread_shutdown_) {
+        return;
+      }
+  } else if (err < 0) {
+      VLOG(1) << "snd_seq_event_input fails: " << snd_strerror(err);
+      return;
+  } else {
+    // Check for disconnection of out client. This means "shut down".
+    if (event->source.client == SND_SEQ_CLIENT_SYSTEM &&
+        event->source.port == SND_SEQ_PORT_SYSTEM_ANNOUNCE &&
+        event->type == SND_SEQ_EVENT_CLIENT_EXIT &&
+        event->data.addr.client == out_client_id_) {
+      return;
+    }
+
+    std::map<int, uint32>::iterator 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);
+          }
+        } else {
+          ReceiveMidiData(source, buf, count, timestamp);
+        }
+      }
+    }
   }
 
   // Do again.
   event_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::EventLoop, base::Unretained(this)));
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace media