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