dlls/winealsa.drv/midi.c

   1 /*
   2  * MIDI driver for ALSA (PE-side)
   3  *
   4  * Copyright 1994       Martin Ayotte
   5  * Copyright 1998       Luiz Otavio L. Zorzella
   6  * Copyright 1998, 1999 Eric POUECH
   7  * Copyright 2003       Christian Costa
   8  * Copyright 2022       Huw Davies
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <errno.h>
  33
  34 #include "ntstatus.h"
  35 #define WIN32_NO_STATUS
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "wingdi.h"
  39 #include "winternl.h"
  40 #include "mmddk.h"
  41 #include "mmdeviceapi.h"
  42
  43 #include "wine/debug.h"
  44 #include "wine/unixlib.h"
  45
  46 #include "unixlib.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(midi);
  49
  50 static WINE_MIDIIN      *MidiInDev;
  51 static WINE_MIDIOUT     *MidiOutDev;
  52
  53 /* this is the total number of MIDI out devices found (synth and port) */
  54 static  int             MODM_NumDevs = 0;
  55 /* this is the total number of MIDI out devices found */
  56 static  int             MIDM_NumDevs = 0;
  57
  58 static  int             numStartedMidiIn = 0;
  59
  60 static CRITICAL_SECTION crit_sect;   /* protects all MidiIn buffer queues */
  61 static CRITICAL_SECTION_DEBUG critsect_debug =
  62 {
  63     0, 0, &crit_sect,
  64     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  65       0, 0, { (DWORD_PTR)(__FILE__ ": crit_sect") }
  66 };
  67 static CRITICAL_SECTION crit_sect = { &critsect_debug, -1, 0, 0, 0, 0 };
  68
  69 static int end_thread;
  70 static HANDLE hThread;
  71
  72 static void seq_lock(void)
  73 {
  74     ALSA_CALL(midi_seq_lock, (void *)(UINT_PTR)1);
  75 }
  76
  77 static void seq_unlock(void)
  78 {
  79     ALSA_CALL(midi_seq_lock, (void *)(UINT_PTR)0);
  80 }
  81
  82 static void notify_client(struct notify_context *notify)
  83 {
  84     TRACE("dev_id = %d msg = %d param1 = %04lX param2 = %04lX\n", notify->dev_id, notify->msg, notify->param_1, notify->param_2);
  85
  86     DriverCallback(notify->callback, notify->flags, notify->device, notify->msg,
  87                    notify->instance, notify->param_1, notify->param_2);
  88 }
  89
  90 /*======================================================================*
  91  *                  Low level MIDI implementation                       *
  92  *======================================================================*/
  93
  94 #if 0 /* Debug Purpose */
  95 static void error_handler(const char* file, int line, const char* function, int err, const char* fmt, ...)
  96 {
  97     va_list arg;
  98     if (err == ENOENT)
  99         return;
 100     va_start(arg, fmt);
 101     fprintf(stderr, "ALSA lib %s:%i:(%s) ", file, line, function);
 102     vfprintf(stderr, fmt, arg);
 103     if (err)
 104         fprintf(stderr, ": %s", snd_strerror(err));
 105     putc('\n', stderr);
 106     va_end(arg);
 107 }
 108 #endif
 109
 110 /**************************************************************************
 111  *                      MIDI_NotifyClient                       [internal]
 112  */
 113 static void MIDI_NotifyClient(UINT wDevID, WORD wMsg,
 114                               DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 115 {
 116     DWORD_PTR           dwCallBack;
 117     UINT                uFlags;
 118     HANDLE              hDev;
 119     DWORD_PTR           dwInstance;
 120
 121     TRACE("wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
 122           wDevID, wMsg, dwParam1, dwParam2);
 123
 124     switch (wMsg) {
 125     case MIM_OPEN:
 126     case MIM_CLOSE:
 127     case MIM_DATA:
 128     case MIM_LONGDATA:
 129     case MIM_ERROR:
 130     case MIM_LONGERROR:
 131     case MIM_MOREDATA:
 132         if (wDevID > MIDM_NumDevs) return;
 133
 134         dwCallBack = MidiInDev[wDevID].midiDesc.dwCallback;
 135         uFlags = MidiInDev[wDevID].wFlags;
 136         hDev = MidiInDev[wDevID].midiDesc.hMidi;
 137         dwInstance = MidiInDev[wDevID].midiDesc.dwInstance;
 138         break;
 139     default:
 140         ERR("Unsupported MSW-MIDI message %u\n", wMsg);
 141         return;
 142     }
 143
 144     DriverCallback(dwCallBack, uFlags, hDev, wMsg, dwInstance, dwParam1, dwParam2);
 145 }
 146
 147 /**************************************************************************
 148  *                      midiOpenSeq                             [internal]
 149  */
 150 static snd_seq_t *midiOpenSeq(int *port_in_ret)
 151 {
 152     struct midi_seq_open_params params;
 153
 154     params.port_in = port_in_ret;
 155     params.close = 0;
 156     ALSA_CALL(midi_seq_open, &params);
 157
 158     return params.seq;
 159 }
 160
 161 /**************************************************************************
 162  *                      midiCloseSeq                            [internal]
 163  */
 164 static int midiCloseSeq(void)
 165 {
 166     struct midi_seq_open_params params;
 167
 168     params.port_in = NULL;
 169     params.close = 1;
 170     ALSA_CALL(midi_seq_open, &params);
 171
 172     return 0;
 173 }
 174
 175 static void handle_midi_event(snd_seq_event_t *ev)
 176 {
 177     WORD wDevID;
 178
 179     /* Find the target device */
 180     for (wDevID = 0; wDevID < MIDM_NumDevs; wDevID++)
 181         if ( (ev->source.client == MidiInDev[wDevID].addr.client) && (ev->source.port == MidiInDev[wDevID].addr.port) )
 182             break;
 183     if ((wDevID == MIDM_NumDevs) || (MidiInDev[wDevID].state != 1))
 184         FIXME("Unexpected event received, type = %x from %d:%d\n", ev->type, ev->source.client, ev->source.port);
 185     else {
 186         DWORD dwTime, toSend = 0;
 187         int value = 0;
 188         /* FIXME: Should use ev->time instead for better accuracy */
 189         dwTime = GetTickCount() - MidiInDev[wDevID].startTime;
 190         TRACE("Event received, type = %x, device = %d\n", ev->type, wDevID);
 191         switch(ev->type)
 192         {
 193         case SND_SEQ_EVENT_NOTEOFF:
 194             toSend = (ev->data.note.velocity << 16) | (ev->data.note.note << 8) | MIDI_CMD_NOTE_OFF | ev->data.control.channel;
 195             break;
 196         case SND_SEQ_EVENT_NOTEON:
 197             toSend = (ev->data.note.velocity << 16) | (ev->data.note.note << 8) | MIDI_CMD_NOTE_ON | ev->data.control.channel;
 198             break;
 199         case SND_SEQ_EVENT_KEYPRESS:
 200             toSend = (ev->data.note.velocity << 16) | (ev->data.note.note << 8) | MIDI_CMD_NOTE_PRESSURE | ev->data.control.channel;
 201             break;
 202         case SND_SEQ_EVENT_CONTROLLER:
 203             toSend = (ev->data.control.value << 16) | (ev->data.control.param << 8) | MIDI_CMD_CONTROL | ev->data.control.channel;
 204             break;
 205         case SND_SEQ_EVENT_PITCHBEND:
 206             value = ev->data.control.value + 0x2000;
 207             toSend = (((value >> 7) & 0x7f) << 16) | ((value & 0x7f) << 8) | MIDI_CMD_BENDER | ev->data.control.channel;
 208             break;
 209         case SND_SEQ_EVENT_PGMCHANGE:
 210             toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_PGM_CHANGE | ev->data.control.channel;
 211             break;
 212         case SND_SEQ_EVENT_CHANPRESS:
 213             toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_CHANNEL_PRESSURE | ev->data.control.channel;
 214             break;
 215         case SND_SEQ_EVENT_CLOCK:
 216             toSend = 0xF8;
 217             break;
 218         case SND_SEQ_EVENT_START:
 219             toSend = 0xFA;
 220             break;
 221         case SND_SEQ_EVENT_CONTINUE:
 222             toSend = 0xFB;
 223             break;
 224         case SND_SEQ_EVENT_STOP:
 225             toSend = 0xFC;
 226             break;
 227         case SND_SEQ_EVENT_SONGPOS:
 228             toSend = (((ev->data.control.value >> 7) & 0x7f) << 16) | ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_COMMON_SONG_POS;
 229             break;
 230         case SND_SEQ_EVENT_SONGSEL:
 231           toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_COMMON_SONG_SELECT;
 232             break;
 233         case SND_SEQ_EVENT_RESET:
 234             toSend = 0xFF;
 235             break;
 236         case SND_SEQ_EVENT_QFRAME:
 237           toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_COMMON_MTC_QUARTER;
 238             break;
 239         case SND_SEQ_EVENT_SYSEX:
 240             {
 241                 int pos = 0;
 242                 int len = ev->data.ext.len;
 243                 LPBYTE ptr = ev->data.ext.ptr;
 244                 LPMIDIHDR lpMidiHdr;
 245
 246                 EnterCriticalSection(&crit_sect);
 247                 while (len) {
 248                     if ((lpMidiHdr = MidiInDev[wDevID].lpQueueHdr) != NULL) {
 249                         int copylen = min(len, lpMidiHdr->dwBufferLength - lpMidiHdr->dwBytesRecorded);
 250                         memcpy(lpMidiHdr->lpData + lpMidiHdr->dwBytesRecorded, ptr + pos, copylen);
 251                         lpMidiHdr->dwBytesRecorded += copylen;
 252                         len -= copylen;
 253                         pos += copylen;
 254                         /* We check if we reach the end of buffer or the end of sysex before notifying
 255                          * to handle the case where ALSA split the sysex into several events */
 256                         if ((lpMidiHdr->dwBytesRecorded == lpMidiHdr->dwBufferLength) ||
 257                             (*(BYTE*)(lpMidiHdr->lpData + lpMidiHdr->dwBytesRecorded - 1) == 0xF7)) {
 258                             MidiInDev[wDevID].lpQueueHdr = lpMidiHdr->lpNext;
 259                             lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
 260                             lpMidiHdr->dwFlags |= MHDR_DONE;
 261                             MIDI_NotifyClient(wDevID, MIM_LONGDATA, (DWORD_PTR)lpMidiHdr, dwTime);
 262                         }
 263                     } else {
 264                         FIXME("Sysex data received but no buffer to store it!\n");
 265                         break;
 266                     }
 267                 }
 268                 LeaveCriticalSection(&crit_sect);
 269             }
 270             break;
 271         case SND_SEQ_EVENT_SENSING:
 272             /* Noting to do */
 273             break;
 274         default:
 275             FIXME("Unhandled event received, type = %x\n", ev->type);
 276             break;
 277         }
 278         if (toSend != 0) {
 279             TRACE("Received event %08x from %d:%d\n", toSend, ev->source.client, ev->source.port);
 280             MIDI_NotifyClient(wDevID, MIM_DATA, toSend, dwTime);
 281         }
 282     }
 283 }
 284
 285 static DWORD WINAPI midRecThread(void *arg)
 286 {
 287     snd_seq_t *midi_seq = arg;
 288     int npfd;
 289     struct pollfd *pfd;
 290     int ret;
 291
 292     TRACE("Thread startup\n");
 293
 294     while(!end_thread) {
 295         TRACE("Thread loop\n");
 296         seq_lock();
 297         npfd = snd_seq_poll_descriptors_count(midi_seq, POLLIN);
 298         pfd = HeapAlloc(GetProcessHeap(), 0, npfd * sizeof(struct pollfd));
 299         snd_seq_poll_descriptors(midi_seq, pfd, npfd, POLLIN);
 300         seq_unlock();
 301
 302         /* Check if an event is present */
 303         if (poll(pfd, npfd, 250) <= 0) {
 304             HeapFree(GetProcessHeap(), 0, pfd);
 305             continue;
 306         }
 307
 308         /* Note: This definitely does not work.
 309          * while(snd_seq_event_input_pending(midi_seq, 0) > 0) {
 310                snd_seq_event_t* ev;
 311                snd_seq_event_input(midi_seq, &ev);
 312                ....................
 313                snd_seq_free_event(ev);
 314            }*/
 315
 316         do {
 317             snd_seq_event_t *ev;
 318
 319             seq_lock();
 320             snd_seq_event_input(midi_seq, &ev);
 321             seq_unlock();
 322
 323             if (ev) {
 324                 handle_midi_event(ev);
 325                 snd_seq_free_event(ev);
 326             }
 327
 328             seq_lock();
 329             ret = snd_seq_event_input_pending(midi_seq, 0);
 330             seq_unlock();
 331         } while(ret > 0);
 332
 333         HeapFree(GetProcessHeap(), 0, pfd);
 334     }
 335     return 0;
 336 }
 337
 338 /**************************************************************************
 339  *                              midGetDevCaps                   [internal]
 340  */
 341 static DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPSW lpCaps, DWORD dwSize)
 342 {
 343     TRACE("(%04X, %p, %08X);\n", wDevID, lpCaps, dwSize);
 344
 345     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 346     if (lpCaps == NULL)         return MMSYSERR_INVALPARAM;
 347
 348     memcpy(lpCaps, &MidiInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
 349
 350     return MMSYSERR_NOERROR;
 351 }
 352
 353
 354 /**************************************************************************
 355  *                      midOpen                                 [internal]
 356  */
 357 static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 358 {
 359     int ret = 0, port_in;
 360     snd_seq_t *midi_seq;
 361
 362     TRACE("(%04X, %p, %08X);\n", wDevID, lpDesc, dwFlags);
 363
 364     if (lpDesc == NULL) {
 365         WARN("Invalid Parameter !\n");
 366         return MMSYSERR_INVALPARAM;
 367     }
 368
 369     /* FIXME :
 370      *  how to check that content of lpDesc is correct ?
 371      */
 372     if (wDevID >= MIDM_NumDevs) {
 373         WARN("wDevID too large (%u) !\n", wDevID);
 374         return MMSYSERR_BADDEVICEID;
 375     }
 376     if (MidiInDev[wDevID].state == -1) {
 377         WARN("device disabled\n");
 378         return MIDIERR_NODEVICE;
 379     }
 380     if (MidiInDev[wDevID].midiDesc.hMidi != 0) {
 381         WARN("device already open !\n");
 382         return MMSYSERR_ALLOCATED;
 383     }
 384     if ((dwFlags & MIDI_IO_STATUS) != 0) {
 385         WARN("No support for MIDI_IO_STATUS in dwFlags yet, ignoring it\n");
 386         dwFlags &= ~MIDI_IO_STATUS;
 387     }
 388     if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) {
 389         FIXME("Bad dwFlags\n");
 390         return MMSYSERR_INVALFLAG;
 391     }
 392
 393     if (!(midi_seq = midiOpenSeq(&port_in))) {
 394         return MMSYSERR_ERROR;
 395     }
 396
 397     MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 398
 399     MidiInDev[wDevID].lpQueueHdr = NULL;
 400     MidiInDev[wDevID].midiDesc = *lpDesc;
 401     MidiInDev[wDevID].state = 0;
 402     MidiInDev[wDevID].startTime = 0;
 403     MidiInDev[wDevID].seq = midi_seq;
 404     MidiInDev[wDevID].port_in = port_in;
 405
 406     /* Connect our app port to the device port */
 407     seq_lock();
 408     ret = snd_seq_connect_from(midi_seq, port_in, MidiInDev[wDevID].addr.client,
 409                                MidiInDev[wDevID].addr.port);
 410     seq_unlock();
 411     if (ret < 0)
 412         return MMSYSERR_NOTENABLED;
 413
 414     TRACE("Input port :%d connected %d:%d\n",port_in,MidiInDev[wDevID].addr.client,MidiInDev[wDevID].addr.port);
 415
 416     if (numStartedMidiIn++ == 0) {
 417         end_thread = 0;
 418         hThread = CreateThread(NULL, 0, midRecThread, midi_seq, 0, NULL);
 419         if (!hThread) {
 420             numStartedMidiIn = 0;
 421             WARN("Couldn't create thread for midi-in\n");
 422             midiCloseSeq();
 423             return MMSYSERR_ERROR;
 424         }
 425         SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
 426         TRACE("Created thread for midi-in\n");
 427     }
 428
 429     MIDI_NotifyClient(wDevID, MIM_OPEN, 0L, 0L);
 430     return MMSYSERR_NOERROR;
 431 }
 432
 433 /**************************************************************************
 434  *                      midClose                                [internal]
 435  */
 436 static DWORD midClose(WORD wDevID)
 437 {
 438     int         ret = MMSYSERR_NOERROR;
 439
 440     TRACE("(%04X);\n", wDevID);
 441
 442     if (wDevID >= MIDM_NumDevs) {
 443         WARN("wDevID too big (%u) !\n", wDevID);
 444         return MMSYSERR_BADDEVICEID;
 445     }
 446     if (MidiInDev[wDevID].midiDesc.hMidi == 0) {
 447         WARN("device not opened !\n");
 448         return MMSYSERR_ERROR;
 449     }
 450     if (MidiInDev[wDevID].lpQueueHdr != 0) {
 451         return MIDIERR_STILLPLAYING;
 452     }
 453
 454     if (MidiInDev[wDevID].seq == NULL) {
 455         WARN("ooops !\n");
 456         return MMSYSERR_ERROR;
 457     }
 458     if (--numStartedMidiIn == 0) {
 459         TRACE("Stopping thread for midi-in\n");
 460         end_thread = 1;
 461         if (WaitForSingleObject(hThread, 5000) != WAIT_OBJECT_0) {
 462             WARN("Thread end not signaled, force termination\n");
 463             TerminateThread(hThread, 0);
 464         }
 465         TRACE("Stopped thread for midi-in\n");
 466     }
 467
 468     seq_lock();
 469     snd_seq_disconnect_from(MidiInDev[wDevID].seq, MidiInDev[wDevID].port_in, MidiInDev[wDevID].addr.client, MidiInDev[wDevID].addr.port);
 470     seq_unlock();
 471     midiCloseSeq();
 472
 473     MIDI_NotifyClient(wDevID, MIM_CLOSE, 0L, 0L);
 474     MidiInDev[wDevID].midiDesc.hMidi = 0;
 475     MidiInDev[wDevID].seq = NULL;
 476
 477     return ret;
 478 }
 479
 480
 481 /**************************************************************************
 482  *                              midAddBuffer                    [internal]
 483  */
 484 static DWORD midAddBuffer(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 485 {
 486     TRACE("(%04X, %p, %d);\n", wDevID, lpMidiHdr, dwSize);
 487
 488     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 489     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 490
 491     if (lpMidiHdr == NULL)      return MMSYSERR_INVALPARAM;
 492     if (dwSize < offsetof(MIDIHDR,dwOffset)) return MMSYSERR_INVALPARAM;
 493     if (lpMidiHdr->dwBufferLength == 0) return MMSYSERR_INVALPARAM;
 494     if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
 495     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
 496
 497     EnterCriticalSection(&crit_sect);
 498     lpMidiHdr->dwFlags &= ~WHDR_DONE;
 499     lpMidiHdr->dwFlags |= MHDR_INQUEUE;
 500     lpMidiHdr->dwBytesRecorded = 0;
 501     lpMidiHdr->lpNext = 0;
 502     if (MidiInDev[wDevID].lpQueueHdr == 0) {
 503         MidiInDev[wDevID].lpQueueHdr = lpMidiHdr;
 504     } else {
 505         LPMIDIHDR       ptr;
 506
 507         for (ptr = MidiInDev[wDevID].lpQueueHdr; ptr->lpNext != 0;
 508              ptr = ptr->lpNext);
 509         ptr->lpNext = lpMidiHdr;
 510     }
 511     LeaveCriticalSection(&crit_sect);
 512
 513     return MMSYSERR_NOERROR;
 514 }
 515
 516 /**************************************************************************
 517  *                              midPrepare                      [internal]
 518  */
 519 static DWORD midPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 520 {
 521     TRACE("(%04X, %p, %d);\n", wDevID, lpMidiHdr, dwSize);
 522
 523     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 || lpMidiHdr->lpData == 0)
 524         return MMSYSERR_INVALPARAM;
 525     if (lpMidiHdr->dwFlags & MHDR_PREPARED)
 526         return MMSYSERR_NOERROR;
 527
 528     lpMidiHdr->lpNext = 0;
 529     lpMidiHdr->dwFlags |= MHDR_PREPARED;
 530     lpMidiHdr->dwFlags &= ~(MHDR_DONE|MHDR_INQUEUE); /* flags cleared since w2k */
 531
 532     return MMSYSERR_NOERROR;
 533 }
 534
 535 /**************************************************************************
 536  *                              midUnprepare                    [internal]
 537  */
 538 static DWORD midUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 539 {
 540     TRACE("(%04X, %p, %d);\n", wDevID, lpMidiHdr, dwSize);
 541
 542     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 || lpMidiHdr->lpData == 0)
 543         return MMSYSERR_INVALPARAM;
 544     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
 545         return MMSYSERR_NOERROR;
 546     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
 547         return MIDIERR_STILLPLAYING;
 548
 549     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
 550
 551     return MMSYSERR_NOERROR;
 552 }
 553
 554 /**************************************************************************
 555  *                      midReset                                [internal]
 556  */
 557 static DWORD midReset(WORD wDevID)
 558 {
 559     DWORD               dwTime = GetTickCount();
 560
 561     TRACE("(%04X);\n", wDevID);
 562
 563     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 564     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 565
 566     EnterCriticalSection(&crit_sect);
 567     while (MidiInDev[wDevID].lpQueueHdr) {
 568         LPMIDIHDR lpMidiHdr = MidiInDev[wDevID].lpQueueHdr;
 569         MidiInDev[wDevID].lpQueueHdr = lpMidiHdr->lpNext;
 570         lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
 571         lpMidiHdr->dwFlags |= MHDR_DONE;
 572         MIDI_NotifyClient(wDevID, MIM_LONGDATA, (DWORD_PTR)lpMidiHdr, dwTime);
 573     }
 574     LeaveCriticalSection(&crit_sect);
 575
 576     return MMSYSERR_NOERROR;
 577 }
 578
 579 /**************************************************************************
 580  *                      midStart                                [internal]
 581  */
 582 static DWORD midStart(WORD wDevID)
 583 {
 584     TRACE("(%04X);\n", wDevID);
 585
 586     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 587     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 588
 589     MidiInDev[wDevID].state = 1;
 590     MidiInDev[wDevID].startTime = GetTickCount();
 591     return MMSYSERR_NOERROR;
 592 }
 593
 594 /**************************************************************************
 595  *                      midStop                                 [internal]
 596  */
 597 static DWORD midStop(WORD wDevID)
 598 {
 599     TRACE("(%04X);\n", wDevID);
 600
 601     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 602     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 603
 604     MidiInDev[wDevID].state = 0;
 605     return MMSYSERR_NOERROR;
 606 }
 607
 608 /**************************************************************************
 609  *                              modGetDevCaps                   [internal]
 610  */
 611 static DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPSW lpCaps, DWORD dwSize)
 612 {
 613     TRACE("(%04X, %p, %08X);\n", wDevID, lpCaps, dwSize);
 614
 615     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
 616     if (lpCaps == NULL)         return MMSYSERR_INVALPARAM;
 617
 618     memcpy(lpCaps, &MidiOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
 619
 620     return MMSYSERR_NOERROR;
 621 }
 622
 623 /**************************************************************************
 624  *                      modGetVolume                            [internal]
 625  */
 626 static DWORD modGetVolume(WORD wDevID, DWORD* lpdwVolume)
 627 {
 628     if (!lpdwVolume) return MMSYSERR_INVALPARAM;
 629     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
 630     *lpdwVolume = 0xFFFFFFFF;
 631     return (MidiOutDev[wDevID].caps.dwSupport & MIDICAPS_VOLUME) ? 0 : MMSYSERR_NOTSUPPORTED;
 632 }
 633
 634 /**************************************************************************
 635  *                      modReset                                [internal]
 636  */
 637 static DWORD modReset(WORD wDevID)
 638 {
 639     DWORD WINAPI ALSA_modMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
 640                                  DWORD_PTR dwParam1, DWORD_PTR dwParam2);
 641     unsigned chn;
 642
 643     TRACE("(%04X);\n", wDevID);
 644
 645     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
 646     if (!MidiOutDev[wDevID].bEnabled) return MIDIERR_NODEVICE;
 647
 648     /* stop all notes */
 649     /* FIXME: check if 0x78B0 is channel dependent or not. I coded it so that
 650      * it's channel dependent...
 651      */
 652     for (chn = 0; chn < 16; chn++) {
 653         /* turn off every note */
 654         ALSA_modMessage(wDevID, MODM_DATA, 0, 0x7800 | MIDI_CMD_CONTROL | chn, 0);
 655         /* remove sustain on all channels */
 656         ALSA_modMessage(wDevID, MODM_DATA, 0, (MIDI_CTL_SUSTAIN << 8) | MIDI_CMD_CONTROL | chn, 0);
 657     }
 658     /* FIXME: the LongData buffers must also be returned to the app */
 659     return MMSYSERR_NOERROR;
 660 }
 661
 662
 663 /*======================================================================*
 664  *                          MIDI entry points                           *
 665  *======================================================================*/
 666
 667 /**************************************************************************
 668  * ALSA_MidiInit                                [internal]
 669  *
 670  * Initializes the MIDI devices information variables
 671  */
 672 static BOOL ALSA_MidiInit(void)
 673 {
 674     struct midi_init_params params;
 675     UINT err;
 676
 677     params.err = &err;
 678     ALSA_CALL(midi_init, &params);
 679
 680     if (!err)
 681     {
 682         MODM_NumDevs = params.num_dests;
 683         MIDM_NumDevs = params.num_srcs;
 684         MidiOutDev = params.dests;
 685         MidiInDev = params.srcs;
 686     }
 687     return TRUE;
 688 }
 689
 690 /**************************************************************************
 691  *                      midMessage (WINEALSA.@)
 692  */
 693 DWORD WINAPI ALSA_midMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
 694                             DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 695 {
 696     TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
 697           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 698     switch (wMsg) {
 699     case DRVM_INIT:
 700         ALSA_MidiInit();
 701         return 0;
 702     case DRVM_EXIT:
 703     case DRVM_ENABLE:
 704     case DRVM_DISABLE:
 705         /* FIXME: Pretend this is supported */
 706         return 0;
 707     case MIDM_OPEN:
 708         return midOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
 709     case MIDM_CLOSE:
 710         return midClose(wDevID);
 711     case MIDM_ADDBUFFER:
 712         return midAddBuffer(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 713     case MIDM_PREPARE:
 714         return midPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 715     case MIDM_UNPREPARE:
 716         return midUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
 717     case MIDM_GETDEVCAPS:
 718         return midGetDevCaps(wDevID, (LPMIDIINCAPSW)dwParam1,dwParam2);
 719     case MIDM_GETNUMDEVS:
 720         return MIDM_NumDevs;
 721     case MIDM_RESET:
 722         return midReset(wDevID);
 723     case MIDM_START:
 724         return midStart(wDevID);
 725     case MIDM_STOP:
 726         return midStop(wDevID);
 727     default:
 728         TRACE("Unsupported message\n");
 729     }
 730     return MMSYSERR_NOTSUPPORTED;
 731 }
 732
 733 /**************************************************************************
 734  *                              modMessage (WINEALSA.@)
 735  */
 736 DWORD WINAPI ALSA_modMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
 737                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 738 {
 739     struct midi_out_message_params params;
 740     struct notify_context notify;
 741     UINT err;
 742
 743     TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
 744           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 745
 746     switch (wMsg) {
 747     case DRVM_INIT:
 748         ALSA_MidiInit();
 749         return 0;
 750     case MODM_GETDEVCAPS:
 751         return modGetDevCaps(wDevID, (LPMIDIOUTCAPSW)dwParam1, dwParam2);
 752     case MODM_GETNUMDEVS:
 753         return MODM_NumDevs;
 754     case MODM_GETVOLUME:
 755         return modGetVolume(wDevID, (DWORD*)dwParam1);
 756     case MODM_SETVOLUME:
 757         return 0;
 758     case MODM_RESET:
 759         return modReset(wDevID);
 760     }
 761
 762     params.dev_id = wDevID;
 763     params.msg = wMsg;
 764     params.user = dwUser;
 765     params.param_1 = dwParam1;
 766     params.param_2 = dwParam2;
 767     params.err = &err;
 768     params.notify = &notify;
 769
 770     ALSA_CALL(midi_out_message, &params);
 771
 772     if (!err && notify.send_notify) notify_client(&notify);
 773
 774     return err;
 775 }
 776
 777 /**************************************************************************
 778  *                              DriverProc (WINEALSA.@)
 779  */
 780 LRESULT CALLBACK ALSA_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 781                                  LPARAM dwParam1, LPARAM dwParam2)
 782 {
 783 /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
 784 /* EPP    dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
 785
 786     switch(wMsg) {
 787     case DRV_LOAD:
 788     case DRV_FREE:
 789     case DRV_OPEN:
 790     case DRV_CLOSE:
 791     case DRV_ENABLE:
 792     case DRV_DISABLE:
 793     case DRV_QUERYCONFIGURE:
 794     case DRV_CONFIGURE:
 795         return 1;
 796     case DRV_INSTALL:
 797     case DRV_REMOVE:
 798         return DRV_SUCCESS;
 799     default:
 800         return 0;
 801     }
 802 }