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
 261         while (m_thread_running && --timeout > 0) { Glib::usleep (1000); }
 262         if (timeout == 0 || m_thread_running) {
 263                 DEBUG_MIDI (string_compose ("Unable to stop midi output device thread: %1\n",
 264                                              m_name));
 265                 return false;
 266         }
 267
 268         void *status;
 269         if (pthread_join (m_output_thread_handle, &status)) {
 270                 DEBUG_MIDI (string_compose ("Unable to join midi output device thread: %1\n",
 271                                             m_name));
 272                 return false;
 273         }
 274         return true;
 275 }
 276
 277 bool
 278 WinMMEMidiOutputDevice::signal (HANDLE semaphore)
 279 {
 280         bool result = (bool)ReleaseSemaphore (semaphore, 1, NULL);
 281         if (!result) {
 282                 DEBUG_MIDI ("WinMMEMidiOutDevice: Cannot release semaphore\n");
 283         }
 284         return result;
 285 }
 286
 287 bool
 288 WinMMEMidiOutputDevice::wait (HANDLE semaphore)
 289 {
 290         DWORD result = WaitForSingleObject (semaphore, INFINITE);
 291         switch (result) {
 292         case WAIT_FAILED:
 293                 DEBUG_MIDI ("WinMMEMidiOutDevice: WaitForSingleObject Failed\n");
 294                 break;
 295         case WAIT_OBJECT_0:
 296                 return true;
 297         default:
 298                 DEBUG_MIDI ("WinMMEMidiOutDevice: Unexpected result from WaitForSingleObject\n");
 299         }
 300         return false;
 301 }
 302
 303 void CALLBACK
 304 WinMMEMidiOutputDevice::winmm_output_callback (HMIDIOUT handle,
 305                                                UINT msg,
 306                                                DWORD_PTR instance,
 307                                                DWORD_PTR midi_data,
 308                                                DWORD_PTR timestamp)
 309 {
 310         ((WinMMEMidiOutputDevice*)instance)
 311             ->midi_output_callback (msg, midi_data, timestamp);
 312 }
 313
 314 void
 315 WinMMEMidiOutputDevice::midi_output_callback (UINT message,
 316                                               DWORD_PTR midi_data,
 317                                               DWORD_PTR timestamp)
 318 {
 319         switch (message) {
 320         case MOM_CLOSE:
 321                 DEBUG_MIDI ("WinMMEMidiOutput - MIDI device closed\n");
 322                 break;
 323         case MOM_DONE:
 324                 signal (m_sysex_semaphore);
 325                 break;
 326         case MOM_OPEN:
 327                 DEBUG_MIDI ("WinMMEMidiOutput - MIDI device opened\n");
 328                 break;
 329         case MOM_POSITIONCB:
 330                 LPMIDIHDR header = (LPMIDIHDR)midi_data;
 331                 DEBUG_MIDI (string_compose ("WinMMEMidiOut - %1 bytes out of %2 bytes of "
 332                                             "the current sysex message have been sent.\n",
 333                                             header->dwOffset,
 334                                             header->dwBytesRecorded));
 335         }
 336 }
 337
 338 void*
 339 WinMMEMidiOutputDevice::midi_output_thread (void *arg)
 340 {
 341         WinMMEMidiOutputDevice* output_device = reinterpret_cast<WinMMEMidiOutputDevice*> (arg);
 342         output_device->midi_output_thread ();
 343         return 0;
 344 }
 345
 346 void
 347 WinMMEMidiOutputDevice::midi_output_thread ()
 348 {
 349         m_thread_running = true;
 350
 351         DEBUG_MIDI ("WinMMEMidiOut: MIDI output thread started\n");
 352
 353 #ifdef USE_MMCSS_THREAD_PRIORITIES
 354         HANDLE task_handle;
 355
 356         mmcss::set_thread_characteristics ("Pro Audio", &task_handle);
 357         mmcss::set_thread_priority (task_handle, mmcss::AVRT_PRIORITY_HIGH);
 358 #endif
 359
 360         while (!m_thread_quit) {
 361                 if (!wait (m_queue_semaphore)) {
 362                         break;
 363                 }
 364
 365                 MidiEventHeader h (0, 0);
 366                 uint8_t data[MAX_MIDI_MSG_SIZE];
 367
 368                 const uint32_t read_space = m_midi_buffer->read_space ();
 369
 370                 if (read_space > sizeof(MidiEventHeader)) {
 371                         if (m_midi_buffer->read ((uint8_t*)&h, sizeof(MidiEventHeader)) !=
 372                             sizeof(MidiEventHeader)) {
 373                                 DEBUG_MIDI ("WinMMEMidiOut: Garbled MIDI EVENT HEADER!!\n");
 374                                 break;
 375                         }
 376                         assert (read_space >= h.size);
 377
 378                         if (h.size > MAX_MIDI_MSG_SIZE) {
 379                                 m_midi_buffer->increment_read_idx (h.size);
 380                                 DEBUG_MIDI ("WinMMEMidiOut: MIDI event too large!\n");
 381                                 continue;
 382                         }
 383                         if (m_midi_buffer->read (&data[0], h.size) != h.size) {
 384                                 DEBUG_MIDI ("WinMMEMidiOut: Garbled MIDI EVENT DATA!!\n");
 385                                 break;
 386                         }
 387                 } else {
 388                         // error/assert?
 389                         DEBUG_MIDI ("WinMMEMidiOut: MIDI buffer underrun, shouldn't occur\n");
 390                         continue;
 391                 }
 392                 uint64_t current_time = utils::get_microseconds ();
 393
 394                 DEBUG_TIMING (string_compose (
 395                     "WinMMEMidiOut: h.time = %1, current_time = %2\n", h.time, current_time));
 396
 397                 if (h.time > current_time) {
 398
 399                         DEBUG_TIMING (string_compose ("WinMMEMidiOut: waiting at %1 for %2 "
 400                                                       "milliseconds before sending message\n",
 401                                                       ((double)current_time) / 1000.0,
 402                                                       ((double)(h.time - current_time)) / 1000.0));
 403
 404                         if (!wait_for_microseconds (h.time - current_time))
 405                         {
 406                                 DEBUG_MIDI ("WinMMEMidiOut: Error waiting for timer\n");
 407                                 break;
 408                         }
 409
 410                         uint64_t wakeup_time = utils::get_microseconds ();
 411                         DEBUG_TIMING (string_compose ("WinMMEMidiOut: woke up at %1(ms)\n",
 412                                                       ((double)wakeup_time) / 1000.0));
 413                         if (wakeup_time > h.time) {
 414                                 DEBUG_TIMING (string_compose ("WinMMEMidiOut: overslept by %1(ms)\n",
 415                                                               ((double)(wakeup_time - h.time)) / 1000.0));
 416                         } else if (wakeup_time < h.time) {
 417                                 DEBUG_TIMING (string_compose ("WinMMEMidiOut: woke up %1(ms) too early\n",
 418                                                               ((double)(h.time - wakeup_time)) / 1000.0));
 419                         }
 420
 421                 } else if (h.time < current_time) {
 422                         DEBUG_TIMING (string_compose (
 423                             "WinMMEMidiOut: MIDI event at sent to driver %1(ms) late\n",
 424                             ((double)(current_time - h.time)) / 1000.0));
 425                 }
 426
 427                 DWORD message = 0;
 428                 MMRESULT result;
 429                 switch (h.size) {
 430                 case 3:
 431                         message |= (((DWORD)data[2]) << 16);
 432                 // Fallthrough on purpose.
 433                 case 2:
 434                         message |= (((DWORD)data[1]) << 8);
 435                 // Fallthrough on purpose.
 436                 case 1:
 437                         message |= (DWORD)data[0];
 438                         result = midiOutShortMsg (m_handle, message);
 439                         if (result != MMSYSERR_NOERROR) {
 440                                 DEBUG_MIDI (
 441                                     string_compose ("WinMMEMidiOutput: %1\n", get_error_string (result)));
 442                         }
 443                         continue;
 444                 }
 445
 446 #if ENABLE_SYSEX
 447                 MIDIHDR header;
 448                 header.dwBufferLength = h.size;
 449                 header.dwFlags = 0;
 450                 header.lpData = (LPSTR)data;
 451
 452                 result = midiOutPrepareHeader (m_handle, &header, sizeof(MIDIHDR));
 453                 if (result != MMSYSERR_NOERROR) {
 454                         DEBUG_MIDI (string_compose ("WinMMEMidiOutput: midiOutPrepareHeader %1\n",
 455                                                     get_error_string (result)));
 456                         continue;
 457                 }
 458
 459                 result = midiOutLongMsg (m_handle, &header, sizeof(MIDIHDR));
 460                 if (result != MMSYSERR_NOERROR) {
 461                         DEBUG_MIDI (string_compose ("WinMMEMidiOutput: midiOutLongMsg %1\n",
 462                                                     get_error_string (result)));
 463                         continue;
 464                 }
 465
 466                 // Sysex messages may be sent synchronously or asynchronously.  The
 467                 // choice is up to the WinMME driver.  So, we wait until the message is
 468                 // sent, regardless of the driver's choice.
 469                 if (!wait (m_sysex_semaphore)) {
 470                         break;
 471                 }
 472
 473                 result = midiOutUnprepareHeader (m_handle, &header, sizeof(MIDIHDR));
 474                 if (result != MMSYSERR_NOERROR) {
 475                         DEBUG_MIDI (string_compose ("WinMMEMidiOutput: midiOutUnprepareHeader %1\n",
 476                                                     get_error_string (result)));
 477                         break;
 478                 }
 479 #endif
 480         }
 481
 482 #ifdef USE_MMCSS_THREAD_PRIORITIES
 483         mmcss::revert_thread_characteristics (task_handle);
 484 #endif
 485
 486         m_thread_running = false;
 487 }
 488
 489 bool
 490 WinMMEMidiOutputDevice::wait_for_microseconds (int64_t wait_us)
 491 {
 492         LARGE_INTEGER due_time;
 493
 494         // 100 ns resolution
 495         due_time.QuadPart = -((LONGLONG)(wait_us * 10));
 496         if (!SetWaitableTimer (m_timer, &due_time, 0, NULL, NULL, 0)) {
 497                 DEBUG_MIDI ("WinMMEMidiOut: Error waiting for timer\n");
 498                 return false;
 499         }
 500
 501         if (!wait (m_timer)) {
 502                 return false;
 503         }
 504
 505         return true;
 506 }
 507
 508 } // namespace ARDOUR