git.oblomov.eu Git - wine/blob - dlls/winealsa.drv/midi.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * Sample MIDI Wine Driver for ALSA (basically Linux)
   5  *
   6  * Copyright 1994       Martin Ayotte
   7  * Copyright 1998       Luiz Otavio L. Zorzella (init procedures)
   8  * Copyright 1998/1999  Eric POUECH :
   9  *              98/7    changes for making this MIDI driver work on OSS
  10  *                      current support is limited to MIDI ports of OSS systems
  11  *              98/9    rewriting MCI code for MIDI
  12  *              98/11   split in midi.c and mcimidi.c
  13  * Copyright 2003      Christian Costa :
  14  *                     ALSA port
  15  *
  16  * This library is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU Lesser General Public
  18  * License as published by the Free Software Foundation; either
  19  * version 2.1 of the License, or (at your option) any later version.
  20  *
  21  * This library is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  * Lesser General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU Lesser General Public
  27  * License along with this library; if not, write to the Free Software
  28  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  29  *
  30  * TODO: Finish midi record
  31  *
  32  */
  33
  34 #include "config.h"
  35
  36 #include <string.h>
  37 #include <stdarg.h>
  38 #include <stdio.h>
  39 #ifdef HAVE_UNISTD_H
  40 # include <unistd.h>
  41 #endif
  42 #include <fcntl.h>
  43 #include <errno.h>
  44
  45 #include "windef.h"
  46 #include "winbase.h"
  47 #include "wingdi.h"
  48 #include "winuser.h"
  49 #include "winnls.h"
  50 #include "mmddk.h"
  51 #include "mmreg.h"
  52 #include "dsound.h"
  53 #include "wine/debug.h"
  54
  55 #include <alsa/asoundlib.h>
  56
  57 WINE_DEFAULT_DEBUG_CHANNEL(midi);
  58
  59 #ifndef SND_SEQ_PORT_TYPE_PORT
  60 #define SND_SEQ_PORT_TYPE_PORT (1<<19)  /* Appears in version 1.0.12rc1 */
  61 #endif
  62
  63 typedef struct {
  64     int                 state;                  /* -1 disabled, 0 is no recording started, 1 in recording, bit 2 set if in sys exclusive recording */
  65     DWORD               bufsize;
  66     MIDIOPENDESC        midiDesc;
  67     WORD                wFlags;
  68     LPMIDIHDR           lpQueueHdr;
  69     DWORD               dwTotalPlayed;
  70     unsigned char       incoming[3];
  71     unsigned char       incPrev;
  72     char                incLen;
  73     DWORD               startTime;
  74     MIDIINCAPSW         caps;
  75     snd_seq_addr_t      addr;
  76 } WINE_MIDIIN;
  77
  78 typedef struct {
  79     BOOL                bEnabled;
  80     DWORD               bufsize;
  81     MIDIOPENDESC        midiDesc;
  82     WORD                wFlags;
  83     LPMIDIHDR           lpQueueHdr;
  84     DWORD               dwTotalPlayed;
  85     void*               lpExtra;                /* according to port type (MIDI, FM...), extra data when needed */
  86     MIDIOUTCAPSW        caps;
  87     snd_seq_addr_t      addr;
  88 } WINE_MIDIOUT;
  89
  90 static WINE_MIDIIN      MidiInDev [MAX_MIDIINDRV ];
  91 static WINE_MIDIOUT     MidiOutDev[MAX_MIDIOUTDRV];
  92
  93 /* this is the total number of MIDI out devices found (synth and port) */
  94 static  int             MODM_NumDevs = 0;
  95 /* this is the total number of MIDI out devices found */
  96 static  int             MIDM_NumDevs = 0;
  97
  98 static  snd_seq_t*      midiSeq = NULL;
  99 static  int             numOpenMidiSeq = 0;
 100 static  int             numStartedMidiIn = 0;
 101
 102 static int port_in;
 103 static int port_out;
 104
 105 static CRITICAL_SECTION crit_sect;   /* protects all MidiIn buffer queues */
 106 static CRITICAL_SECTION_DEBUG critsect_debug =
 107 {
 108     0, 0, &crit_sect,
 109     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 110       0, 0, { (DWORD_PTR)(__FILE__ ": crit_sect") }
 111 };
 112 static CRITICAL_SECTION crit_sect = { &critsect_debug, -1, 0, 0, 0, 0 };
 113
 114 static int end_thread;
 115 static HANDLE hThread;
 116
 117 /*======================================================================*
 118  *                  Low level MIDI implementation                       *
 119  *======================================================================*/
 120
 121 static int midiOpenSeq(int);
 122 static int midiCloseSeq(void);
 123
 124 #if 0 /* Debug Purpose */
 125 static void error_handler(const char* file, int line, const char* function, int err, const char* fmt, ...)
 126 {
 127     va_list arg;
 128     if (err == ENOENT)
 129         return;
 130     va_start(arg, fmt);
 131     fprintf(stderr, "ALSA lib %s:%i:(%s) ", file, line, function);
 132     vfprintf(stderr, fmt, arg);
 133     if (err)
 134         fprintf(stderr, ": %s", snd_strerror(err));
 135     putc('\n', stderr);
 136     va_end(arg);
 137 }
 138 #endif
 139
 140 /**************************************************************************
 141  *                      MIDI_unixToWindowsDeviceType            [internal]
 142  *
 143  * return the Windows equivalent to a Unix Device Type
 144  *
 145  */
 146 static  int     MIDI_AlsaToWindowsDeviceType(unsigned int type)
 147 {
 148     /* MOD_MIDIPORT     output port
 149      * MOD_SYNTH        generic internal synth
 150      * MOD_SQSYNTH      square wave internal synth
 151      * MOD_FMSYNTH      FM internal synth
 152      * MOD_MAPPER       MIDI mapper
 153      * MOD_WAVETABLE    hardware wavetable internal synth
 154      * MOD_SWSYNTH      software internal synth
 155      */
 156
 157     /* FIXME Is this really the correct equivalence from ALSA to
 158        Windows Sound type? */
 159
 160     if (type & SND_SEQ_PORT_TYPE_SYNTH)
 161         return MOD_FMSYNTH;
 162
 163     if (type & (SND_SEQ_PORT_TYPE_DIRECT_SAMPLE|SND_SEQ_PORT_TYPE_SAMPLE))
 164         return MOD_SYNTH;
 165
 166     if (type & (SND_SEQ_PORT_TYPE_MIDI_GENERIC|SND_SEQ_PORT_TYPE_APPLICATION))
 167         return MOD_MIDIPORT;
 168
 169     ERR("Cannot determine the type (alsa type is %x) of this midi device. Assuming FM Synth\n", type);
 170     return MOD_FMSYNTH;
 171 }
 172
 173 /**************************************************************************
 174  *                      MIDI_NotifyClient                       [internal]
 175  */
 176 static void MIDI_NotifyClient(UINT wDevID, WORD wMsg,
 177                               DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 178 {
 179     DWORD_PTR           dwCallBack;
 180     UINT                uFlags;
 181     HANDLE              hDev;
 182     DWORD_PTR           dwInstance;
 183
 184     TRACE("wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
 185           wDevID, wMsg, dwParam1, dwParam2);
 186
 187     switch (wMsg) {
 188     case MOM_OPEN:
 189     case MOM_CLOSE:
 190     case MOM_DONE:
 191     case MOM_POSITIONCB:
 192         if (wDevID > MODM_NumDevs) return;
 193
 194         dwCallBack = MidiOutDev[wDevID].midiDesc.dwCallback;
 195         uFlags = MidiOutDev[wDevID].wFlags;
 196         hDev = MidiOutDev[wDevID].midiDesc.hMidi;
 197         dwInstance = MidiOutDev[wDevID].midiDesc.dwInstance;
 198         break;
 199
 200     case MIM_OPEN:
 201     case MIM_CLOSE:
 202     case MIM_DATA:
 203     case MIM_LONGDATA:
 204     case MIM_ERROR:
 205     case MIM_LONGERROR:
 206     case MIM_MOREDATA:
 207         if (wDevID > MIDM_NumDevs) return;
 208
 209         dwCallBack = MidiInDev[wDevID].midiDesc.dwCallback;
 210         uFlags = MidiInDev[wDevID].wFlags;
 211         hDev = MidiInDev[wDevID].midiDesc.hMidi;
 212         dwInstance = MidiInDev[wDevID].midiDesc.dwInstance;
 213         break;
 214     default:
 215         ERR("Unsupported MSW-MIDI message %u\n", wMsg);
 216         return;
 217     }
 218
 219     DriverCallback(dwCallBack, uFlags, hDev, wMsg, dwInstance, dwParam1, dwParam2);
 220 }
 221
 222 static int midi_warn = 1;
 223 /**************************************************************************
 224  *                      midiOpenSeq                             [internal]
 225  */
 226 static int midiOpenSeq(int create_client)
 227 {
 228     if (numOpenMidiSeq == 0) {
 229         if (snd_seq_open(&midiSeq, "default", SND_SEQ_OPEN_DUPLEX, 0) < 0)
 230         {
 231             if (midi_warn)
 232             {
 233                 WARN("Error opening ALSA sequencer.\n");
 234             }
 235             midi_warn = 0;
 236             return -1;
 237         }
 238
 239         if (create_client) {
 240             /* Setting the client name is the only init to do */
 241             snd_seq_set_client_name(midiSeq, "WINE midi driver");
 242
 243 #if 0 /* FIXME: Is it possible to use a port for READ & WRITE ops */
 244             port_in = port_out = snd_seq_create_simple_port(midiSeq, "WINE ALSA Input/Output", SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_WRITE,
 245                                                                          SND_SEQ_PORT_TYPE_APPLICATION);
 246             if (port_out < 0)
 247                TRACE("Unable to create output port\n");
 248             else
 249                TRACE("Outport port created successfully (%d)\n", port_out);
 250 #else
 251             port_out = snd_seq_create_simple_port(midiSeq, "WINE ALSA Output", SND_SEQ_PORT_CAP_READ,
 252                                                                                  SND_SEQ_PORT_TYPE_APPLICATION);
 253             if (port_out < 0)
 254                 TRACE("Unable to create output port\n");
 255             else
 256                 TRACE("Outport port created successfully (%d)\n", port_out);
 257
 258             port_in = snd_seq_create_simple_port(midiSeq, "WINE ALSA Input", SND_SEQ_PORT_CAP_WRITE,
 259                                                                        SND_SEQ_PORT_TYPE_APPLICATION);
 260             if (port_in < 0)
 261                 TRACE("Unable to create input port\n");
 262             else
 263                 TRACE("Input port created successfully (%d)\n", port_in);
 264 #endif
 265        }
 266     }
 267     numOpenMidiSeq++;
 268     return 0;
 269 }
 270
 271 /**************************************************************************
 272  *                      midiCloseSeq                            [internal]
 273  */
 274 static int midiCloseSeq(void)
 275 {
 276     if (--numOpenMidiSeq == 0) {
 277         snd_seq_delete_simple_port(midiSeq, port_out);
 278         snd_seq_delete_simple_port(midiSeq, port_in);
 279         snd_seq_close(midiSeq);
 280         midiSeq = NULL;
 281     }
 282     return 0;
 283 }
 284
 285 static DWORD WINAPI midRecThread(LPVOID arg)
 286 {
 287     int npfd;
 288     struct pollfd *pfd;
 289
 290     TRACE("Thread startup\n");
 291
 292     while(!end_thread) {
 293         TRACE("Thread loop\n");
 294         npfd = snd_seq_poll_descriptors_count(midiSeq, POLLIN);
 295         pfd = HeapAlloc(GetProcessHeap(), 0, npfd * sizeof(struct pollfd));
 296         snd_seq_poll_descriptors(midiSeq, pfd, npfd, POLLIN);
 297
 298         /* Check if an event is present */
 299         if (poll(pfd, npfd, 250) <= 0) {
 300             HeapFree(GetProcessHeap(), 0, pfd);
 301             continue;
 302         }
 303
 304         /* Note: This definitely does not work.
 305          * while(snd_seq_event_input_pending(midiSeq, 0) > 0) {
 306                snd_seq_event_t* ev;
 307                snd_seq_event_input(midiSeq, &ev);
 308                ....................
 309                snd_seq_free_event(ev);
 310            }*/
 311
 312         do {
 313             WORD wDevID;
 314             snd_seq_event_t* ev;
 315             snd_seq_event_input(midiSeq, &ev);
 316             /* Find the target device */
 317             for (wDevID = 0; wDevID < MIDM_NumDevs; wDevID++)
 318                 if ( (ev->source.client == MidiInDev[wDevID].addr.client) && (ev->source.port == MidiInDev[wDevID].addr.port) )
 319                     break;
 320             if ((wDevID == MIDM_NumDevs) || (MidiInDev[wDevID].state != 1))
 321                 FIXME("Unexpected event received, type = %x from %d:%d\n", ev->type, ev->source.client, ev->source.port);
 322             else {
 323                 DWORD dwTime, toSend = 0;
 324                 int value = 0;
 325                 /* FIXME: Should use ev->time instead for better accuracy */
 326                 dwTime = GetTickCount() - MidiInDev[wDevID].startTime;
 327                 TRACE("Event received, type = %x, device = %d\n", ev->type, wDevID);
 328                 switch(ev->type)
 329                 {
 330                 case SND_SEQ_EVENT_NOTEOFF:
 331                     toSend = (ev->data.note.velocity << 16) | (ev->data.note.note << 8) | MIDI_CMD_NOTE_OFF | ev->data.control.channel;
 332                     break;
 333                 case SND_SEQ_EVENT_NOTEON:
 334                     toSend = (ev->data.note.velocity << 16) | (ev->data.note.note << 8) | MIDI_CMD_NOTE_ON | ev->data.control.channel;
 335                     break;
 336                 case SND_SEQ_EVENT_KEYPRESS:
 337                     toSend = (ev->data.note.velocity << 16) | (ev->data.note.note << 8) | MIDI_CMD_NOTE_PRESSURE | ev->data.control.channel;
 338                     break;
 339                 case SND_SEQ_EVENT_CONTROLLER:
 340                     toSend = (ev->data.control.value << 16) | (ev->data.control.param << 8) | MIDI_CMD_CONTROL | ev->data.control.channel;
 341                     break;
 342                 case SND_SEQ_EVENT_PITCHBEND:
 343                     value = ev->data.control.value + 0x2000;
 344                     toSend = (((value >> 7) & 0x7f) << 16) | ((value & 0x7f) << 8) | MIDI_CMD_BENDER | ev->data.control.channel;
 345                     break;
 346                 case SND_SEQ_EVENT_PGMCHANGE:
 347                     toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_PGM_CHANGE | ev->data.control.channel;
 348                     break;
 349                 case SND_SEQ_EVENT_CHANPRESS:
 350                     toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_CHANNEL_PRESSURE | ev->data.control.channel;
 351                     break;
 352                 case SND_SEQ_EVENT_CLOCK:
 353                     toSend = 0xF8;
 354                     break;
 355                 case SND_SEQ_EVENT_START:
 356                     toSend = 0xFA;
 357                     break;
 358                 case SND_SEQ_EVENT_CONTINUE:
 359                     toSend = 0xFB;
 360                     break;
 361                 case SND_SEQ_EVENT_STOP:
 362                     toSend = 0xFC;
 363                     break;
 364                 case SND_SEQ_EVENT_SONGPOS:
 365                     toSend = (((ev->data.control.value >> 7) & 0x7f) << 16) | ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_COMMON_SONG_POS;
 366                     break;
 367                 case SND_SEQ_EVENT_SONGSEL:
 368                   toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_COMMON_SONG_SELECT;
 369                     break;
 370                 case SND_SEQ_EVENT_RESET:
 371                     toSend = 0xFF;
 372                     break;
 373                 case SND_SEQ_EVENT_QFRAME:
 374                   toSend = ((ev->data.control.value & 0x7f) << 8) | MIDI_CMD_COMMON_MTC_QUARTER;
 375                     break;
 376                 case SND_SEQ_EVENT_SYSEX:
 377                     {
 378                         int pos = 0;
 379                         int len = ev->data.ext.len;
 380                         LPBYTE ptr = ev->data.ext.ptr;
 381                         LPMIDIHDR lpMidiHdr;
 382
 383                         EnterCriticalSection(&crit_sect);
 384                         while (len) {
 385                             if ((lpMidiHdr = MidiInDev[wDevID].lpQueueHdr) != NULL) {
 386                                 int copylen = min(len, lpMidiHdr->dwBufferLength - lpMidiHdr->dwBytesRecorded);
 387                                 memcpy(lpMidiHdr->lpData + lpMidiHdr->dwBytesRecorded, ptr + pos, copylen);
 388                                 lpMidiHdr->dwBytesRecorded += copylen;
 389                                 len -= copylen;
 390                                 pos += copylen;
 391                                 /* We check if we reach the end of buffer or the end of sysex before notifying
 392                                  * to handle the case where ALSA split the sysex into several events */
 393                                 if ((lpMidiHdr->dwBytesRecorded == lpMidiHdr->dwBufferLength) ||
 394                                     (*(BYTE*)(lpMidiHdr->lpData + lpMidiHdr->dwBytesRecorded - 1) == 0xF7)) {
 395                                     lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
 396                                     lpMidiHdr->dwFlags |= MHDR_DONE;
 397                                     MidiInDev[wDevID].lpQueueHdr = lpMidiHdr->lpNext;
 398                                     MIDI_NotifyClient(wDevID, MIM_LONGDATA, (DWORD_PTR)lpMidiHdr, dwTime);
 399                                 }
 400                             } else {
 401                                 FIXME("Sysex data received but no buffer to store it!\n");
 402                                 break;
 403                             }
 404                         }
 405                         LeaveCriticalSection(&crit_sect);
 406                     }
 407                     break;
 408                 case SND_SEQ_EVENT_SENSING:
 409                     /* Noting to do */
 410                     break;
 411                 default:
 412                     FIXME("Unhandled event received, type = %x\n", ev->type);
 413                     break;
 414                 }
 415                 if (toSend != 0) {
 416                     TRACE("Sending event %08x (from %d %d)\n", toSend, ev->source.client, ev->source.port);
 417                     MIDI_NotifyClient(wDevID, MIM_DATA, toSend, dwTime);
 418                 }
 419             }
 420             snd_seq_free_event(ev);
 421         } while(snd_seq_event_input_pending(midiSeq, 0) > 0);
 422
 423         HeapFree(GetProcessHeap(), 0, pfd);
 424     }
 425     return 0;
 426 }
 427
 428 /**************************************************************************
 429  *                              midGetDevCaps                   [internal]
 430  */
 431 static DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPSW lpCaps, DWORD dwSize)
 432 {
 433     TRACE("(%04X, %p, %08X);\n", wDevID, lpCaps, dwSize);
 434
 435     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 436     if (lpCaps == NULL)         return MMSYSERR_INVALPARAM;
 437
 438     memcpy(lpCaps, &MidiInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
 439
 440     return MMSYSERR_NOERROR;
 441 }
 442
 443
 444 /**************************************************************************
 445  *                      midOpen                                 [internal]
 446  */
 447 static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 448 {
 449     TRACE("(%04X, %p, %08X);\n", wDevID, lpDesc, dwFlags);
 450
 451     if (lpDesc == NULL) {
 452         WARN("Invalid Parameter !\n");
 453         return MMSYSERR_INVALPARAM;
 454     }
 455
 456     /* FIXME :
 457      *  how to check that content of lpDesc is correct ?
 458      */
 459     if (wDevID >= MIDM_NumDevs) {
 460         WARN("wDevID too large (%u) !\n", wDevID);
 461         return MMSYSERR_BADDEVICEID;
 462     }
 463     if (MidiInDev[wDevID].state == -1) {
 464         WARN("device disabled\n");
 465         return MIDIERR_NODEVICE;
 466     }
 467     if (MidiInDev[wDevID].midiDesc.hMidi != 0) {
 468         WARN("device already open !\n");
 469         return MMSYSERR_ALLOCATED;
 470     }
 471     if ((dwFlags & MIDI_IO_STATUS) != 0) {
 472         WARN("No support for MIDI_IO_STATUS in dwFlags yet, ignoring it\n");
 473         dwFlags &= ~MIDI_IO_STATUS;
 474     }
 475     if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) {
 476         FIXME("Bad dwFlags\n");
 477         return MMSYSERR_INVALFLAG;
 478     }
 479
 480     if (midiOpenSeq(1) < 0) {
 481         return MMSYSERR_ERROR;
 482     }
 483
 484     /* Connect our app port to the device port */
 485     if (snd_seq_connect_from(midiSeq, port_in, MidiInDev[wDevID].addr.client, MidiInDev[wDevID].addr.port) < 0)
 486         return MMSYSERR_NOTENABLED;
 487
 488     TRACE("input port connected %d %d %d\n",port_in,MidiInDev[wDevID].addr.client,MidiInDev[wDevID].addr.port);
 489
 490     if (numStartedMidiIn++ == 0) {
 491         end_thread = 0;
 492         hThread = CreateThread(NULL, 0, midRecThread, NULL, 0, NULL);
 493         if (!hThread) {
 494             numStartedMidiIn = 0;
 495             WARN("Couldn't create thread for midi-in\n");
 496             midiCloseSeq();
 497             return MMSYSERR_ERROR;
 498         }
 499         SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
 500         TRACE("Created thread for midi-in\n");
 501     }
 502
 503     MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 504
 505     MidiInDev[wDevID].lpQueueHdr = NULL;
 506     MidiInDev[wDevID].dwTotalPlayed = 0;
 507     MidiInDev[wDevID].bufsize = 0x3FFF;
 508     MidiInDev[wDevID].midiDesc = *lpDesc;
 509     MidiInDev[wDevID].state = 0;
 510     MidiInDev[wDevID].incLen = 0;
 511     MidiInDev[wDevID].startTime = 0;
 512
 513     MIDI_NotifyClient(wDevID, MIM_OPEN, 0L, 0L);
 514     return MMSYSERR_NOERROR;
 515 }
 516
 517 /**************************************************************************
 518  *                      midClose                                [internal]
 519  */
 520 static DWORD midClose(WORD wDevID)
 521 {
 522     int         ret = MMSYSERR_NOERROR;
 523
 524     TRACE("(%04X);\n", wDevID);
 525
 526     if (wDevID >= MIDM_NumDevs) {
 527         WARN("wDevID too big (%u) !\n", wDevID);
 528         return MMSYSERR_BADDEVICEID;
 529     }
 530     if (MidiInDev[wDevID].midiDesc.hMidi == 0) {
 531         WARN("device not opened !\n");
 532         return MMSYSERR_ERROR;
 533     }
 534     if (MidiInDev[wDevID].lpQueueHdr != 0) {
 535         return MIDIERR_STILLPLAYING;
 536     }
 537
 538     if (midiSeq == NULL) {
 539         WARN("ooops !\n");
 540         return MMSYSERR_ERROR;
 541     }
 542     if (--numStartedMidiIn == 0) {
 543         TRACE("Stopping thread for midi-in\n");
 544         end_thread = 1;
 545         if (WaitForSingleObject(hThread, 5000) != WAIT_OBJECT_0) {
 546             WARN("Thread end not signaled, force termination\n");
 547             TerminateThread(hThread, 0);
 548         }
 549         TRACE("Stopped thread for midi-in\n");
 550     }
 551
 552     snd_seq_disconnect_from(midiSeq, port_in, MidiInDev[wDevID].addr.client, MidiInDev[wDevID].addr.port);
 553     midiCloseSeq();
 554
 555     MidiInDev[wDevID].bufsize = 0;
 556     MIDI_NotifyClient(wDevID, MIM_CLOSE, 0L, 0L);
 557     MidiInDev[wDevID].midiDesc.hMidi = 0;
 558
 559     return ret;
 560 }
 561
 562
 563 /**************************************************************************
 564  *                              midAddBuffer                    [internal]
 565  */
 566 static DWORD midAddBuffer(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 567 {
 568     TRACE("(%04X, %p, %08X);\n", wDevID, lpMidiHdr, dwSize);
 569
 570     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 571     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 572
 573     if (lpMidiHdr == NULL)      return MMSYSERR_INVALPARAM;
 574     if (dwSize < offsetof(MIDIHDR,dwOffset)) return MMSYSERR_INVALPARAM;
 575     if (lpMidiHdr->dwBufferLength == 0) return MMSYSERR_INVALPARAM;
 576     if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
 577     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
 578
 579     EnterCriticalSection(&crit_sect);
 580     lpMidiHdr->dwFlags &= ~WHDR_DONE;
 581     lpMidiHdr->dwFlags |= MHDR_INQUEUE;
 582     lpMidiHdr->dwBytesRecorded = 0;
 583     lpMidiHdr->lpNext = 0;
 584     if (MidiInDev[wDevID].lpQueueHdr == 0) {
 585         MidiInDev[wDevID].lpQueueHdr = lpMidiHdr;
 586     } else {
 587         LPMIDIHDR       ptr;
 588
 589         for (ptr = MidiInDev[wDevID].lpQueueHdr; ptr->lpNext != 0;
 590              ptr = ptr->lpNext);
 591         ptr->lpNext = lpMidiHdr;
 592     }
 593     LeaveCriticalSection(&crit_sect);
 594
 595     return MMSYSERR_NOERROR;
 596 }
 597
 598 /**************************************************************************
 599  *                              midPrepare                      [internal]
 600  */
 601 static DWORD midPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 602 {
 603     TRACE("(%04X, %p, %08X);\n", wDevID, lpMidiHdr, dwSize);
 604
 605     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 ||
 606         lpMidiHdr->lpData == 0 || (lpMidiHdr->dwFlags & MHDR_INQUEUE) != 0)
 607         return MMSYSERR_INVALPARAM;
 608
 609     lpMidiHdr->lpNext = 0;
 610     lpMidiHdr->dwFlags |= MHDR_PREPARED;
 611     lpMidiHdr->dwBytesRecorded = 0;
 612
 613     return MMSYSERR_NOERROR;
 614 }
 615
 616 /**************************************************************************
 617  *                              midUnprepare                    [internal]
 618  */
 619 static DWORD midUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 620 {
 621     TRACE("(%04X, %p, %08X);\n", wDevID, lpMidiHdr, dwSize);
 622
 623     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 624     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 625
 626     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 ||
 627         lpMidiHdr->lpData == 0)
 628         return MMSYSERR_INVALPARAM;
 629
 630     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
 631     if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
 632
 633     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
 634
 635     return MMSYSERR_NOERROR;
 636 }
 637
 638 /**************************************************************************
 639  *                      midReset                                [internal]
 640  */
 641 static DWORD midReset(WORD wDevID)
 642 {
 643     DWORD               dwTime = GetTickCount();
 644
 645     TRACE("(%04X);\n", wDevID);
 646
 647     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 648     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 649
 650     EnterCriticalSection(&crit_sect);
 651     while (MidiInDev[wDevID].lpQueueHdr) {
 652         MidiInDev[wDevID].lpQueueHdr->dwFlags &= ~MHDR_INQUEUE;
 653         MidiInDev[wDevID].lpQueueHdr->dwFlags |= MHDR_DONE;
 654         /* FIXME: when called from 16 bit, lpQueueHdr needs to be a segmented ptr */
 655         MIDI_NotifyClient(wDevID, MIM_LONGDATA,
 656                           (DWORD_PTR)MidiInDev[wDevID].lpQueueHdr, dwTime);
 657         MidiInDev[wDevID].lpQueueHdr = MidiInDev[wDevID].lpQueueHdr->lpNext;
 658     }
 659     LeaveCriticalSection(&crit_sect);
 660
 661     return MMSYSERR_NOERROR;
 662 }
 663
 664 /**************************************************************************
 665  *                      midStart                                [internal]
 666  */
 667 static DWORD midStart(WORD wDevID)
 668 {
 669     TRACE("(%04X);\n", wDevID);
 670
 671     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 672     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 673
 674     MidiInDev[wDevID].state = 1;
 675     MidiInDev[wDevID].startTime = GetTickCount();
 676     return MMSYSERR_NOERROR;
 677 }
 678
 679 /**************************************************************************
 680  *                      midStop                                 [internal]
 681  */
 682 static DWORD midStop(WORD wDevID)
 683 {
 684     TRACE("(%04X);\n", wDevID);
 685
 686     if (wDevID >= MIDM_NumDevs) return MMSYSERR_BADDEVICEID;
 687     if (MidiInDev[wDevID].state == -1) return MIDIERR_NODEVICE;
 688
 689     MidiInDev[wDevID].state = 0;
 690     return MMSYSERR_NOERROR;
 691 }
 692
 693 /**************************************************************************
 694  *                              modGetDevCaps                   [internal]
 695  */
 696 static DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPSW lpCaps, DWORD dwSize)
 697 {
 698     TRACE("(%04X, %p, %08X);\n", wDevID, lpCaps, dwSize);
 699
 700     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
 701     if (lpCaps == NULL)         return MMSYSERR_INVALPARAM;
 702
 703     memcpy(lpCaps, &MidiOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
 704
 705     return MMSYSERR_NOERROR;
 706 }
 707
 708 /**************************************************************************
 709  *                      modOpen                                 [internal]
 710  */
 711 static DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 712 {
 713     TRACE("(%04X, %p, %08X);\n", wDevID, lpDesc, dwFlags);
 714     if (lpDesc == NULL) {
 715         WARN("Invalid Parameter !\n");
 716         return MMSYSERR_INVALPARAM;
 717     }
 718     if (wDevID >= MODM_NumDevs) {
 719         TRACE("MAX_MIDIOUTDRV reached !\n");
 720         return MMSYSERR_BADDEVICEID;
 721     }
 722     if (MidiOutDev[wDevID].midiDesc.hMidi != 0) {
 723         WARN("device already open !\n");
 724         return MMSYSERR_ALLOCATED;
 725     }
 726     if (!MidiOutDev[wDevID].bEnabled) {
 727         WARN("device disabled !\n");
 728         return MIDIERR_NODEVICE;
 729     }
 730     if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) {
 731         WARN("bad dwFlags\n");
 732         return MMSYSERR_INVALFLAG;
 733     }
 734     if (!MidiOutDev[wDevID].bEnabled) {
 735         TRACE("disabled wDevID\n");
 736         return MMSYSERR_NOTENABLED;
 737     }
 738
 739     MidiOutDev[wDevID].lpExtra = 0;
 740
 741     switch (MidiOutDev[wDevID].caps.wTechnology) {
 742     case MOD_FMSYNTH:
 743     case MOD_MIDIPORT:
 744     case MOD_SYNTH:
 745         if (midiOpenSeq(1) < 0) {
 746             return MMSYSERR_ALLOCATED;
 747         }
 748         break;
 749     default:
 750         WARN("Technology not supported (yet) %d !\n",
 751              MidiOutDev[wDevID].caps.wTechnology);
 752         return MMSYSERR_NOTENABLED;
 753     }
 754
 755     MidiOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 756
 757     MidiOutDev[wDevID].lpQueueHdr = NULL;
 758     MidiOutDev[wDevID].dwTotalPlayed = 0;
 759     MidiOutDev[wDevID].bufsize = 0x3FFF;
 760     MidiOutDev[wDevID].midiDesc = *lpDesc;
 761
 762     /* Connect our app port to the device port */
 763     if (snd_seq_connect_to(midiSeq, port_out, MidiOutDev[wDevID].addr.client, MidiOutDev[wDevID].addr.port) < 0)
 764         return MMSYSERR_NOTENABLED;
 765
 766     MIDI_NotifyClient(wDevID, MOM_OPEN, 0L, 0L);
 767     TRACE("Successful !\n");
 768     return MMSYSERR_NOERROR;
 769 }
 770
 771
 772 /**************************************************************************
 773  *                      modClose                                [internal]
 774  */
 775 static DWORD modClose(WORD wDevID)
 776 {
 777     int ret = MMSYSERR_NOERROR;
 778
 779     TRACE("(%04X);\n", wDevID);
 780
 781     if (MidiOutDev[wDevID].midiDesc.hMidi == 0) {
 782         WARN("device not opened !\n");
 783         return MMSYSERR_ERROR;
 784     }
 785     /* FIXME: should test that no pending buffer is still in the queue for
 786      * playing */
 787
 788     if (midiSeq == NULL) {
 789         WARN("can't close !\n");
 790         return MMSYSERR_ERROR;
 791     }
 792
 793     switch (MidiOutDev[wDevID].caps.wTechnology) {
 794     case MOD_FMSYNTH:
 795     case MOD_MIDIPORT:
 796     case MOD_SYNTH:
 797         snd_seq_disconnect_to(midiSeq, port_out, MidiOutDev[wDevID].addr.client, MidiOutDev[wDevID].addr.port);
 798         midiCloseSeq();
 799         break;
 800     default:
 801         WARN("Technology not supported (yet) %d !\n",
 802              MidiOutDev[wDevID].caps.wTechnology);
 803         return MMSYSERR_NOTENABLED;
 804     }
 805
 806     HeapFree(GetProcessHeap(), 0, MidiOutDev[wDevID].lpExtra);
 807     MidiOutDev[wDevID].lpExtra = 0;
 808
 809     MidiOutDev[wDevID].bufsize = 0;
 810     MIDI_NotifyClient(wDevID, MOM_CLOSE, 0L, 0L);
 811     MidiOutDev[wDevID].midiDesc.hMidi = 0;
 812     return ret;
 813 }
 814
 815 /**************************************************************************
 816  *                      modData                                 [internal]
 817  */
 818 static DWORD modData(WORD wDevID, DWORD dwParam)
 819 {
 820     BYTE        evt = LOBYTE(LOWORD(dwParam));
 821     BYTE        d1  = HIBYTE(LOWORD(dwParam));
 822     BYTE        d2  = LOBYTE(HIWORD(dwParam));
 823
 824     TRACE("(%04X, %08X);\n", wDevID, dwParam);
 825
 826     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
 827     if (!MidiOutDev[wDevID].bEnabled) return MIDIERR_NODEVICE;
 828
 829     if (midiSeq == NULL) {
 830         WARN("can't play !\n");
 831         return MIDIERR_NODEVICE;
 832     }
 833     switch (MidiOutDev[wDevID].caps.wTechnology) {
 834     case MOD_SYNTH:
 835     case MOD_MIDIPORT:
 836         {
 837             int handled = 1; /* Assume event is handled */
 838             snd_seq_event_t event;
 839             snd_seq_ev_clear(&event);
 840             snd_seq_ev_set_direct(&event);
 841             snd_seq_ev_set_source(&event, port_out);
 842             snd_seq_ev_set_dest(&event, MidiOutDev[wDevID].addr.client, MidiOutDev[wDevID].addr.port);
 843
 844             switch (evt & 0xF0) {
 845             case MIDI_CMD_NOTE_OFF:
 846                 snd_seq_ev_set_noteoff(&event, evt&0x0F, d1, d2);
 847                 break;
 848             case MIDI_CMD_NOTE_ON:
 849                 snd_seq_ev_set_noteon(&event, evt&0x0F, d1, d2);
 850                 break;
 851             case MIDI_CMD_NOTE_PRESSURE:
 852                 snd_seq_ev_set_keypress(&event, evt&0x0F, d1, d2);
 853                 break;
 854             case MIDI_CMD_CONTROL:
 855                 snd_seq_ev_set_controller(&event, evt&0x0F, d1, d2);
 856                 break;
 857             case MIDI_CMD_BENDER:
 858                 snd_seq_ev_set_pitchbend(&event, evt&0x0F, ((WORD)d2 << 7 | (WORD)d1) - 0x2000);
 859                 break;
 860             case MIDI_CMD_PGM_CHANGE:
 861                 snd_seq_ev_set_pgmchange(&event, evt&0x0F, d1);
 862                 break;
 863             case MIDI_CMD_CHANNEL_PRESSURE:
 864                 snd_seq_ev_set_chanpress(&event, evt&0x0F, d1);
 865                 break;
 866             case MIDI_CMD_COMMON_SYSEX:
 867                 switch (evt & 0x0F) {
 868                 case 0x00:      /* System Exclusive, don't do it on modData,
 869                                  * should require modLongData*/
 870                 case 0x04:      /* Undefined. */
 871                 case 0x05:      /* Undefined. */
 872                 case 0x07:      /* End of Exclusive. */
 873                 case 0x09:      /* Undefined. */
 874                 case 0x0D:      /* Undefined. */
 875                     handled = 0;
 876                     break;
 877                 case 0x06:      /* Tune Request */
 878                 case 0x08:      /* Timing Clock. */
 879                 case 0x0A:      /* Start. */
 880                 case 0x0B:      /* Continue */
 881                 case 0x0C:      /* Stop */
 882                 case 0x0E:      /* Active Sensing. */
 883                     /* FIXME: Is this function suitable for these purposes
 884                        (and also Song Select and Song Position Pointer) */
 885                     snd_seq_ev_set_sysex(&event, 1, &evt);
 886                     break;
 887                 case 0x0F:      /* Reset */
 888                                 /* snd_seq_ev_set_sysex(&event, 1, &evt);
 889                                    this other way may be better */
 890                     {
 891                         BYTE reset_sysex_seq[] = {MIDI_CMD_COMMON_SYSEX, 0x7e, 0x7f, 0x09, 0x01, 0xf7};
 892                         snd_seq_ev_set_sysex(&event, sizeof(reset_sysex_seq), reset_sysex_seq);
 893                     }
 894                     break;
 895                 case 0x01:      /* MTC Quarter frame */
 896                 case 0x03:      /* Song Select. */
 897                     {
 898                         BYTE buf[2];
 899                         buf[0] = evt;
 900                         buf[1] = d1;
 901                         snd_seq_ev_set_sysex(&event, sizeof(buf), buf);
 902                     }
 903                     break;
 904                 case 0x02:      /* Song Position Pointer. */
 905                     {
 906                         BYTE buf[3];
 907                         buf[0] = evt;
 908                         buf[1] = d1;
 909                         buf[2] = d2;
 910                         snd_seq_ev_set_sysex(&event, sizeof(buf), buf);
 911                     }
 912                     break;
 913                 }
 914                 break;
 915             }
 916             if (handled)
 917                 snd_seq_event_output_direct(midiSeq, &event);
 918         }
 919         break;
 920     default:
 921         WARN("Technology not supported (yet) %d !\n",
 922              MidiOutDev[wDevID].caps.wTechnology);
 923         return MMSYSERR_NOTENABLED;
 924     }
 925
 926     return MMSYSERR_NOERROR;
 927 }
 928
 929 /**************************************************************************
 930  *              modLongData                                     [internal]
 931  */
 932 static DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
 933 {
 934     int len_add = 0;
 935     BYTE *lpData, *lpNewData = NULL;
 936     snd_seq_event_t event;
 937
 938     TRACE("(%04X, %p, %08X);\n", wDevID, lpMidiHdr, dwSize);
 939
 940     /* Note: MS doc does not say much about the dwBytesRecorded member of the MIDIHDR structure
 941      * but it seems to be used only for midi input.
 942      * Taking a look at the WAVEHDR structure (which is quite similar) confirms this assumption.
 943      */
 944
 945     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
 946     if (!MidiOutDev[wDevID].bEnabled) return MIDIERR_NODEVICE;
 947
 948     if (midiSeq == NULL) {
 949         WARN("can't play !\n");
 950         return MIDIERR_NODEVICE;
 951     }
 952
 953     lpData = (BYTE*)lpMidiHdr->lpData;
 954
 955     if (lpData == NULL)
 956         return MIDIERR_UNPREPARED;
 957     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
 958         return MIDIERR_UNPREPARED;
 959     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
 960         return MIDIERR_STILLPLAYING;
 961     lpMidiHdr->dwFlags &= ~MHDR_DONE;
 962     lpMidiHdr->dwFlags |= MHDR_INQUEUE;
 963
 964     /* FIXME: MS doc is not 100% clear. Will lpData only contain system exclusive
 965      * data, or can it also contain raw MIDI data, to be split up and sent to
 966      * modShortData() ?
 967      * If the latest is true, then the following WARNing will fire up
 968      */
 969     if (lpData[0] != 0xF0 || lpData[lpMidiHdr->dwBufferLength - 1] != 0xF7) {
 970         WARN("Alleged system exclusive buffer is not correct\n\tPlease report with MIDI file\n");
 971         lpNewData = HeapAlloc(GetProcessHeap(), 0, lpMidiHdr->dwBufferLength + 2);
 972     }
 973
 974     TRACE("dwBufferLength=%u !\n", lpMidiHdr->dwBufferLength);
 975     TRACE("                 %02X %02X %02X ... %02X %02X %02X\n",
 976           lpData[0], lpData[1], lpData[2], lpData[lpMidiHdr->dwBufferLength-3],
 977           lpData[lpMidiHdr->dwBufferLength-2], lpData[lpMidiHdr->dwBufferLength-1]);
 978
 979     switch (MidiOutDev[wDevID].caps.wTechnology) {
 980     case MOD_FMSYNTH:
 981         /* FIXME: I don't think there is much to do here */
 982         HeapFree(GetProcessHeap(), 0, lpNewData);
 983         break;
 984     case MOD_MIDIPORT:
 985         if (lpData[0] != 0xF0) {
 986             /* Send start of System Exclusive */
 987             len_add = 1;
 988             lpNewData[0] = 0xF0;
 989             memcpy(lpNewData + 1, lpData, lpMidiHdr->dwBufferLength);
 990             WARN("Adding missing 0xF0 marker at the beginning of system exclusive byte stream\n");
 991         }
 992         if (lpData[lpMidiHdr->dwBufferLength-1] != 0xF7) {
 993             /* Send end of System Exclusive */
 994             if (!len_add)
 995                 memcpy(lpNewData, lpData, lpMidiHdr->dwBufferLength);
 996             lpNewData[lpMidiHdr->dwBufferLength + len_add] = 0xF7;
 997             len_add++;
 998             WARN("Adding missing 0xF7 marker at the end of system exclusive byte stream\n");
 999         }
1000         snd_seq_ev_clear(&event);
1001         snd_seq_ev_set_direct(&event);
1002         snd_seq_ev_set_source(&event, port_out);
1003         snd_seq_ev_set_dest(&event, MidiOutDev[wDevID].addr.client, MidiOutDev[wDevID].addr.port);
1004         TRACE("client = %d port = %d\n", MidiOutDev[wDevID].addr.client, MidiOutDev[wDevID].addr.port);
1005         snd_seq_ev_set_sysex(&event, lpMidiHdr->dwBufferLength + len_add, lpNewData ? lpNewData : lpData);
1006         snd_seq_event_output_direct(midiSeq, &event);
1007         HeapFree(GetProcessHeap(), 0, lpNewData);
1008         break;
1009     default:
1010         WARN("Technology not supported (yet) %d !\n",
1011              MidiOutDev[wDevID].caps.wTechnology);
1012         HeapFree(GetProcessHeap(), 0, lpNewData);
1013         return MMSYSERR_NOTENABLED;
1014     }
1015
1016     lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1017     lpMidiHdr->dwFlags |= MHDR_DONE;
1018     MIDI_NotifyClient(wDevID, MOM_DONE, (DWORD_PTR)lpMidiHdr, 0L);
1019     return MMSYSERR_NOERROR;
1020 }
1021
1022 /**************************************************************************
1023  *                      modPrepare                              [internal]
1024  */
1025 static DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1026 {
1027     TRACE("(%04X, %p, %08X);\n", wDevID, lpMidiHdr, dwSize);
1028
1029     if (midiSeq == NULL) {
1030         WARN("can't prepare !\n");
1031         return MMSYSERR_NOTENABLED;
1032     }
1033
1034     /* MS doc says that dwFlags must be set to zero, but (kinda funny) MS mciseq drivers
1035      * asks to prepare MIDIHDR which dwFlags != 0.
1036      * So at least check for the inqueue flag
1037      */
1038     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 ||
1039         lpMidiHdr->lpData == 0 || (lpMidiHdr->dwFlags & MHDR_INQUEUE) != 0) {
1040         WARN("%p %p %08x %d\n", lpMidiHdr, lpMidiHdr ? lpMidiHdr->lpData : NULL,
1041              lpMidiHdr ? lpMidiHdr->dwFlags : 0, dwSize);
1042         return MMSYSERR_INVALPARAM;
1043     }
1044
1045     lpMidiHdr->lpNext = 0;
1046     lpMidiHdr->dwFlags |= MHDR_PREPARED;
1047     lpMidiHdr->dwFlags &= ~MHDR_DONE;
1048     return MMSYSERR_NOERROR;
1049 }
1050
1051 /**************************************************************************
1052  *                              modUnprepare                    [internal]
1053  */
1054 static DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1055 {
1056     TRACE("(%04X, %p, %08X);\n", wDevID, lpMidiHdr, dwSize);
1057
1058     if (midiSeq == NULL) {
1059         WARN("can't unprepare !\n");
1060         return MMSYSERR_NOTENABLED;
1061     }
1062
1063     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0)
1064         return MMSYSERR_INVALPARAM;
1065     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
1066         return MIDIERR_STILLPLAYING;
1067     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
1068     return MMSYSERR_NOERROR;
1069 }
1070
1071 /**************************************************************************
1072  *                      modGetVolume                            [internal]
1073  */
1074 static DWORD modGetVolume(WORD wDevID, DWORD* lpdwVolume)
1075 {
1076     if (!lpdwVolume) return MMSYSERR_INVALPARAM;
1077     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
1078     *lpdwVolume = 0xFFFFFFFF;
1079     return (MidiOutDev[wDevID].caps.dwSupport & MIDICAPS_VOLUME) ? 0 : MMSYSERR_NOTSUPPORTED;
1080 }
1081
1082 /**************************************************************************
1083  *                      modReset                                [internal]
1084  */
1085 static DWORD modReset(WORD wDevID)
1086 {
1087     unsigned chn;
1088
1089     TRACE("(%04X);\n", wDevID);
1090
1091     if (wDevID >= MODM_NumDevs) return MMSYSERR_BADDEVICEID;
1092     if (!MidiOutDev[wDevID].bEnabled) return MIDIERR_NODEVICE;
1093
1094     /* stop all notes */
1095     /* FIXME: check if 0x78B0 is channel dependent or not. I coded it so that
1096      * it's channel dependent...
1097      */
1098     for (chn = 0; chn < 16; chn++) {
1099         /* turn off every note */
1100         modData(wDevID, 0x7800 | MIDI_CMD_CONTROL | chn);
1101         /* remove sustain on all channels */
1102         modData(wDevID, (MIDI_CTL_SUSTAIN << 8) | MIDI_CMD_CONTROL | chn);
1103     }
1104     /* FIXME: the LongData buffers must also be returned to the app */
1105     return MMSYSERR_NOERROR;
1106 }
1107
1108
1109 /**************************************************************************
1110  *                      ALSA_AddMidiPort                        [internal]
1111  *
1112  * Helper for ALSA_MidiInit
1113  */
1114 static void ALSA_AddMidiPort(snd_seq_client_info_t* cinfo, snd_seq_port_info_t* pinfo, unsigned int cap, unsigned int type)
1115 {
1116     char midiPortName[MAXPNAMELEN];
1117
1118     if (cap & SND_SEQ_PORT_CAP_WRITE) {
1119         TRACE("OUT (%d:%s:%s:%d:%s:%x)\n",snd_seq_client_info_get_client(cinfo),
1120                                           snd_seq_client_info_get_name(cinfo),
1121                                           snd_seq_client_info_get_type(cinfo) == SND_SEQ_USER_CLIENT ? "user" : "kernel",
1122                                           snd_seq_port_info_get_port(pinfo),
1123                                           snd_seq_port_info_get_name(pinfo),
1124                                           type);
1125
1126         if (MODM_NumDevs >= MAX_MIDIOUTDRV)
1127             return;
1128         if (!type)
1129             return;
1130
1131         MidiOutDev[MODM_NumDevs].addr = *snd_seq_port_info_get_addr(pinfo);
1132
1133         /* Manufac ID. We do not have access to this with soundcard.h
1134          * Does not seem to be a problem, because in mmsystem.h only
1135          * Microsoft's ID is listed.
1136          */
1137         MidiOutDev[MODM_NumDevs].caps.wMid = 0x00FF;
1138         MidiOutDev[MODM_NumDevs].caps.wPid = 0x0001;    /* FIXME Product ID  */
1139         /* Product Version. We simply say "1" */
1140         MidiOutDev[MODM_NumDevs].caps.vDriverVersion = 0x001;
1141         /* The following are mandatory for MOD_MIDIPORT */
1142         MidiOutDev[MODM_NumDevs].caps.wChannelMask   = 0xFFFF;
1143         MidiOutDev[MODM_NumDevs].caps.wVoices        = 0;
1144         MidiOutDev[MODM_NumDevs].caps.wNotes         = 0;
1145         MidiOutDev[MODM_NumDevs].caps.dwSupport      = 0;
1146
1147         /* Try to use both client and port names, if this is too long take the port name only.
1148            In the second case the port name should be explicit enough due to its big size.
1149          */
1150         if ( (strlen(snd_seq_client_info_get_name(cinfo)) + strlen(snd_seq_port_info_get_name(pinfo)) + 3) < MAXPNAMELEN ) {
1151             sprintf(midiPortName, "%s - %s", snd_seq_client_info_get_name(cinfo), snd_seq_port_info_get_name(pinfo));
1152         } else {
1153             lstrcpynA(midiPortName, snd_seq_port_info_get_name(pinfo), MAXPNAMELEN);
1154         }
1155         MultiByteToWideChar(CP_UNIXCP, 0, midiPortName, -1,
1156                             MidiOutDev[MODM_NumDevs].caps.szPname,
1157                             sizeof(MidiOutDev[MODM_NumDevs].caps.szPname) / sizeof(WCHAR));
1158
1159         MidiOutDev[MODM_NumDevs].caps.wTechnology = MIDI_AlsaToWindowsDeviceType(type);
1160
1161         if (MOD_MIDIPORT != MidiOutDev[MODM_NumDevs].caps.wTechnology) {
1162             /* FIXME Do we have this information?
1163              * Assuming the soundcards can handle
1164              * MIDICAPS_VOLUME and MIDICAPS_LRVOLUME but
1165              * not MIDICAPS_CACHE.
1166              */
1167             MidiOutDev[MODM_NumDevs].caps.dwSupport = MIDICAPS_VOLUME|MIDICAPS_LRVOLUME;
1168             MidiOutDev[MODM_NumDevs].caps.wVoices   = 16;
1169
1170             /* FIXME Is it possible to know the maximum
1171              * number of simultaneous notes of a soundcard ?
1172              * I believe we don't have this information, but
1173              * it's probably equal or more than wVoices
1174              */
1175             MidiOutDev[MODM_NumDevs].caps.wNotes    = 16;
1176         }
1177         MidiOutDev[MODM_NumDevs].bEnabled    = TRUE;
1178
1179         TRACE("MidiOut[%d]\tname='%s' techn=%d voices=%d notes=%d chnMsk=%04x support=%d\n"
1180             "\tALSA info: midi dev-type=%x, capa=0\n",
1181               MODM_NumDevs, wine_dbgstr_w(MidiOutDev[MODM_NumDevs].caps.szPname),
1182               MidiOutDev[MODM_NumDevs].caps.wTechnology,
1183               MidiOutDev[MODM_NumDevs].caps.wVoices, MidiOutDev[MODM_NumDevs].caps.wNotes,
1184               MidiOutDev[MODM_NumDevs].caps.wChannelMask, MidiOutDev[MODM_NumDevs].caps.dwSupport,
1185               type);
1186
1187         MODM_NumDevs++;
1188     }
1189     if (cap & SND_SEQ_PORT_CAP_READ) {
1190         TRACE("IN  (%d:%s:%s:%d:%s:%x)\n",snd_seq_client_info_get_client(cinfo),
1191                                           snd_seq_client_info_get_name(cinfo),
1192                                           snd_seq_client_info_get_type(cinfo) == SND_SEQ_USER_CLIENT ? "user" : "kernel",
1193                                           snd_seq_port_info_get_port(pinfo),
1194                                           snd_seq_port_info_get_name(pinfo),
1195                                           type);
1196
1197         if (MIDM_NumDevs >= MAX_MIDIINDRV)
1198             return;
1199         if (!type)
1200             return;
1201
1202         MidiInDev[MIDM_NumDevs].addr = *snd_seq_port_info_get_addr(pinfo);
1203
1204         /* Manufac ID. We do not have access to this with soundcard.h
1205          * Does not seem to be a problem, because in mmsystem.h only
1206          * Microsoft's ID is listed.
1207          */
1208         MidiInDev[MIDM_NumDevs].caps.wMid = 0x00FF;
1209         MidiInDev[MIDM_NumDevs].caps.wPid = 0x0001;     /* FIXME Product ID  */
1210         /* Product Version. We simply say "1" */
1211         MidiInDev[MIDM_NumDevs].caps.vDriverVersion = 0x001;
1212         MidiInDev[MIDM_NumDevs].caps.dwSupport = 0; /* mandatory with MIDIINCAPS */
1213
1214         /* Try to use both client and port names, if this is too long take the port name only.
1215            In the second case the port name should be explicit enough due to its big size.
1216          */
1217         if ( (strlen(snd_seq_client_info_get_name(cinfo)) + strlen(snd_seq_port_info_get_name(pinfo)) + 3) < MAXPNAMELEN ) {
1218             sprintf(midiPortName, "%s - %s", snd_seq_client_info_get_name(cinfo), snd_seq_port_info_get_name(pinfo));
1219         } else {
1220             lstrcpynA(midiPortName, snd_seq_port_info_get_name(pinfo), MAXPNAMELEN);
1221         }
1222         MultiByteToWideChar(CP_UNIXCP, 0, midiPortName, -1,
1223                             MidiInDev[MIDM_NumDevs].caps.szPname,
1224                             sizeof(MidiInDev[MIDM_NumDevs].caps.szPname) / sizeof(WCHAR));
1225         MidiInDev[MIDM_NumDevs].state = 0;
1226
1227         TRACE("MidiIn [%d]\tname='%s' support=%d\n"
1228               "\tALSA info: midi dev-type=%x, capa=0\n",
1229               MIDM_NumDevs, wine_dbgstr_w(MidiInDev[MIDM_NumDevs].caps.szPname),
1230               MidiInDev[MIDM_NumDevs].caps.dwSupport,
1231               type);
1232
1233         MIDM_NumDevs++;
1234     }
1235 }
1236
1237
1238 /*======================================================================*
1239  *                          MIDI entry points                           *
1240  *======================================================================*/
1241
1242 /**************************************************************************
1243  * ALSA_MidiInit                                [internal]
1244  *
1245  * Initializes the MIDI devices information variables
1246  */
1247 static LONG ALSA_MidiInit(void)
1248 {
1249     static      BOOL    bInitDone = FALSE;
1250     snd_seq_client_info_t *cinfo;
1251     snd_seq_port_info_t *pinfo;
1252
1253     if (bInitDone)
1254         return TRUE;
1255
1256     TRACE("Initializing the MIDI variables.\n");
1257     bInitDone = TRUE;
1258
1259     /* try to open device */
1260     if (midiOpenSeq(0) == -1) {
1261         return TRUE;
1262     }
1263
1264 #if 0 /* Debug purpose */
1265     snd_lib_error_set_handler(error_handler);
1266 #endif
1267     cinfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_seq_client_info_sizeof() );
1268     pinfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, snd_seq_port_info_sizeof() );
1269
1270     /* First, search for all internal midi devices */
1271     snd_seq_client_info_set_client(cinfo, -1);
1272     while(snd_seq_query_next_client(midiSeq, cinfo) >= 0) {
1273         snd_seq_port_info_set_client(pinfo, snd_seq_client_info_get_client(cinfo));
1274         snd_seq_port_info_set_port(pinfo, -1);
1275         while (snd_seq_query_next_port(midiSeq, pinfo) >= 0) {
1276             unsigned int cap = snd_seq_port_info_get_capability(pinfo);
1277             unsigned int type = snd_seq_port_info_get_type(pinfo);
1278             if (!(type & SND_SEQ_PORT_TYPE_PORT))
1279                 ALSA_AddMidiPort(cinfo, pinfo, cap, type);
1280         }
1281     }
1282
1283     /* Second, search for all external ports */
1284     snd_seq_client_info_set_client(cinfo, -1);
1285     while(snd_seq_query_next_client(midiSeq, cinfo) >= 0) {
1286         snd_seq_port_info_set_client(pinfo, snd_seq_client_info_get_client(cinfo));
1287         snd_seq_port_info_set_port(pinfo, -1);
1288         while (snd_seq_query_next_port(midiSeq, pinfo) >= 0) {
1289             unsigned int cap = snd_seq_port_info_get_capability(pinfo);
1290             unsigned int type = snd_seq_port_info_get_type(pinfo);
1291             if (type & SND_SEQ_PORT_TYPE_PORT)
1292                 ALSA_AddMidiPort(cinfo, pinfo, cap, type);
1293         }
1294     }
1295
1296     /* close file and exit */
1297     midiCloseSeq();
1298     HeapFree( GetProcessHeap(), 0, cinfo );
1299     HeapFree( GetProcessHeap(), 0, pinfo );
1300
1301     TRACE("End\n");
1302     return TRUE;
1303 }
1304
1305 /**************************************************************************
1306  *                      midMessage (WINEALSA.@)
1307  */
1308 DWORD WINAPI ALSA_midMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
1309                             DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1310 {
1311     TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1312           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1313     switch (wMsg) {
1314     case DRVM_INIT:
1315         ALSA_MidiInit();
1316         return 0;
1317     case DRVM_EXIT:
1318     case DRVM_ENABLE:
1319     case DRVM_DISABLE:
1320         /* FIXME: Pretend this is supported */
1321         return 0;
1322     case MIDM_OPEN:
1323         return midOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
1324     case MIDM_CLOSE:
1325         return midClose(wDevID);
1326     case MIDM_ADDBUFFER:
1327         return midAddBuffer(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1328     case MIDM_PREPARE:
1329         return midPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1330     case MIDM_UNPREPARE:
1331         return midUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1332     case MIDM_GETDEVCAPS:
1333         return midGetDevCaps(wDevID, (LPMIDIINCAPSW)dwParam1,dwParam2);
1334     case MIDM_GETNUMDEVS:
1335         return MIDM_NumDevs;
1336     case MIDM_RESET:
1337         return midReset(wDevID);
1338     case MIDM_START:
1339         return midStart(wDevID);
1340     case MIDM_STOP:
1341         return midStop(wDevID);
1342     default:
1343         TRACE("Unsupported message\n");
1344     }
1345     return MMSYSERR_NOTSUPPORTED;
1346 }
1347
1348 /**************************************************************************
1349  *                              modMessage (WINEALSA.@)
1350  */
1351 DWORD WINAPI ALSA_modMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
1352                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1353 {
1354     TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1355           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1356
1357     switch (wMsg) {
1358     case DRVM_INIT:
1359         ALSA_MidiInit();
1360         return 0;
1361     case DRVM_EXIT:
1362     case DRVM_ENABLE:
1363     case DRVM_DISABLE:
1364         /* FIXME: Pretend this is supported */
1365         return 0;
1366     case MODM_OPEN:
1367         return modOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
1368     case MODM_CLOSE:
1369         return modClose(wDevID);
1370     case MODM_DATA:
1371         return modData(wDevID, dwParam1);
1372     case MODM_LONGDATA:
1373         return modLongData(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1374     case MODM_PREPARE:
1375         return modPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1376     case MODM_UNPREPARE:
1377         return modUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1378     case MODM_GETDEVCAPS:
1379         return modGetDevCaps(wDevID, (LPMIDIOUTCAPSW)dwParam1, dwParam2);
1380     case MODM_GETNUMDEVS:
1381         return MODM_NumDevs;
1382     case MODM_GETVOLUME:
1383         return modGetVolume(wDevID, (DWORD*)dwParam1);
1384     case MODM_SETVOLUME:
1385         return 0;
1386     case MODM_RESET:
1387         return modReset(wDevID);
1388     default:
1389         TRACE("Unsupported message\n");
1390     }
1391     return MMSYSERR_NOTSUPPORTED;
1392 }
1393
1394 /**************************************************************************
1395  *                              DriverProc (WINEALSA.@)
1396  */
1397 LRESULT CALLBACK ALSA_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1398                                  LPARAM dwParam1, LPARAM dwParam2)
1399 {
1400 /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
1401 /* EPP    dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
1402
1403     switch(wMsg) {
1404     case DRV_LOAD:
1405     case DRV_FREE:
1406     case DRV_OPEN:
1407     case DRV_CLOSE:
1408     case DRV_ENABLE:
1409     case DRV_DISABLE:
1410     case DRV_QUERYCONFIGURE:
1411     case DRV_CONFIGURE:
1412         return 1;
1413     case DRV_INSTALL:
1414     case DRV_REMOVE:
1415         return DRV_SUCCESS;
1416     default:
1417         return 0;
1418     }
1419 }