Web MIDI: implement sending for dynamic manager instantiation on Windows

media/midi/dynamically_initialized_midi_manager_win.cc

 // Copyright 2017 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/dynamically_initialized_midi_manager_win.h"
 
 #include <windows.h>
 
 #include <mmreg.h>
 #include <mmsystem.h>
@@ skipping 21 matching lines @@
   // Calculates event time from elapsed time that system provides.
   base::TimeTicks CalculateInEventTime(size_t index, uint32_t elapsed_ms) const;
 
   // Registers HMIDIIN handle to resolve port index.
   void RegisterInHandle(HMIDIIN handle, size_t index);
 
   // Unregisters HMIDIIN handle.
   void UnregisterInHandle(HMIDIIN handle);
 
   // Finds HMIDIIN handle and fullfil |out_index| with the port index.
-  bool FindHandle(HMIDIIN hmi, size_t* out_index);
+  bool FindInHandle(HMIDIIN hmi, size_t* out_index);
 
   // Restores used input buffer for the next data receive.
   void RestoreInBuffer(size_t index);
 
   // Ports accessors.
   std::vector<std::unique_ptr<InPort>>* inputs() { return &input_ports_; }
   std::vector<std::unique_ptr<OutPort>>* outputs() { return &output_ports_; }
 
   // Handles MIDI input port callbacks that runs on a system provided thread.
   static void CALLBACK HandleMidiInCallback(HMIDIIN hmi,
                                             UINT msg,
                                             DWORD_PTR instance,
                                             DWORD_PTR param1,
                                             DWORD_PTR param2);
 
+  // Handles MIDI output port callbacks that runs on a system provided thread.
+  static void CALLBACK HandleMidiOutCallback(HMIDIOUT hmo,
+                                             UINT msg,
+                                             DWORD_PTR instance,
+                                             DWORD_PTR param1,
+                                             DWORD_PTR param2);
+
  private:
   // Holds all MIDI input or output ports connected once.
   std::vector<std::unique_ptr<InPort>> input_ports_;
   std::vector<std::unique_ptr<OutPort>> output_ports_;
 
   // Map to resolve MIDI input port index from HMIDIIN.
   std::map<HMIDIIN, size_t> hmidiin_to_index_map_;
 };
 
 namespace {
 
 // Assumes that nullptr represents an invalid MIDI handle.
 constexpr HMIDIIN kInvalidInHandle = nullptr;
 constexpr HMIDIOUT kInvalidOutHandle = nullptr;
 
+// Defines SysEx message size limit.
+// TODO(crbug.com/383578): This restriction should be removed once Web MIDI
+// defines a standardized way to handle large sysex messages.
+// Note for built-in USB-MIDI driver:
+// From an observation on Windows 7/8.1 with a USB-MIDI keyboard,
+// midiOutLongMsg() will be always blocked. Sending 64 bytes or less data takes
+// roughly 300 usecs. Sending 2048 bytes or more data takes roughly
+// |message.size() / (75 * 1024)| secs in practice. Here we put 256 KB size
+// limit on SysEx message, with hoping that midiOutLongMsg will be blocked at
+// most 4 sec or so with a typical USB-MIDI device.
+// TODO(toyoshim): Consider to use linked small buffers so that midiOutReset()
+// can abort sending unhandled following buffers.
+constexpr size_t kSysExSizeLimit = 256 * 1024;
+
 // Defines input buffer size.
 constexpr size_t kBufferLength = 32 * 1024;
 
 // Global variables to identify MidiManager instance.
 constexpr int kInvalidInstanceId = -1;
 int g_active_instance_id = kInvalidInstanceId;
 DynamicallyInitializedMidiManagerWin* g_manager_instance = nullptr;
 
 // Obtains base::Lock instance pointer to lock instance_id.
 base::Lock* GetInstanceIdLock() {
@@ skipping 71 matching lines @@
   midiInReset(handle);
 
   // Obtains MIDIHDR ownership to release allocated buffers.
   ScopedMIDIHDR hdr(lphdr);
   if (hdr)
     midiInUnprepareHeader(handle, hdr.get(), sizeof(*hdr));
   midiInClose(handle);
 }
 
 void FinalizeOutPort(HMIDIOUT handle) {
+  // Resets inflight buffers. This will cancel sending data that system
+  // holds and were not sent yet.
+  midiOutReset(handle);
   midiOutClose(handle);
 }
 
-// Handles MIDI output port callbacks that runs on a system provided thread.
-void CALLBACK HandleMidiOutCallback(HMIDIOUT hmo,
-                                    UINT msg,
-                                    DWORD_PTR instance,
-                                    DWORD_PTR param1,
-                                    DWORD_PTR param2) {
-  // TODO(toyoshim): Following patches will implement actual functions.
-}
-
 // All instances of Port subclasses are always accessed behind a lock of
 // *GetTaskLock(). Port and subclasses implementation do not need to
 // consider thread safety.
 class Port {
  public:
   Port(const std::string& type,
        uint32_t device_id,
        uint16_t manufacturer_id,
        uint16_t product_id,
        uint32_t driver_version,
@@ skipping 66 matching lines @@
   uint32_t device_id_;
   const uint16_t manufacturer_id_;
   const uint16_t product_id_;
   const uint32_t driver_version_;
   const std::string product_name_;
   MidiPortInfo info_;
 };  // class Port
 
 }  // namespace
 
-// TODO(toyoshim): Following patches will implement actual functions.
 class DynamicallyInitializedMidiManagerWin::InPort final : public Port {
  public:
   InPort(DynamicallyInitializedMidiManagerWin* manager,
          int instance_id,
          UINT device_id,
          const MIDIINCAPS2W& caps)
       : Port("input",
              device_id,
              caps.wMid,
              caps.wPid,
@@ skipping 97 matching lines @@
   }
 
  private:
   DynamicallyInitializedMidiManagerWin* manager_;
   HMIDIIN in_handle_;
   ScopedMIDIHDR hdr_;
   base::TimeTicks start_time_;
   int instance_id_;
 };
 
-// TODO(toyoshim): Following patches will implement actual functions.
 class DynamicallyInitializedMidiManagerWin::OutPort final : public Port {
  public:
   OutPort(UINT device_id, const MIDIOUTCAPS2W& caps)
       : Port("output",
              device_id,
              caps.wMid,
              caps.wPid,
              caps.vDriverVersion,
              base::WideToUTF8(
                  base::string16(caps.szPname, wcslen(caps.szPname)))),
@@ skipping 28 matching lines @@
         base::Bind(&DynamicallyInitializedMidiManagerWin::SetOutputPortState,
                    base::Unretained(manager), index_, info_.state));
   }
 
   void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) {
     manager->PostReplyTask(
         base::Bind(&DynamicallyInitializedMidiManagerWin::AddOutputPort,
                    base::Unretained(manager), info_));
   }
 
+  void Send(const std::vector<uint8_t>& data) {
+    if (out_handle_ == kInvalidOutHandle)
+      return;
+
+    if (data.size() <= 3) {
+      DWORD message = 0;

[yhirano, 2017/03/01 01:48:49]

[optional] I would prefer defining |message| as a uint32_t, and cast it when
passing it to midiOutShortMsg.

[Takashi Toyoshima, 2017/03/01 03:38:02]

changed to uint32_t.
cast is not needed to pass it to the Win32 API because DWORD is uint32_t (though
I'm not sure win clang bot agreed. let me try).

+      for (size_t i = 0; i < data.size(); ++i)
+        message |= (static_cast<uint32_t>(data[i]) << (i * 8));
+      midiOutShortMsg(out_handle_, message);
+    } else {
+      if (data.size() > kSysExSizeLimit) {
+        LOG(ERROR) << "Ignoring SysEx message due to the size limit"
+                   << ", size = " << data.size();
+        // TODO(toyoshim): Consider to report metrics here.
+        return;
+      }
+      ScopedMIDIHDR hdr(CreateMIDIHDR(data));
+      MMRESULT result =
+          midiOutPrepareHeader(out_handle_, hdr.get(), sizeof(*hdr));
+      if (result != MMSYSERR_NOERROR)
+        return;
+      result = midiOutLongMsg(out_handle_, hdr.get(), sizeof(*hdr));
+      if (result != MMSYSERR_NOERROR)
+        midiOutUnprepareHeader(out_handle_, hdr.get(), sizeof(*hdr));
+      else
+        ignore_result(hdr.release());
+      // MIDIHDR will be released on MOM_DONE.
+    }
+  }
+
   // Port overrides:
   bool Connect() override {
     // Until |software| option is supported, disable Microsoft GS Wavetable
     // Synth that has a known security issue.
     if (software_ && manufacturer_id_ == MM_MICROSOFT &&
         (product_id_ == MM_MSFT_WDMAUDIO_MIDIOUT ||
          product_id_ == MM_MSFT_GENERIC_MIDISYNTH)) {
       return false;
     }
     return Port::Connect();
   }
 
   bool Disconnect() override {
     if (out_handle_ != kInvalidOutHandle) {
       // Following API call may fail because device was already disconnected.
       // But just in case.
       midiOutClose(out_handle_);
       out_handle_ = kInvalidOutHandle;
     }
     return Port::Disconnect();
   }
 
   void Open() override {
-    MMRESULT result =
-        midiOutOpen(&out_handle_, device_id_,
-                    reinterpret_cast<DWORD_PTR>(&HandleMidiOutCallback), 0,
-                    CALLBACK_FUNCTION);
+    MMRESULT result = midiOutOpen(
+        &out_handle_, device_id_,
+        reinterpret_cast<DWORD_PTR>(&PortManager::HandleMidiOutCallback), 0,
+        CALLBACK_FUNCTION);
     if (result == MMSYSERR_NOERROR) {
       Port::Open();
     } else {
       out_handle_ = kInvalidOutHandle;
       Disconnect();
     }
   }
 
   const bool software_;
   HMIDIOUT out_handle_;
@@ skipping 14 matching lines @@
   GetTaskLock()->AssertAcquired();
   hmidiin_to_index_map_[handle] = index;
 }
 
 void DynamicallyInitializedMidiManagerWin::PortManager::UnregisterInHandle(
     HMIDIIN handle) {
   GetTaskLock()->AssertAcquired();
   hmidiin_to_index_map_.erase(handle);
 }
 
-bool DynamicallyInitializedMidiManagerWin::PortManager::FindHandle(
+bool DynamicallyInitializedMidiManagerWin::PortManager::FindInHandle(
     HMIDIIN hmi,
     size_t* out_index) {
   GetTaskLock()->AssertAcquired();
   auto found = hmidiin_to_index_map_.find(hmi);
   if (found == hmidiin_to_index_map_.end())
     return false;
   *out_index = found->second;
   return true;
 }
 
@@ skipping 20 matching lines @@
   // and to access member variables that are used on TaskRunner.
   base::AutoLock task_lock(*GetTaskLock());
   {
     base::AutoLock lock(*GetInstanceIdLock());
     if (instance_id != g_active_instance_id)
       return;
     manager = g_manager_instance;
   }
 
   size_t index;
-  if (!manager->port_manager()->FindHandle(hmi, &index))
+  if (!manager->port_manager()->FindInHandle(hmi, &index))
     return;
 
   DCHECK(msg == MIM_DATA || msg == MIM_LONGDATA);
   if (msg == MIM_DATA) {
     const uint8_t status_byte = static_cast<uint8_t>(param1 & 0xff);
     const uint8_t first_data_byte = static_cast<uint8_t>((param1 >> 8) & 0xff);
     const uint8_t second_data_byte =
         static_cast<uint8_t>((param1 >> 16) & 0xff);
     const size_t len = GetMessageLength(status_byte);
     const uint8_t kData[] = {status_byte, first_data_byte, second_data_byte};
@@ skipping 14 matching lines @@
           &DynamicallyInitializedMidiManagerWin::ReceiveMidiData,
           base::Unretained(manager), index, data,
           manager->port_manager()->CalculateInEventTime(index, param2)));
     }
     manager->PostTask(base::Bind(
         &DynamicallyInitializedMidiManagerWin::PortManager::RestoreInBuffer,
         base::Unretained(manager->port_manager()), index));
   }
 }
 
+void CALLBACK
+DynamicallyInitializedMidiManagerWin::PortManager::HandleMidiOutCallback(
+    HMIDIOUT hmo,
+    UINT msg,
+    DWORD_PTR instance,
+    DWORD_PTR param1,
+    DWORD_PTR param2) {
+  if (msg == MOM_DONE) {
+    ScopedMIDIHDR hdr(reinterpret_cast<LPMIDIHDR>(param1));
+    if (!hdr)
+      return;
+    // TODO(toyoshim): Call midiOutUnprepareHeader outside the callback.
+    // Since this callback may be invoked after the manager is destructed,
+    // and can not send a task to the TaskRunner in such case, we need to
+    // consider to track MIDIHDR per port, and clean it in port finalization
+    // steps, too.
+    midiOutUnprepareHeader(hmo, hdr.get(), sizeof(*hdr));
+  }
+}
+
 DynamicallyInitializedMidiManagerWin::DynamicallyInitializedMidiManagerWin(
     MidiService* service)
     : MidiManager(service),
       instance_id_(IssueNextInstanceId()),
       port_manager_(base::MakeUnique<PortManager>()) {
   base::AutoLock lock(*GetInstanceIdLock());
   CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
 
   // Obtains the task runner for the current thread that hosts this instnace.
   thread_runner_ = base::ThreadTaskRunnerHandle::Get();
@@ skipping 50 matching lines @@
     port->Finalize(service()->GetTaskRunner(kTaskRunner));
   for (const auto& port : *port_manager_->outputs())
     port->Finalize(service()->GetTaskRunner(kTaskRunner));
 }
 
 void DynamicallyInitializedMidiManagerWin::DispatchSendMidiData(
     MidiManagerClient* client,
     uint32_t port_index,
     const std::vector<uint8_t>& data,
     double timestamp) {
-  // TODO(toyoshim): Following patches will implement.
+  if (timestamp != 0.0) {
+    base::TimeTicks time = base::TimeTicks() +
+                           base::TimeDelta::FromMicroseconds(
+                               timestamp * base::Time::kMicrosecondsPerSecond);
+    base::TimeTicks now = base::TimeTicks::Now();
+    if (now < time) {
+      PostDelayedTask(
+          base::Bind(&DynamicallyInitializedMidiManagerWin::SendOnTaskRunner,
+                     base::Unretained(this), client, port_index, data),
+          time - now);
+      return;
+    }
+  }
+  PostTask(base::Bind(&DynamicallyInitializedMidiManagerWin::SendOnTaskRunner,
+                      base::Unretained(this), client, port_index, data));
 }
 
 void DynamicallyInitializedMidiManagerWin::OnDevicesChanged(
     base::SystemMonitor::DeviceType device_type) {
   // Notified on the I/O thread.
   CHECK(thread_runner_->BelongsToCurrentThread());
 
   switch (device_type) {
     case base::SystemMonitor::DEVTYPE_AUDIO:
     case base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE:
@@ skipping 19 matching lines @@
   service()
       ->GetTaskRunner(kTaskRunner)
       ->PostTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task));
 }
 
 void DynamicallyInitializedMidiManagerWin::PostReplyTask(
     const base::Closure& task) {
   thread_runner_->PostTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task));
 }
 
+void DynamicallyInitializedMidiManagerWin::PostDelayedTask(
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  service()
+      ->GetTaskRunner(kTaskRunner)
+      ->PostDelayedTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task),
+                        delay);
+}
+
 void DynamicallyInitializedMidiManagerWin::InitializeOnTaskRunner() {
   UpdateDeviceListOnTaskRunner();
   PostReplyTask(
       base::Bind(&DynamicallyInitializedMidiManagerWin::CompleteInitialization,
                  base::Unretained(this), mojom::Result::OK));
 }
 
 void DynamicallyInitializedMidiManagerWin::UpdateDeviceListOnTaskRunner() {
   std::vector<std::unique_ptr<InPort>> active_input_ports =
       InPort::EnumerateActivePorts(this, instance_id_);
@@ skipping 37 matching lines @@
                      }) == known_ports->end()) {
       size_t index = known_ports->size();
       port->set_index(index);
       known_ports->push_back(std::move(port));
       (*known_ports)[index]->Connect();
       (*known_ports)[index]->NotifyPortAdded(this);
     }
   }
 }
 
+void DynamicallyInitializedMidiManagerWin::SendOnTaskRunner(
+    MidiManagerClient* client,
+    uint32_t port_index,
+    const std::vector<uint8_t>& data) {
+  CHECK_GT(port_manager_->outputs()->size(), port_index);
+  (*port_manager_->outputs())[port_index]->Send(data);
+  // |client| will be checked inside MidiManager::AccumulateMidiBytesSent.
+  PostReplyTask(
+      base::Bind(&DynamicallyInitializedMidiManagerWin::AccumulateMidiBytesSent,
+                 base::Unretained(this), client, data.size()));
+}
+
 }  // namespace midi