libs/backends/portaudio/winmmemidi_output_device.cc

   1 /*
   2  * Copyright (C) 2015 Tim Mayberry <mojofunk@gmail.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include "winmmemidi_output_device.h"
  20
  21 #include <glibmm.h>
  22
  23 #include "pbd/debug.h"
  24 #include "pbd/compose.h"
  25
  26 #include "rt_thread.h"
  27 #include "win_utils.h"
  28 #include "midi_util.h"
  29
  30 #include "mmcss.h"
  31 #include "debug.h"
  32
  33 // remove dup with input_device
  34 static const uint32_t MIDI_BUFFER_SIZE = 32768;
  35 static const uint32_t MAX_MIDI_MSG_SIZE = 256; // fix this for sysex
  36 static const uint32_t MAX_QUEUE_SIZE = 4096;
  37
  38 namespace ARDOUR {
  39
  40 WinMMEMidiOutputDevice::WinMMEMidiOutputDevice (int index)
  41         : m_handle(0)
  42         , m_queue_semaphore(0)
  43         , m_sysex_semaphore(0)
  44         , m_timer(0)
  45         , m_started(false)
  46         , m_enabled(false)
  47         , m_thread_running(false)
  48         , m_thread_quit(false)
  49         , m_midi_buffer(new RingBuffer<uint8_t>(MIDI_BUFFER_SIZE))
  50 {
  51         DEBUG_MIDI (string_compose ("Creating midi output device index: %1\n", index));
  52
  53         std::string error_msg;
  54
  55         if (!open (index, error_msg)) {
  56                 DEBUG_MIDI (error_msg);
  57                 throw std::runtime_error (error_msg);
  58         }
  59
  60         set_device_name (index);
  61 }
  62
  63 WinMMEMidiOutputDevice::~WinMMEMidiOutputDevice ()
  64 {
  65         std::string error_msg;
  66         if (!close (error_msg)) {
  67                 DEBUG_MIDI (error_msg);
  68         }
  69 }
  70
  71 bool
  72 WinMMEMidiOutputDevice::enqueue_midi_event (uint64_t timestamp,
  73                                             const uint8_t* data,
  74                                             size_t size)
  75 {
  76         const uint32_t total_bytes = sizeof(MidiEventHeader) + size;
  77         if (m_midi_buffer->write_space () < total_bytes) {
  78                 DEBUG_MIDI ("WinMMEMidiOutput: ring buffer overflow\n");
  79                 return false;
  80         }
  81
  82         MidiEventHeader h (timestamp, size);
  83         m_midi_buffer->write ((uint8_t*)&h, sizeof(MidiEventHeader));
  84         m_midi_buffer->write (data, size);
  85
  86         signal (m_queue_semaphore);
  87         return true;
  88 }
  89
  90 bool
  91 WinMMEMidiOutputDevice::open (UINT index, std::string& error_msg)
  92 {
  93         MMRESULT result = midiOutOpen (&m_handle,
  94                                        index,
  95                                        (DWORD_PTR)winmm_output_callback,
  96                                        (DWORD_PTR) this,
  97                                        CALLBACK_FUNCTION);
  98         if (result != MMSYSERR_NOERROR) {
  99                 error_msg = get_error_string (result);
 100                 return false;
 101         }
 102
 103         m_queue_semaphore = CreateSemaphore (NULL, 0, MAX_QUEUE_SIZE, NULL);
 104         if (m_queue_semaphore == NULL) {
 105                 DEBUG_MIDI ("WinMMEMidiOutput: Unable to create queue semaphore\n");
 106                 return false;
 107         }
 108         m_sysex_semaphore = CreateSemaphore (NULL, 0, 1, NULL);
 109         if (m_sysex_semaphore == NULL) {
 110                 DEBUG_MIDI ("WinMMEMidiOutput: Unable to create sysex semaphore\n");
 111                 return false;
 112         }
 113         return true;
 114 }
 115
 116 bool
 117 WinMMEMidiOutputDevice::close (std::string& error_msg)
 118 {
 119         // return error message for first error encountered?
 120         bool success = true;
 121         MMRESULT result = midiOutReset (m_handle);
 122         if (result != MMSYSERR_NOERROR) {
 123                 error_msg = get_error_string (result);
 124                 DEBUG_MIDI (error_msg);
 125                 success = false;
 126         }
 127         result = midiOutClose (m_handle);
 128         if (result != MMSYSERR_NOERROR) {
 129                 error_msg = get_error_string (result);
 130                 DEBUG_MIDI (error_msg);
 131                 success = false;
 132         }
 133
 134         if (m_sysex_semaphore) {
 135                 if (!CloseHandle (m_sysex_semaphore)) {
 136                         DEBUG_MIDI ("WinMMEMidiOut Unable to close sysex semaphore\n");
 137                         success = false;
 138                 } else {
 139                         m_sysex_semaphore = 0;
 140                 }
 141         }
 142         if (m_queue_semaphore) {
 143                 if (!CloseHandle (m_queue_semaphore)) {
 144                         DEBUG_MIDI ("WinMMEMidiOut Unable to close queue semaphore\n");
 145                         success = false;
 146                 } else {
 147                         m_queue_semaphore = 0;
 148                 }
 149         }
 150
 151         m_handle = 0;
 152         return success;
 153 }
 154
 155 bool
 156 WinMMEMidiOutputDevice::set_device_name (UINT index)
 157 {
 158         MIDIOUTCAPS capabilities;
 159         MMRESULT result =
 160             midiOutGetDevCaps (index, &capabilities, sizeof(capabilities));
 161
 162         if (result != MMSYSERR_NOERROR) {
 163                 DEBUG_MIDI (get_error_string (result));
 164                 m_name = "Unknown Midi Output Device";
 165                 return false;
 166         } else {
 167                 m_name = capabilities.szPname;
 168         }
 169         return true;
 170 }
 171
 172 std::string
 173 WinMMEMidiOutputDevice::get_error_string (MMRESULT error_code)
 174 {
 175         char error_msg[MAXERRORLENGTH];
 176         MMRESULT result = midiOutGetErrorText (error_code, error_msg, MAXERRORLENGTH);
 177         if (result != MMSYSERR_NOERROR) {
 178                 return error_msg;
 179         }
 180         return "WinMMEMidiOutput: Unknown Error code";
 181 }
 182
 183 bool
 184 WinMMEMidiOutputDevice::start ()
 185 {
 186         if (m_thread_running) {
 187                 DEBUG_MIDI (
 188                     string_compose ("WinMMEMidiOutput: device %1 already started\n", m_name));
 189                 return true;
 190         }
 191
 192         m_timer = CreateWaitableTimer (NULL, FALSE, NULL);
 193
 194         if (!m_timer) {
 195                 DEBUG_MIDI ("WinMMEMidiOutput: unable to create waitable timer\n");
 196                 return false;
 197         }
 198
 199         if (!start_midi_output_thread ()) {
 200                 DEBUG_MIDI ("WinMMEMidiOutput: Failed to start MIDI output thread\n");
 201
 202                 if (!CloseHandle (m_timer)) {
 203                         DEBUG_MIDI ("WinMMEMidiOutput: unable to close waitable timer\n");
 204                 }
 205                 return false;
 206         }
 207         return true;
 208 }
 209
 210 bool
 211 WinMMEMidiOutputDevice::stop ()
 212 {
 213         if (!m_thread_running) {
 214                 DEBUG_MIDI ("WinMMEMidiOutputDevice: device already stopped\n");
 215                 return true;
 216         }
 217
 218         if (!stop_midi_output_thread ()) {
 219                 DEBUG_MIDI ("WinMMEMidiOutput: Failed to start MIDI output thread\n");
 220                 return false;
 221         }
 222
 223         if (!CloseHandle (m_timer)) {
 224                 DEBUG_MIDI ("WinMMEMidiOutput: unable to close waitable timer\n");
 225                 return false;
 226         }
 227         m_timer = 0;
 228         return true;
 229 }
 230
 231 bool
 232 WinMMEMidiOutputDevice::start_midi_output_thread ()
 233 {
 234         m_thread_quit = false;
 235
 236         //pthread_attr_t attr;
 237         size_t stacksize = 100000;
 238
 239         // TODO Use native threads
 240         if (_realtime_pthread_create (SCHED_FIFO, -21, stacksize,
 241                                 &m_output_thread_handle, midi_output_thread, this)) {
 242                 return false;
 243         }
 244
 245         int timeout = 5000;
 246         while (!m_thread_running && --timeout > 0) { Glib::usleep (1000); }
 247         if (timeout == 0 || !m_thread_running) {
 248                 DEBUG_MIDI (string_compose ("Unable to start midi output device thread: %1\n",
 249                                             m_name));
 250                 return false;
 251         }
 252         return true;
 253 }
 254
 255 bool
 256 WinMMEMidiOutputDevice::stop_midi_output_thread ()
 257 {
 258         int timeout = 5000;
 259         m_thread_quit = true;
 260         signal (m_queue_semaphore);
 261
 262         while (m_thread_running && --timeout > 0) { Glib::usleep (1000); }
 263         if (timeout == 0 || m_thread_running) {
 264                 DEBUG_MIDI (string_compose ("Unable to stop midi output device thread: %1\n",
 265                                              m_name));
 266                 return false;
 267         }
 268
 269         void *status;
 270         if (pthread_join (m_output_thread_handle, &status)) {
 271                 DEBUG_MIDI (string_compose ("Unable to join midi output device thread: %1\n",
 272                                             m_name));
 273                 return false;
 274         }
 275         return true;
 276 }
 277
 278 bool
 279 WinMMEMidiOutputDevice::signal (HANDLE semaphore)
 280 {
 281         bool result = (bool)ReleaseSemaphore (semaphore, 1, NULL);
 282         if (!result) {
 283                 DEBUG_MIDI ("WinMMEMidiOutDevice: Cannot release semaphore\n");
 284         }
 285         return result;
 286 }
 287
 288 bool
 289 WinMMEMidiOutputDevice::wait (HANDLE semaphore)
 290 {
 291         DWORD result = WaitForSingleObject (semaphore, INFINITE);
 292         switch (result) {
 293         case WAIT_FAILED:
 294                 DEBUG_MIDI ("WinMMEMidiOutDevice: WaitForSingleObject Failed\n");
 295                 break;
 296         case WAIT_OBJECT_0:
 297                 return true;
 298         default:
 299                 DEBUG_MIDI ("WinMMEMidiOutDevice: Unexpected result from WaitForSingleObject\n");
 300         }
 301         return false;
 302 }
 303
 304 void CALLBACK
 305 WinMMEMidiOutputDevice::winmm_output_callback (HMIDIOUT handle,
 306                                                UINT msg,
 307                                                DWORD_PTR instance,
 308                                                DWORD_PTR midi_data,
 309                                                DWORD_PTR timestamp)
 310 {
 311         ((WinMMEMidiOutputDevice*)instance)
 312             ->midi_output_callback (msg, midi_data, timestamp);
 313 }
 314
 315 void
 316 WinMMEMidiOutputDevice::midi_output_callback (UINT message,
 317                                               DWORD_PTR midi_data,
 318                                               DWORD_PTR timestamp)
 319 {
 320         switch (message) {
 321         case MOM_CLOSE:
 322                 DEBUG_MIDI ("WinMMEMidiOutput - MIDI device closed\n");
 323                 break;
 324         case MOM_DONE:
 325                 signal (m_sysex_semaphore);
 326                 break;
 327         case MOM_OPEN:
 328                 DEBUG_MIDI ("WinMMEMidiOutput - MIDI device opened\n");
 329                 break;
 330         case MOM_POSITIONCB:
 331                 LPMIDIHDR header = (LPMIDIHDR)midi_data;
 332                 DEBUG_MIDI (string_compose ("WinMMEMidiOut - %1 bytes out of %2 bytes of "
 333                                             "the current sysex message have been sent.\n",
 334                                             header->dwOffset,
 335                                             header->dwBytesRecorded));
 336         }
 337 }
 338
 339 void*
 340 WinMMEMidiOutputDevice::midi_output_thread (void *arg)
 341 {
 342         WinMMEMidiOutputDevice* output_device = reinterpret_cast<WinMMEMidiOutputDevice*> (arg);
 343         output_device->midi_output_thread ();
 344         return 0;
 345 }
 346
 347 void
 348 WinMMEMidiOutputDevice::midi_output_thread ()
 349 {
 350         m_thread_running = true;
 351
 352         DEBUG_MIDI ("WinMMEMidiOut: MIDI output thread started\n");
 353
 354 #ifdef USE_MMCSS_THREAD_PRIORITIES
 355         HANDLE task_handle;
 356
 357         mmcss::set_thread_characteristics ("Pro Audio", &task_handle);
 358         mmcss::set_thread_priority (task_handle, mmcss::AVRT_PRIORITY_HIGH);
 359 #endif
 360
 361         while (!m_thread_quit) {
 362                 if (!wait (m_queue_semaphore)) {
 363                         break;
 364                 }
 365
 366                 MidiEventHeader h (0, 0);
 367                 uint8_t data[MAX_MIDI_MSG_SIZE];
 368
 369                 const uint32_t read_space = m_midi_buffer->read_space ();
 370
 371                 if (read_space > sizeof(MidiEventHeader)) {
 372                         if (m_midi_buffer->read ((uint8_t*)&h, sizeof(MidiEventHeader)) !=
 373                             sizeof(MidiEventHeader)) {
 374                                 DEBUG_MIDI ("WinMMEMidiOut: Garbled MIDI EVENT HEADER!!\n");
 375                                 break;
 376                         }
 377                         assert (read_space >= h.size);
 378
 379                         if (h.size > MAX_MIDI_MSG_SIZE) {
 380                                 m_midi_buffer->increment_read_idx (h.size);
 381                                 DEBUG_MIDI ("WinMMEMidiOut: MIDI event too large!\n");
 382                                 continue;
 383                         }
 384                         if (m_midi_buffer->read (&data[0], h.size) != h.size) {
 385                                 DEBUG_MIDI ("WinMMEMidiOut: Garbled MIDI EVENT DATA!!\n");
 386                                 break;
 387                         }
 388                 } else {
 389                         // error/assert?
 390                         DEBUG_MIDI ("WinMMEMidiOut: MIDI buffer underrun, shouldn't occur\n");
 391                         continue;
 392                 }
 393                 uint64_t current_time = utils::get_microseconds ();
 394
 395                 DEBUG_TIMING (string_compose (
 396                     "WinMMEMidiOut: h.time = %1, current_time = %2\n", h.time, current_time));
 397
 398                 if (h.time > current_time) {
 399
 400                         DEBUG_TIMING (string_compose ("WinMMEMidiOut: waiting at %1 for %2 "
 401                                                       "milliseconds before sending message\n",
 402                                                       ((double)current_time) / 1000.0,
 403                                                       ((double)(h.time - current_time)) / 1000.0));
 404
 405                         if (!wait_for_microseconds (h.time - current_time))
 406                         {
 407                                 DEBUG_MIDI ("WinMMEMidiOut: Error waiting for timer\n");
 408                                 break;
 409                         }
 410
 411                         uint64_t wakeup_time = utils::get_microseconds ();
 412                         DEBUG_TIMING (string_compose ("WinMMEMidiOut: woke up at %1(ms)\n",
 413                                                       ((double)wakeup_time) / 1000.0));
 414                         if (wakeup_time > h.time) {
 415                                 DEBUG_TIMING (string_compose ("WinMMEMidiOut: overslept by %1(ms)\n",
 416                                                               ((double)(wakeup_time - h.time)) / 1000.0));
 417                         } else if (wakeup_time < h.time) {
 418                                 DEBUG_TIMING (string_compose ("WinMMEMidiOut: woke up %1(ms) too early\n",
 419                                                               ((double)(h.time - wakeup_time)) / 1000.0));
 420                         }
 421
 422                 } else if (h.time < current_time) {
 423                         DEBUG_TIMING (string_compose (
 424                             "WinMMEMidiOut: MIDI event at sent to driver %1(ms) late\n",
 425                             ((double)(current_time - h.time)) / 1000.0));
 426                 }
 427
 428                 DWORD message = 0;
 429                 MMRESULT result;
 430                 switch (h.size) {
 431                 case 3:
 432                         message |= (((DWORD)data[2]) << 16);
 433                 // Fallthrough on purpose.
 434                 case 2:
 435                         message |= (((DWORD)data[1]) << 8);
 436                 // Fallthrough on purpose.
 437                 case 1:
 438                         message |= (DWORD)data[0];
 439                         result = midiOutShortMsg (m_handle, message);
 440                         if (result != MMSYSERR_NOERROR) {
 441                                 DEBUG_MIDI (
 442                                     string_compose ("WinMMEMidiOutput: %1\n", get_error_string (result)));
 443                         }
 444                         continue;
 445                 }
 446
 447 #if ENABLE_SYSEX
 448                 MIDIHDR header;
 449                 header.dwBufferLength = h.size;
 450                 header.dwFlags = 0;
 451                 header.lpData = (LPSTR)data;
 452
 453                 result = midiOutPrepareHeader (m_handle, &header, sizeof(MIDIHDR));
 454                 if (result != MMSYSERR_NOERROR) {
 455                         DEBUG_MIDI (string_compose ("WinMMEMidiOutput: midiOutPrepareHeader %1\n",
 456                                                     get_error_string (result)));
 457                         continue;
 458                 }
 459
 460                 result = midiOutLongMsg (m_handle, &header, sizeof(MIDIHDR));
 461                 if (result != MMSYSERR_NOERROR) {
 462                         DEBUG_MIDI (string_compose ("WinMMEMidiOutput: midiOutLongMsg %1\n",
 463                                                     get_error_string (result)));
 464                         continue;
 465                 }
 466
 467                 // Sysex messages may be sent synchronously or asynchronously.  The
 468                 // choice is up to the WinMME driver.  So, we wait until the message is
 469                 // sent, regardless of the driver's choice.
 470                 if (!wait (m_sysex_semaphore)) {
 471                         break;
 472                 }
 473
 474                 result = midiOutUnprepareHeader (m_handle, &header, sizeof(MIDIHDR));
 475                 if (result != MMSYSERR_NOERROR) {
 476                         DEBUG_MIDI (string_compose ("WinMMEMidiOutput: midiOutUnprepareHeader %1\n",
 477                                                     get_error_string (result)));
 478                         break;
 479                 }
 480 #endif
 481         }
 482
 483 #ifdef USE_MMCSS_THREAD_PRIORITIES
 484         mmcss::revert_thread_characteristics (task_handle);
 485 #endif
 486
 487         m_thread_running = false;
 488 }
 489
 490 bool
 491 WinMMEMidiOutputDevice::wait_for_microseconds (int64_t wait_us)
 492 {
 493         LARGE_INTEGER due_time;
 494
 495         // 100 ns resolution
 496         due_time.QuadPart = -((LONGLONG)(wait_us * 10));
 497         if (!SetWaitableTimer (m_timer, &due_time, 0, NULL, NULL, 0)) {
 498                 DEBUG_MIDI ("WinMMEMidiOut: Error waiting for timer\n");
 499                 return false;
 500         }
 501
 502         if (!wait (m_timer)) {
 503                 return false;
 504         }
 505
 506         return true;
 507 }
 508
 509 } // namespace ARDOUR