git.oblomov.eu Git - wine/blob - multimedia/midi.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * Sample MIDI Wine Driver for Linux
   5  *
   6  * Copyright 1994 Martin Ayotte
   7  */
   8
   9 /*
  10  * Eric POUECH :
  11  * 98/7 changes for making this MIDI driver work on OSS
  12  *      current support is limited to MIDI ports of OSS systems
  13  * 98/9 rewriting MCI code for MIDI
  14  * 98/11 splitted in midi.c and mcimidi.c
  15  */
  16
  17 #include "config.h"
  18 #include <errno.h>
  19 #include <string.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <sys/ioctl.h>
  25 #include "wine/winuser16.h"
  26 #include "multimedia.h"
  27 #include "driver.h"
  28 #include "xmalloc.h"
  29 #include "debug.h"
  30 #include "heap.h"
  31
  32
  33 typedef struct {
  34 #ifndef HAVE_OSS
  35     int                 unixdev;
  36 #endif
  37     int                 state;
  38     DWORD               bufsize;
  39     LPMIDIOPENDESC      midiDesc;
  40     WORD                wFlags;
  41     LPMIDIHDR16                 lpQueueHdr;
  42     DWORD               dwTotalPlayed;
  43 #ifdef HAVE_OSS
  44     unsigned char       incoming[3];
  45     unsigned char       incPrev;
  46     char                incLen;
  47     DWORD               startTime;
  48 #endif
  49 } WINE_MIDIIN;
  50
  51 typedef struct {
  52 #ifndef HAVE_OSS
  53     int                 unixdev;
  54 #endif
  55     int                 state;
  56     DWORD               bufsize;
  57     LPMIDIOPENDESC      midiDesc;
  58     WORD                wFlags;
  59     LPMIDIHDR16                 lpQueueHdr;
  60     DWORD               dwTotalPlayed;
  61 #ifdef HAVE_OSS
  62     void*               lpExtra;                /* according to port type (MIDI, FM...), extra data when needed */
  63 #endif
  64 } WINE_MIDIOUT;
  65
  66 static WINE_MIDIIN      MidiInDev [MAX_MIDIINDRV ];
  67 static WINE_MIDIOUT     MidiOutDev[MAX_MIDIOUTDRV];
  68
  69 /* this is the total number of MIDI out devices found */
  70 int     MODM_NUMDEVS = 0;
  71 /* this is the number of FM synthetizers (index from 0 to
  72    NUMFMSYNTHDEVS - 1) */
  73 int     MODM_NUMFMSYNTHDEVS = 0;
  74 /* this is the number of Midi ports (index from NUMFMSYNTHDEVS to
  75    NUMFMSYNTHDEVS + NUMMIDIDEVS - 1) */
  76 int     MODM_NUMMIDIDEVS = 0;
  77
  78 /* this is the total number of MIDI out devices found */
  79 int     MIDM_NUMDEVS = 0;
  80
  81 #ifdef HAVE_OSS
  82 static  int             midiSeqFD = -1;
  83 static  int             numOpenMidiSeq = 0;
  84 static  UINT            midiInTimerID = 0;
  85 static  int             numStartedMidiIn = 0;
  86 #endif /* HAVE_OSS */
  87
  88 /* this structure holds pointers with information for each MIDI
  89  * out device found.
  90  */
  91 LPMIDIOUTCAPS16 midiOutDevices[MAX_MIDIOUTDRV];
  92
  93 /* this structure holds pointers with information for each MIDI
  94  * in device found.
  95  */
  96 LPMIDIINCAPS16  midiInDevices [MAX_MIDIINDRV];
  97
  98 /*
  99  * FIXME : all tests on device ID for midXXX and modYYY are made against
 100  * MAX_MIDIxxDRV (when they are made) but should be done against the actual
 101  * number of midi devices found...
 102  * check also when HAVE_OSS is defined that midiDesc is not NULL
 103  */
 104
 105 /*======================================================================*
 106  *                  Low level MIDI implemantation                       *
 107  *======================================================================*/
 108 #ifdef SNDCTL_MIDI_INFO
 109 /**************************************************************************
 110  *                      MIDI_NotifyClient                       [internal]
 111  */
 112 static DWORD MIDI_NotifyClient(UINT16 wDevID, WORD wMsg,
 113                                DWORD dwParam1, DWORD dwParam2)
 114 {
 115     DWORD               dwCallBack;
 116     UINT16              uFlags;
 117     HANDLE16            hDev;
 118     DWORD               dwInstance;
 119
 120     TRACE(midi,"wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
 121           wDevID, wMsg, dwParam1, dwParam2);
 122
 123     switch (wMsg) {
 124     case MOM_OPEN:
 125     case MOM_CLOSE:
 126     case MOM_DONE:
 127         if (wDevID > MAX_MIDIOUTDRV)
 128             return MCIERR_INTERNAL;
 129
 130         dwCallBack = MidiOutDev[wDevID].midiDesc->dwCallback;
 131         uFlags = MidiOutDev[wDevID].wFlags;
 132         hDev = MidiOutDev[wDevID].midiDesc->hMidi;
 133         dwInstance = MidiOutDev[wDevID].midiDesc->dwInstance;
 134         break;
 135
 136     case MIM_OPEN:
 137     case MIM_CLOSE:
 138     case MIM_DATA:
 139     case MIM_ERROR:
 140         if (wDevID > MAX_MIDIINDRV)
 141             return MCIERR_INTERNAL;
 142
 143         dwCallBack = MidiInDev[wDevID].midiDesc->dwCallback;
 144         uFlags = MidiInDev[wDevID].wFlags;
 145         hDev = MidiInDev[wDevID].midiDesc->hMidi;
 146         dwInstance = MidiInDev[wDevID].midiDesc->dwInstance;
 147         break;
 148     default:
 149         WARN(midi, "Unsupported MSW-MIDI message %u\n", wMsg);
 150         return MCIERR_INTERNAL;
 151     }
 152
 153     return DriverCallback16(dwCallBack, uFlags, hDev, wMsg, dwInstance, dwParam1, dwParam2) ?
 154         0 : MCIERR_INTERNAL;
 155 }
 156
 157 #ifdef HAVE_OSS
 158 /**************************************************************************
 159  *                      midiOpenSeq                             [internal]
 160  */
 161 static int midiOpenSeq(void)
 162 {
 163     if (numOpenMidiSeq == 0) {
 164         midiSeqFD = open(MIDI_SEQ, O_RDWR, 0);
 165         if (midiSeqFD == -1) {
 166             ERR(midi, "can't open '%s' ! (%d)\n", MIDI_SEQ, errno);
 167             return -1;
 168         }
 169         if (fcntl(midiSeqFD, F_SETFL, O_NONBLOCK) < 0) {
 170             WARN(midi, "can't set sequencer fd to non blocking (%d)\n", errno);
 171             close(midiSeqFD);
 172             midiSeqFD = -1;
 173             return -1;
 174         }
 175         ioctl(midiSeqFD, SNDCTL_SEQ_RESET);
 176     }
 177     numOpenMidiSeq++;
 178     return 0;
 179 }
 180
 181 /**************************************************************************
 182  *                      midiCloseSeq                            [internal]
 183  */
 184 static int midiCloseSeq(void)
 185 {
 186     if (--numOpenMidiSeq == 0) {
 187         close(midiSeqFD);
 188         midiSeqFD = -1;
 189     }
 190     return 0;
 191 }
 192
 193 /* FIXME: this is a bad idea, it's even not static... */
 194 SEQ_DEFINEBUF(1024);
 195
 196 /* FIXME: this is not reentrant, not static - because of global variable
 197  * _seqbuf and al. */
 198 /**************************************************************************
 199  *                      seqbuf_dump                             [internal]
 200  */
 201 void seqbuf_dump(void)
 202 {
 203     if (_seqbufptr) {
 204         if (write(midiSeqFD, _seqbuf, _seqbufptr) == -1) {
 205             WARN(midi, "Can't write data to sequencer (%d/%d)!\n",
 206                  midiSeqFD, errno);
 207         }
 208         /* FIXME:
 209          *      in any case buffer is lost so that if many errors occur the buffer
 210          * will not overrun
 211          */
 212         _seqbufptr = 0;
 213     }
 214 }
 215 #endif /* HAVE_OSS */
 216
 217 #ifdef HAVE_OSS
 218
 219 static void midReceiveChar(WORD wDevID, unsigned char value, DWORD dwTime)
 220 {
 221     DWORD               toSend = 0;
 222
 223     TRACE(midi, "Adding %02xh to %d[%d]\n", value, wDevID, MidiInDev[wDevID].incLen);
 224
 225     if (wDevID >= MAX_MIDIINDRV) {
 226         WARN(midi, "bad devID\n");
 227         return;
 228     }
 229     if (MidiInDev[wDevID].state == 0) {
 230         TRACE(midi, "input not started, thrown away\n");
 231         return;
 232     }
 233
 234     if (MidiInDev[wDevID].state & 2) { /* system exclusive */
 235         LPMIDIHDR16     ptr = MidiInDev[wDevID].lpQueueHdr;
 236         WORD                    sbfb = FALSE;
 237
 238         if (ptr) {
 239             ((LPSTR)(ptr->reserved))[ptr->dwBytesRecorded++] = value;
 240             if (ptr->dwBytesRecorded == ptr->dwBufferLength) {
 241                 sbfb = TRUE;
 242             }
 243         }
 244         if (value == 0xF7) { /* then end */
 245             MidiInDev[wDevID].state &= ~2;
 246             sbfb = TRUE;
 247         }
 248         if (sbfb && ptr != NULL) {
 249             ptr = MidiInDev[wDevID].lpQueueHdr;
 250             ptr->dwFlags &= ~MHDR_INQUEUE;
 251             ptr->dwFlags |= MHDR_DONE;
 252             MidiInDev[wDevID].lpQueueHdr = (LPMIDIHDR16)ptr->lpNext;
 253             if (MIDI_NotifyClient(wDevID, MIM_LONGDATA, (DWORD)ptr, dwTime) != MMSYSERR_NOERROR) {
 254                 WARN(midi, "Couldn't notify client\n");
 255             }
 256         }
 257         return;
 258     }
 259
 260 #define IS_CMD(_x)      (((_x) & 0x80) == 0x80)
 261 #define IS_SYS_CMD(_x)  (((_x) & 0xF0) == 0xF0)
 262
 263     if (!IS_CMD(value) && MidiInDev[wDevID].incLen == 0) { /* try to reuse old cmd */
 264         if (IS_CMD(MidiInDev[wDevID].incPrev) && !IS_SYS_CMD(MidiInDev[wDevID].incPrev)) {
 265             MidiInDev[wDevID].incoming[0] = MidiInDev[wDevID].incPrev;
 266             MidiInDev[wDevID].incLen = 1;
 267             TRACE(midi, "Reusing old command %02xh\n", MidiInDev[wDevID].incPrev);
 268         } else {
 269             FIXME(midi, "error for midi-in, should generate MIM_ERROR notification:"
 270                   " prev=%02Xh, incLen=%02Xh\n",
 271                   MidiInDev[wDevID].incPrev, MidiInDev[wDevID].incLen);
 272             return;
 273         }
 274     }
 275     MidiInDev[wDevID].incoming[(int)(MidiInDev[wDevID].incLen++)] = value;
 276     if (MidiInDev[wDevID].incLen == 1 && !IS_SYS_CMD(MidiInDev[wDevID].incoming[0])) {
 277         /* store new cmd, just in case */
 278         MidiInDev[wDevID].incPrev = MidiInDev[wDevID].incoming[0];
 279     }
 280
 281 #undef IS_CMD(_x)
 282 #undef IS_SYS_CMD(_x)
 283
 284     switch (MidiInDev[wDevID].incoming[0] & 0xF0) {
 285     case MIDI_NOTEOFF:
 286     case MIDI_NOTEON:
 287     case MIDI_KEY_PRESSURE:
 288     case MIDI_CTL_CHANGE:
 289     case MIDI_PITCH_BEND:
 290         if (MidiInDev[wDevID].incLen == 3) {
 291             toSend = (MidiInDev[wDevID].incoming[2] << 16) |
 292                 (MidiInDev[wDevID].incoming[1] <<  8) |
 293                 (MidiInDev[wDevID].incoming[0] <<  0);
 294         }
 295         break;
 296     case MIDI_PGM_CHANGE:
 297     case MIDI_CHN_PRESSURE:
 298         if (MidiInDev[wDevID].incLen == 2) {
 299             toSend = (MidiInDev[wDevID].incoming[1] <<  8) |
 300                 (MidiInDev[wDevID].incoming[0] <<  0);
 301         }
 302         break;
 303     case MIDI_SYSTEM_PREFIX:
 304         if (MidiInDev[wDevID].incoming[0] == 0xF0) {
 305             MidiInDev[wDevID].state |= 2;
 306             MidiInDev[wDevID].incLen = 0;
 307         } else {
 308             if (MidiInDev[wDevID].incLen == 1) {
 309                 toSend = (MidiInDev[wDevID].incoming[0] <<  0);
 310             }
 311         }
 312         break;
 313     default:
 314         WARN(midi, "This shouldn't happen (%02X)\n", MidiInDev[wDevID].incoming[0]);
 315     }
 316     if (toSend != 0) {
 317         TRACE(midi, "Sending event %08lx\n", toSend);
 318         MidiInDev[wDevID].incLen =      0;
 319         dwTime -= MidiInDev[wDevID].startTime;
 320         if (MIDI_NotifyClient(wDevID, MIM_DATA, toSend, dwTime) != MMSYSERR_NOERROR) {
 321             WARN(midi, "Couldn't notify client\n");
 322         }
 323     }
 324 }
 325
 326 static VOID WINAPI midTimeCallback(HWND hwnd, UINT msg, UINT id, DWORD dwTime)
 327 {
 328     unsigned    char            buffer[256];
 329     int                         len, idx;
 330
 331     TRACE(midi, "(%04X, %d, %d, %lu)\n", hwnd, msg, id, dwTime);
 332
 333     len = read(midiSeqFD, buffer, sizeof(buffer));
 334
 335     if ((len % 4) != 0) {
 336         WARN(midi, "bad length %d (%d)\n", len, errno);
 337         return;
 338     }
 339
 340     for (idx = 0; idx < len; ) {
 341         if (buffer[idx] & 0x80) {
 342             TRACE(midi,
 343                   "reading<8> %02x %02x %02x %02x %02x %02x %02x %02x\n",
 344                   buffer[idx + 0], buffer[idx + 1],
 345                   buffer[idx + 2], buffer[idx + 3],
 346                   buffer[idx + 4], buffer[idx + 5],
 347                   buffer[idx + 6], buffer[idx + 7]);
 348             idx += 8;
 349         } else {
 350             switch (buffer[idx + 0]) {
 351             case SEQ_WAIT:
 352             case SEQ_ECHO:
 353                 break;
 354             case SEQ_MIDIPUTC:
 355                 midReceiveChar(buffer[idx + 2], buffer[idx + 1], dwTime);
 356                 break;
 357             default:
 358                 TRACE(midi, "Unsupported event %d\n", buffer[idx + 0]);
 359                 break;
 360             }
 361             idx += 4;
 362         }
 363     }
 364 }
 365 #endif /* HAVE_OSS */
 366
 367 /**************************************************************************
 368  *                              midGetDevCaps                   [internal]
 369  */
 370 static DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS16 lpCaps, DWORD dwSize)
 371 {
 372     LPMIDIINCAPS16      tmplpCaps;
 373
 374     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpCaps, dwSize);
 375
 376     if (wDevID >= MIDM_NUMDEVS) {
 377         return MMSYSERR_BADDEVICEID;
 378     }
 379     if (lpCaps == NULL) {
 380         return MMSYSERR_INVALPARAM;
 381     }
 382
 383     tmplpCaps = midiInDevices[wDevID];
 384     lpCaps->wMid = tmplpCaps->wMid;
 385     lpCaps->wPid = tmplpCaps->wPid;
 386     lpCaps->vDriverVersion = tmplpCaps->vDriverVersion;
 387     strcpy(lpCaps->szPname, tmplpCaps->szPname);
 388     if (dwSize == sizeof(MIDIINCAPS16)) {
 389         /* we should run win 95, so make use of dwSupport */
 390         lpCaps->dwSupport = tmplpCaps->dwSupport;
 391     } else if (dwSize != sizeof(MIDIINCAPS16) - sizeof(DWORD)) {
 392         TRACE(midi, "bad size for lpCaps\n");
 393         return MMSYSERR_INVALPARAM;
 394     }
 395
 396     return MMSYSERR_NOERROR;
 397 }
 398
 399 /**************************************************************************
 400  *                      midOpen                                 [internal]
 401  */
 402 static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 403 {
 404     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
 405
 406     if (lpDesc == NULL) {
 407         WARN(midi, "Invalid Parameter !\n");
 408         return MMSYSERR_INVALPARAM;
 409     }
 410     /* FIXME :
 411      *  how to check that content of lpDesc is correct ?
 412      */
 413     if (wDevID >= MAX_MIDIINDRV) {
 414         WARN(midi,"wDevID too large (%u) !\n", wDevID);
 415         return MMSYSERR_BADDEVICEID;
 416     }
 417     if (MidiInDev[wDevID].midiDesc != 0) {
 418         WARN(midi, "device already open !\n");
 419         return MMSYSERR_ALLOCATED;
 420     }
 421     if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) {
 422         FIXME(midi, "No support for MIDI_IO_STATUS in dwFlags\n");
 423         return MMSYSERR_INVALFLAG;
 424     }
 425
 426 #ifdef HAVE_OSS
 427     if (midiOpenSeq() < 0) {
 428         return MMSYSERR_ERROR;
 429     }
 430
 431     if (numStartedMidiIn++ == 0) {
 432         midiInTimerID = SetTimer(0, 0, 250, midTimeCallback);
 433         if (!midiInTimerID) {
 434             numStartedMidiIn = 0;
 435             WARN(midi, "Couldn't start timer for midi-in\n");
 436             midiCloseSeq();
 437             return MMSYSERR_ERROR;
 438         }
 439         TRACE(midi, "Starting timer (%u) for midi-in\n", midiInTimerID);
 440     }
 441 #else /* HAVE_OSS */
 442     {
 443         int             midi = open(MIDI_DEV, O_WRONLY, 0);
 444
 445         MidiInDev[wDevID].unixdev = 0;
 446         if (midi == -1) {
 447             WARN(midi,"can't open '%s' (%d)!\n", MIDI_DEV, errno);
 448             return MMSYSERR_ALLOCATED;
 449         }
 450         MidiInDev[wDevID].unixdev = midi;
 451     }
 452 #endif /* HAVE_OSS */
 453
 454     MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 455     switch (MidiInDev[wDevID].wFlags) {
 456     case DCB_NULL:
 457         TRACE(midi,"CALLBACK_NULL !\n");
 458         break;
 459     case DCB_WINDOW:
 460         TRACE(midi, "CALLBACK_WINDOW !\n");
 461         break;
 462     case DCB_TASK:
 463         TRACE(midi, "CALLBACK_TASK !\n");
 464         break;
 465     case DCB_FUNCTION:
 466         TRACE(midi, "CALLBACK_FUNCTION (%08lX)!\n", lpDesc->dwCallback);
 467         break;
 468     }
 469     MidiInDev[wDevID].lpQueueHdr = NULL;
 470     MidiInDev[wDevID].dwTotalPlayed = 0;
 471     MidiInDev[wDevID].bufsize = 0x3FFF;
 472     MidiInDev[wDevID].midiDesc = lpDesc;
 473     MidiInDev[wDevID].state = 0;
 474 #ifdef HAVE_OSS
 475     MidiInDev[wDevID].incLen = 0;
 476     MidiInDev[wDevID].startTime = 0;
 477 #endif /* HAVE_OSS */
 478     if (MIDI_NotifyClient(wDevID, MIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
 479         WARN(midi,"can't notify client !\n");
 480         return MMSYSERR_INVALPARAM;
 481     }
 482     return MMSYSERR_NOERROR;
 483 }
 484
 485 /**************************************************************************
 486  *                      midClose                                [internal]
 487  */
 488 static DWORD midClose(WORD wDevID)
 489 {
 490     int         ret = MMSYSERR_NOERROR;
 491
 492     TRACE(midi, "(%04X);\n", wDevID);
 493
 494     if (wDevID >= MAX_MIDIINDRV) {
 495         WARN(midi,"wDevID too bif (%u) !\n", wDevID);
 496         return MMSYSERR_BADDEVICEID;
 497     }
 498     if (MidiInDev[wDevID].midiDesc == 0) {
 499         WARN(midi, "device not opened !\n");
 500         return MMSYSERR_ERROR;
 501     }
 502     if (MidiInDev[wDevID].lpQueueHdr != 0) {
 503         return MIDIERR_STILLPLAYING;
 504     }
 505
 506 #ifdef HAVE_OSS
 507     if (midiSeqFD == -1) {
 508         WARN(midi,"ooops !\n");
 509         return MMSYSERR_ERROR;
 510     }
 511     if (--numStartedMidiIn == 0) {
 512         TRACE(midi, "Stopping timer for midi-in\n");
 513         if (!KillTimer(0, midiInTimerID)) {
 514             WARN(midi, "Couldn't stop timer for midi-in\n");
 515         }
 516         midiInTimerID = 0;
 517     }
 518     midiCloseSeq();
 519 #else /* HAVE_OSS */
 520     if (MidiInDev[wDevID].unixdev == 0) {
 521         WARN(midi,"ooops !\n");
 522         return MMSYSERR_ERROR;
 523     }
 524     close(MidiInDev[wDevID].unixdev);
 525     MidiInDev[wDevID].unixdev = 0;
 526 #endif /* HAVE_OSS */
 527     MidiInDev[wDevID].bufsize = 0;
 528     if (MIDI_NotifyClient(wDevID, MIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
 529         WARN(midi,"can't notify client !\n");
 530         ret = MMSYSERR_INVALPARAM;
 531     }
 532     MidiInDev[wDevID].midiDesc = 0;
 533     return ret;
 534 }
 535
 536 /**************************************************************************
 537  *                              midAddBuffer                    [internal]
 538  */
 539 static DWORD midAddBuffer(WORD wDevID, LPMIDIHDR16 lpMidiHdr, DWORD dwSize)
 540 {
 541     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
 542
 543     if (lpMidiHdr == NULL)      return MMSYSERR_INVALPARAM;
 544     if (sizeof(MIDIHDR16) != dwSize) return MMSYSERR_INVALPARAM;
 545     if (lpMidiHdr->dwBufferLength == 0) return MMSYSERR_INVALPARAM;
 546     if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
 547     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
 548
 549     if (MidiInDev[wDevID].lpQueueHdr == 0) {
 550         MidiInDev[wDevID].lpQueueHdr = lpMidiHdr;
 551     } else {
 552         LPMIDIHDR16     ptr;
 553
 554         for (ptr = MidiInDev[wDevID].lpQueueHdr;
 555              ptr->lpNext != 0;
 556              ptr = (LPMIDIHDR16)ptr->lpNext);
 557         ptr->lpNext = (struct midihdr_tag*)lpMidiHdr;
 558     }
 559     return MMSYSERR_NOERROR;
 560 }
 561
 562 /**************************************************************************
 563  *                              midPrepare                      [internal]
 564  */
 565 static DWORD midPrepare(WORD wDevID, LPMIDIHDR16 lpMidiHdr, DWORD dwSize)
 566 {
 567     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
 568
 569     if (dwSize != sizeof(MIDIHDR16) || lpMidiHdr == 0 ||
 570         lpMidiHdr->lpData == 0 || lpMidiHdr->dwFlags != 0 ||
 571         lpMidiHdr->dwBufferLength >= 0x10000ul)
 572         return MMSYSERR_INVALPARAM;
 573
 574     lpMidiHdr->lpNext = 0;
 575     lpMidiHdr->dwFlags |= MHDR_PREPARED;
 576     lpMidiHdr->dwBytesRecorded = 0;
 577
 578     return MMSYSERR_NOERROR;
 579 }
 580
 581 /**************************************************************************
 582  *                              midUnprepare                    [internal]
 583  */
 584 static DWORD midUnprepare(WORD wDevID, LPMIDIHDR16 lpMidiHdr, DWORD dwSize)
 585 {
 586     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
 587
 588     if (dwSize != sizeof(MIDIHDR16) || lpMidiHdr == 0 ||
 589         lpMidiHdr->lpData == 0 || lpMidiHdr->dwBufferLength >= 0x10000ul)
 590         return MMSYSERR_INVALPARAM;
 591
 592     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
 593     if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
 594
 595     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
 596
 597     return MMSYSERR_NOERROR;
 598 }
 599
 600 /**************************************************************************
 601  *                      midReset                                [internal]
 602  */
 603 static DWORD midReset(WORD wDevID)
 604 {
 605     DWORD               dwTime = GetTickCount();
 606
 607     TRACE(midi, "(%04X);\n", wDevID);
 608
 609     while (MidiInDev[wDevID].lpQueueHdr) {
 610         MidiInDev[wDevID].lpQueueHdr->dwFlags &= ~MHDR_INQUEUE;
 611         MidiInDev[wDevID].lpQueueHdr->dwFlags |= MHDR_DONE;
 612         if (MIDI_NotifyClient(wDevID, MIM_LONGDATA,
 613                               (DWORD)MidiInDev[wDevID].lpQueueHdr, dwTime) != MMSYSERR_NOERROR) {
 614             WARN(midi, "Couldn't notify client\n");
 615         }
 616         MidiInDev[wDevID].lpQueueHdr = (LPMIDIHDR16)MidiInDev[wDevID].lpQueueHdr->lpNext;
 617     }
 618
 619     return MMSYSERR_NOERROR;
 620 }
 621
 622
 623 /**************************************************************************
 624  *                      midStart                                [internal]
 625  */
 626 static DWORD midStart(WORD wDevID)
 627 {
 628     TRACE(midi, "(%04X);\n", wDevID);
 629
 630     /* FIXME : should test value of wDevID */
 631
 632 #ifdef HAVE_OSS
 633     MidiInDev[wDevID].state = 1;
 634     MidiInDev[wDevID].startTime = GetTickCount();
 635     return MMSYSERR_NOERROR;
 636 #else
 637     return MMSYSERR_NOTENABLED;
 638 #endif /* HAVE_OSS */
 639 }
 640
 641 /**************************************************************************
 642  *                      midStop                                 [internal]
 643  */
 644 static DWORD midStop(WORD wDevID)
 645 {
 646     TRACE(midi, "(%04X);\n", wDevID);
 647
 648     /* FIXME : should test value of wDevID */
 649
 650 #ifdef HAVE_OSS
 651     MidiInDev[wDevID].state = 0;
 652     return MMSYSERR_NOERROR;
 653 #else /* HAVE_OSS */
 654     return MMSYSERR_NOTENABLED;
 655 #endif /* HAVE_OSS */
 656 }
 657
 658 /*-----------------------------------------------------------------------*/
 659
 660 #ifdef HAVE_OSS
 661
 662 typedef struct sVoice {
 663     int                 note;                   /* 0 means not used */
 664     int                 channel;
 665     unsigned            cntMark : 30,
 666                         status : 2;
 667 #define sVS_UNUSED      0
 668 #define sVS_PLAYING     1
 669 #define sVS_SUSTAINED   2
 670 } sVoice;
 671
 672 typedef struct sChannel {
 673     int                 program;
 674
 675     int                 bender;
 676     int                 benderRange;
 677     /* controlers */
 678     int                 bank;           /* CTL_BANK_SELECT */
 679     int                 volume;         /* CTL_MAIN_VOLUME */
 680     int                 balance;        /* CTL_BALANCE     */
 681     int                 expression;     /* CTL_EXPRESSION  */
 682     int                 sustain;        /* CTL_SUSTAIN     */
 683
 684     unsigned char       nrgPmtMSB;      /* Non register Parameters */
 685     unsigned char       nrgPmtLSB;
 686     unsigned char       regPmtMSB;      /* Non register Parameters */
 687     unsigned char       regPmtLSB;
 688 } sChannel;
 689
 690 typedef struct sFMextra {
 691     unsigned            counter;
 692     int                 drumSetMask;
 693     sChannel            channel[16];    /* MIDI has only 16 channels */
 694     sVoice              voice[1];       /* dyn allocated according to sound card */
 695     /* do not append fields below voice[1] since the size of this structure
 696      * depends on the number of available voices on the FM synth...
 697      */
 698 } sFMextra;
 699
 700 extern  unsigned char midiFMInstrumentPatches[16 * 128];
 701 extern  unsigned char midiFMDrumsPatches     [16 * 128];
 702
 703 /**************************************************************************
 704  *                      modFMLoad                               [internal]
 705  */
 706 static int modFMLoad(int dev)
 707 {
 708     int                         i;
 709     struct sbi_instrument       sbi;
 710
 711     sbi.device = dev;
 712     sbi.key = FM_PATCH;
 713
 714     memset(sbi.operators + 16, 0, 16);
 715     for (i = 0; i < 128; i++) {
 716         sbi.channel = i;
 717         memcpy(sbi.operators, midiFMInstrumentPatches + i * 16, 16);
 718
 719         if (write(midiSeqFD, (char*)&sbi, sizeof(sbi)) == -1) {
 720             WARN(midi, "Couldn't write patch for instrument %d (%d)!\n", sbi.channel, errno);
 721             return -1;
 722         }
 723     }
 724     for (i = 0; i < 128; i++) {
 725         sbi.channel = 128 + i;
 726         memcpy(sbi.operators, midiFMDrumsPatches + i * 16, 16);
 727
 728         if (write(midiSeqFD, (char*)&sbi, sizeof(sbi)) == -1) {
 729             WARN(midi, "Couldn't write patch for drum %d (%d)!\n", sbi.channel, errno);
 730             return -1;
 731         }
 732     }
 733     return 0;
 734 }
 735
 736 /**************************************************************************
 737  *                      modFMReset                              [internal]
 738  */
 739 static  void modFMReset(WORD wDevID)
 740 {
 741     sFMextra*   extra   = (sFMextra*)MidiOutDev[wDevID].lpExtra;
 742     sVoice*     voice   = extra->voice;
 743     sChannel*   channel = extra->channel;
 744     int         i;
 745
 746     for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
 747         if (voice[i].status != sVS_UNUSED) {
 748             SEQ_STOP_NOTE(wDevID, i, voice[i].note, 64);
 749         }
 750         SEQ_KEY_PRESSURE(wDevID, i, 127, 0);
 751         SEQ_CONTROL(wDevID, i, SEQ_VOLMODE, VOL_METHOD_LINEAR);
 752         voice[i].note = 0;
 753         voice[i].channel = -1;
 754         voice[i].cntMark = 0;
 755         voice[i].status = sVS_UNUSED;
 756     }
 757     for (i = 0; i < 16; i++) {
 758         channel[i].program = 0;
 759         channel[i].bender = 8192;
 760         channel[i].benderRange = 2;
 761         channel[i].bank = 0;
 762         channel[i].volume = 127;
 763         channel[i].balance = 64;
 764         channel[i].expression = 0;
 765         channel[i].sustain = 0;
 766     }
 767     extra->counter = 0;
 768     extra->drumSetMask = 1 << 9; /* channel 10 is normally drums, sometimes 16 also */
 769     SEQ_DUMPBUF();
 770 }
 771
 772 #define         IS_DRUM_CHANNEL(_xtra, _chn)    ((_xtra)->drumSetMask & (1 << (_chn)))
 773
 774 #endif /* HAVE_OSS */
 775
 776 /**************************************************************************
 777  *                              modGetDevCaps                   [internal]
 778  */
 779 static DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS16 lpCaps,
 780                            DWORD dwSize)
 781 {
 782     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpCaps, dwSize);
 783     if (wDevID == (WORD) MIDI_MAPPER) {
 784         lpCaps->wMid = 0x00FF;  /* Manufac ID */
 785         lpCaps->wPid = 0x0001;  /* Product ID */
 786         lpCaps->vDriverVersion = 0x001; /* Product Version */
 787         strcpy(lpCaps->szPname, "MIDI Mapper (not functional yet)");
 788         /* FIXME Does it make any difference ? */
 789         lpCaps->wTechnology = MOD_FMSYNTH;
 790         lpCaps->wVoices     = 14;       /* FIXME */
 791         lpCaps->wNotes      = 14;       /* FIXME */
 792         /* FIXME Does it make any difference ? */
 793         lpCaps->dwSupport   = MIDICAPS_VOLUME|MIDICAPS_LRVOLUME;
 794     } else {
 795         LPMIDIOUTCAPS16 tmplpCaps;
 796
 797         if (wDevID >= MODM_NUMDEVS) {
 798             TRACE(midi, "MAX_MIDIOUTDRV reached !\n");
 799             return MMSYSERR_BADDEVICEID;
 800         }
 801         /* FIXME There is a way to do it so easily, but I'm too
 802          * sleepy to think and I want to test
 803          */
 804
 805         tmplpCaps = midiOutDevices[wDevID];
 806         lpCaps->wMid = tmplpCaps->wMid;
 807         lpCaps->wPid = tmplpCaps->wPid;
 808         lpCaps->vDriverVersion = tmplpCaps->vDriverVersion;
 809         strcpy(lpCaps->szPname, tmplpCaps->szPname);
 810         lpCaps->wTechnology = tmplpCaps->wTechnology;
 811         lpCaps->wVoices = tmplpCaps->wVoices;
 812         lpCaps->wNotes = tmplpCaps->wNotes;
 813         lpCaps->dwSupport = tmplpCaps->dwSupport;
 814     }
 815     return MMSYSERR_NOERROR;
 816 }
 817
 818 /**************************************************************************
 819  *                      modOpen                                 [internal]
 820  */
 821 static DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 822 {
 823     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
 824     if (lpDesc == NULL) {
 825         WARN(midi, "Invalid Parameter !\n");
 826         return MMSYSERR_INVALPARAM;
 827     }
 828     if (wDevID >= MAX_MIDIOUTDRV) {
 829         TRACE(midi,"MAX_MIDIOUTDRV reached !\n");
 830         return MMSYSERR_BADDEVICEID;
 831     }
 832     if (MidiOutDev[wDevID].midiDesc != 0) {
 833         WARN(midi, "device already open !\n");
 834         return MMSYSERR_ALLOCATED;
 835     }
 836     if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) {
 837         WARN(midi, "bad dwFlags\n");
 838         return MMSYSERR_INVALFLAG;
 839     }
 840     if (midiOutDevices[wDevID] == NULL) {
 841         TRACE(midi, "un-allocated wDevID\n");
 842         return MMSYSERR_BADDEVICEID;
 843     }
 844
 845 #ifdef HAVE_OSS
 846     MidiOutDev[wDevID].lpExtra = 0;
 847
 848     switch (midiOutDevices[wDevID]->wTechnology) {
 849     case MOD_FMSYNTH:
 850         {
 851             void*       extra = xmalloc(sizeof(struct sFMextra) +
 852                                         sizeof(struct sVoice) *
 853                                         (midiOutDevices[wDevID]->wVoices - 1));
 854
 855             if (extra == 0) {
 856                 WARN(midi, "can't alloc extra data !\n");
 857                 return MMSYSERR_NOMEM;
 858             }
 859             MidiOutDev[wDevID].lpExtra = extra;
 860             if (midiOpenSeq() < 0) {
 861                 MidiOutDev[wDevID].lpExtra = 0;
 862                 free(extra);
 863                 return MMSYSERR_ERROR;
 864             }
 865             if (modFMLoad(wDevID) < 0) {
 866                 midiCloseSeq();
 867                 MidiOutDev[wDevID].lpExtra = 0;
 868                 free(extra);
 869                 return MMSYSERR_ERROR;
 870             }
 871             modFMReset(wDevID);
 872         }
 873         break;
 874     case MOD_MIDIPORT:
 875         if (midiOpenSeq() < 0) {
 876             return MMSYSERR_ALLOCATED;
 877         }
 878         break;
 879     default:
 880         WARN(midi,"Technology not supported (yet) %d !\n",
 881              midiOutDevices[wDevID]->wTechnology);
 882         return MMSYSERR_NOTENABLED;
 883     }
 884 #else /* HAVE_OSS */
 885     {
 886         int     midi = open (MIDI_DEV, O_WRONLY, 0);
 887         MidiOutDev[wDevID].unixdev = 0;
 888         if (midi == -1) {
 889             WARN(midi, "can't open !\n");
 890             return MMSYSERR_ALLOCATED;
 891         }
 892         MidiOutDev[wDevID].unixdev = midi;
 893     }
 894 #endif /* HAVE_OSS */
 895
 896     MidiOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 897     switch (MidiOutDev[wDevID].wFlags) {
 898     case DCB_NULL:
 899         TRACE(midi,"CALLBACK_NULL !\n");
 900         break;
 901     case DCB_WINDOW:
 902         TRACE(midi, "CALLBACK_WINDOW !\n");
 903         break;
 904     case DCB_TASK:
 905         TRACE(midi, "CALLBACK_TASK !\n");
 906         break;
 907     case DCB_FUNCTION:
 908         TRACE(midi, "CALLBACK_FUNCTION !\n");
 909         break;
 910     }
 911     MidiOutDev[wDevID].lpQueueHdr = NULL;
 912     MidiOutDev[wDevID].dwTotalPlayed = 0;
 913     MidiOutDev[wDevID].bufsize = 0x3FFF;
 914     MidiOutDev[wDevID].midiDesc = lpDesc;
 915
 916     if (MIDI_NotifyClient(wDevID, MOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
 917         WARN(midi,"can't notify client !\n");
 918         return MMSYSERR_INVALPARAM;
 919     }
 920     TRACE(midi, "Succesful !\n");
 921     return MMSYSERR_NOERROR;
 922 }
 923
 924
 925 /**************************************************************************
 926  *                      modClose                                [internal]
 927  */
 928 static DWORD modClose(WORD wDevID)
 929 {
 930     int ret = MMSYSERR_NOERROR;
 931
 932     TRACE(midi, "(%04X);\n", wDevID);
 933
 934     if (MidiOutDev[wDevID].midiDesc == 0) {
 935         WARN(midi, "device not opened !\n");
 936         return MMSYSERR_ERROR;
 937     }
 938     /* FIXME: should test that no pending buffer is still in the queue for
 939      * playing */
 940
 941 #ifdef HAVE_OSS
 942     if (midiSeqFD == -1) {
 943         WARN(midi,"can't close !\n");
 944         return MMSYSERR_ERROR;
 945     }
 946
 947     switch (midiOutDevices[wDevID]->wTechnology) {
 948     case MOD_FMSYNTH:
 949     case MOD_MIDIPORT:
 950         midiCloseSeq();
 951         break;
 952     default:
 953         WARN(midi,"Technology not supported (yet) %d !\n",
 954              midiOutDevices[wDevID]->wTechnology);
 955         return MMSYSERR_NOTENABLED;
 956     }
 957
 958     if (MidiOutDev[wDevID].lpExtra != 0) {
 959         free(MidiOutDev[wDevID].lpExtra);
 960         MidiOutDev[wDevID].lpExtra = 0;
 961     }
 962 #else
 963     if (MidiOutDev[wDevID].unixdev == 0) {
 964         WARN(midi,"can't close !\n");
 965         return MMSYSERR_NOTENABLED;
 966     }
 967     close(MidiOutDev[wDevID].unixdev);
 968     MidiOutDev[wDevID].unixdev = 0;
 969 #endif /* HAVE_OSS */
 970
 971     MidiOutDev[wDevID].bufsize = 0;
 972     if (MIDI_NotifyClient(wDevID, MOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
 973         WARN(midi,"can't notify client !\n");
 974         ret = MMSYSERR_INVALPARAM;
 975     }
 976     MidiOutDev[wDevID].midiDesc = 0;
 977     return ret;
 978 }
 979
 980 /**************************************************************************
 981  *                      modData                                 [internal]
 982  */
 983 static DWORD modData(WORD wDevID, DWORD dwParam)
 984 {
 985     WORD        evt = LOBYTE(LOWORD(dwParam));
 986     WORD        d1  = HIBYTE(LOWORD(dwParam));
 987     WORD        d2  = LOBYTE(HIWORD(dwParam));
 988
 989     TRACE(midi, "(%04X, %08lX);\n", wDevID, dwParam);
 990
 991 #ifdef HAVE_OSS
 992     if (midiSeqFD == -1) {
 993         WARN(midi,"can't play !\n");
 994         return MIDIERR_NODEVICE;
 995     }
 996     switch (midiOutDevices[wDevID]->wTechnology) {
 997     case MOD_FMSYNTH:
 998         /* FIXME:
 999          *      - chorus depth controller is not used
1000          */
1001         {
1002             sFMextra*   extra   = (sFMextra*)MidiOutDev[wDevID].lpExtra;
1003             sVoice*     voice   = extra->voice;
1004             sChannel*   channel = extra->channel;
1005             int         chn = (evt & 0x0F);
1006             int         i, nv;
1007
1008             switch (evt & 0xF0) {
1009             case MIDI_NOTEOFF:
1010                 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1011                                 /* don't stop sustained notes */
1012                     if (voice[i].status == sVS_PLAYING && voice[i].channel == chn && voice[i].note == d1) {
1013                         voice[i].status = sVS_UNUSED;
1014                         SEQ_STOP_NOTE(wDevID, i, d1, d2);
1015                     }
1016                 }
1017                 break;
1018             case MIDI_NOTEON:
1019                 if (d2 == 0) { /* note off if velocity == 0 */
1020                     for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1021                         /* don't stop sustained notes */
1022                         if (voice[i].status == sVS_PLAYING && voice[i].channel == chn && voice[i].note == d1) {
1023                             voice[i].status = sVS_UNUSED;
1024                             SEQ_STOP_NOTE(wDevID, i, d1, 64);
1025                         }
1026                     }
1027                     break;
1028                 }
1029                 /* finding out in this order :
1030                  *      - an empty voice
1031                  *      - if replaying the same note on the same channel
1032                  *      - the older voice (LRU)
1033                  */
1034                 for (i = nv = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1035                     if (voice[i].status == sVS_UNUSED ||
1036                         (voice[i].note == d1 && voice[i].channel == chn)) {
1037                         nv = i;
1038                         break;
1039                     }
1040                     if (voice[i].cntMark < voice[0].cntMark) {
1041                         nv = i;
1042                     }
1043                 }
1044                 TRACE(midi,
1045                       "playing on voice=%d, pgm=%d, pan=0x%02X, vol=0x%02X, "
1046                       "bender=0x%02X, note=0x%02X, vel=0x%02X\n",
1047                       nv, channel[chn].program,
1048                       channel[chn].balance,
1049                       channel[chn].volume,
1050                       channel[chn].bender, d1, d2);
1051
1052                 SEQ_SET_PATCH(wDevID, nv, IS_DRUM_CHANNEL(extra, chn) ?
1053                               (128 + d1) : channel[chn].program);
1054                 SEQ_BENDER_RANGE(wDevID, nv, channel[chn].benderRange * 100);
1055                 SEQ_BENDER(wDevID, nv, channel[chn].bender);
1056                 SEQ_CONTROL(wDevID, nv, CTL_PAN, channel[chn].balance);
1057                 SEQ_CONTROL(wDevID, nv, CTL_EXPRESSION, channel[chn].expression);
1058 #if 0
1059                 /* FIXME: does not really seem to work on my SB card and
1060                  * screws everything up... so lay it down
1061                  */
1062                 SEQ_CONTROL(wDevID, nv, CTL_MAIN_VOLUME, channel[chn].volume);
1063 #endif
1064                 SEQ_START_NOTE(wDevID, nv, d1, d2);
1065                 voice[nv].status = channel[chn].sustain ? sVS_SUSTAINED : sVS_PLAYING;
1066                 voice[nv].note = d1;
1067                 voice[nv].channel = chn;
1068                 voice[nv].cntMark = extra->counter++;
1069                 break;
1070             case MIDI_KEY_PRESSURE:
1071                 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1072                     if (voice[i].status != sVS_UNUSED && voice[i].channel == chn && voice[i].note == d1) {
1073                         SEQ_KEY_PRESSURE(wDevID, i, d1, d2);
1074                     }
1075                 }
1076                 break;
1077             case MIDI_CTL_CHANGE:
1078                 switch (d1) {
1079                 case CTL_BANK_SELECT:   channel[chn].bank = d2;         break;
1080                 case CTL_MAIN_VOLUME:   channel[chn].volume = d2;       break;
1081                 case CTL_PAN:           channel[chn].balance = d2;      break;
1082                 case CTL_EXPRESSION:    channel[chn].expression = d2;   break;
1083                 case CTL_SUSTAIN:       channel[chn].sustain = d2;
1084                     if (d2) {
1085                         for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1086                             if (voice[i].status == sVS_PLAYING && voice[i].channel == chn) {
1087                                 voice[i].status = sVS_SUSTAINED;
1088                             }
1089                         }
1090                     } else {
1091                         for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1092                             if (voice[i].status == sVS_SUSTAINED && voice[i].channel == chn) {
1093                                 voice[i].status = sVS_UNUSED;
1094                                 SEQ_STOP_NOTE(wDevID, i, voice[i].note, 64);
1095                             }
1096                         }
1097                     }
1098                     break;
1099                 case CTL_NONREG_PARM_NUM_LSB:   channel[chn].nrgPmtLSB = d2;    break;
1100                 case CTL_NONREG_PARM_NUM_MSB:   channel[chn].nrgPmtMSB = d2;    break;
1101                 case CTL_REGIST_PARM_NUM_LSB:   channel[chn].regPmtLSB = d2;    break;
1102                 case CTL_REGIST_PARM_NUM_MSB:   channel[chn].regPmtMSB = d2;    break;
1103
1104                 case CTL_DATA_ENTRY:
1105                     switch ((channel[chn].regPmtMSB << 8) | channel[chn].regPmtLSB) {
1106                     case 0x0000:
1107                         if (channel[chn].benderRange != d2) {
1108                             channel[chn].benderRange = d2;
1109                             for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1110                                 if (voice[i].channel == chn) {
1111                                     SEQ_BENDER_RANGE(wDevID, i, channel[chn].benderRange);
1112                                 }
1113                             }
1114                         }
1115                         break;
1116
1117                     case 0x7F7F:
1118                         channel[chn].benderRange = 2;
1119                         for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1120                             if (voice[i].channel == chn) {
1121                                 SEQ_BENDER_RANGE(wDevID, i, channel[chn].benderRange);
1122                             }
1123                         }
1124                         break;
1125                     default:
1126                         TRACE(midi, "Data entry: regPmt=0x%02x%02x, nrgPmt=0x%02x%02x with %x\n",
1127                               channel[chn].regPmtMSB, channel[chn].regPmtLSB,
1128                               channel[chn].nrgPmtMSB, channel[chn].nrgPmtLSB,
1129                               d2);
1130                         break;
1131                     }
1132                     break;
1133
1134                 case 0x78: /* all sounds off */
1135                     /* FIXME: I don't know if I have to take care of the channel
1136                      * for this control ?
1137                      */
1138                     for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1139                         if (voice[i].status != sVS_UNUSED && voice[i].channel == chn) {
1140                             voice[i].status = sVS_UNUSED;
1141                             SEQ_STOP_NOTE(wDevID, i, voice[i].note, 0);
1142                         }
1143                     }
1144                     break;
1145                 case 0x7B: /* all notes off */
1146                     /* FIXME: I don't know if I have to take care of the channel
1147                      * for this control ?
1148                      */
1149                     for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1150                         if (voice[i].status == sVS_PLAYING && voice[i].channel == chn) {
1151                             voice[i].status = sVS_UNUSED;
1152                             SEQ_STOP_NOTE(wDevID, i, voice[i].note, 0);
1153                         }
1154                     }
1155                     break;
1156                 default:
1157                     TRACE(midi, "Dropping MIDI control event 0x%02x(%02x) on channel %d\n",
1158                           d1, d2, chn);
1159                     break;
1160                 }
1161                 break;
1162             case MIDI_PGM_CHANGE:
1163                 channel[chn].program = d1;
1164                 break;
1165             case MIDI_CHN_PRESSURE:
1166                 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1167                     if (voice[i].status != sVS_UNUSED && voice[i].channel == chn) {
1168                         SEQ_KEY_PRESSURE(wDevID, i, voice[i].note, d1);
1169                     }
1170                 }
1171                 break;
1172             case MIDI_PITCH_BEND:
1173                 channel[chn].bender = (d2 << 7) + d1;
1174                 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1175                     if (voice[i].channel == chn) {
1176                         SEQ_BENDER(wDevID, i, channel[chn].bender);
1177                     }
1178                 }
1179                 break;
1180             case MIDI_SYSTEM_PREFIX:
1181                 switch (evt & 0x0F) {
1182                 case 0x0F:      /* Reset */
1183                     modFMReset(wDevID);
1184                     break;
1185                 default:
1186                     WARN(midi, "Unsupported (yet) system event %02x\n", evt & 0x0F);
1187                 }
1188                 break;
1189             default:
1190                 WARN(midi, "Internal error, shouldn't happen (event=%08x)\n", evt & 0xF0);
1191                 return MMSYSERR_NOTENABLED;
1192             }
1193         }
1194         break;
1195     case MOD_MIDIPORT:
1196         {
1197             int dev = wDevID - MODM_NUMFMSYNTHDEVS;
1198             if (dev < 0) {
1199                 WARN(midi, "Internal error on devID (%u) !\n", wDevID);
1200                 return MIDIERR_NODEVICE;
1201             }
1202
1203             switch (evt & 0xF0) {
1204             case MIDI_NOTEOFF:
1205             case MIDI_NOTEON:
1206             case MIDI_KEY_PRESSURE:
1207             case MIDI_CTL_CHANGE:
1208             case MIDI_PITCH_BEND:
1209                 SEQ_MIDIOUT(dev, evt);
1210                 SEQ_MIDIOUT(dev, d1);
1211                 SEQ_MIDIOUT(dev, d2);
1212                 break;
1213             case MIDI_PGM_CHANGE:
1214             case MIDI_CHN_PRESSURE:
1215                 SEQ_MIDIOUT(dev, evt);
1216                 SEQ_MIDIOUT(dev, d1);
1217                 break;
1218             case MIDI_SYSTEM_PREFIX:
1219                 switch (evt & 0x0F) {
1220                 case 0x00:      /* System Exclusive, don't do it on modData,
1221                                  * should require modLongData*/
1222                 case 0x01:      /* Undefined */
1223                 case 0x04:      /* Undefined. */
1224                 case 0x05:      /* Undefined. */
1225                 case 0x07:      /* End of Exclusive. */
1226                 case 0x09:      /* Undefined. */
1227                 case 0x0D:      /* Undefined. */
1228                     break;
1229                 case 0x06:      /* Tune Request */
1230                 case 0x08:      /* Timing Clock. */
1231                 case 0x0A:      /* Start. */
1232                 case 0x0B:      /* Continue */
1233                 case 0x0C:      /* Stop */
1234                 case 0x0E:      /* Active Sensing. */
1235                     SEQ_MIDIOUT(dev, evt);
1236                     break;
1237                 case 0x0F:      /* Reset */
1238                                 /* SEQ_MIDIOUT(dev, evt);
1239                                    this other way may be better */
1240                     SEQ_MIDIOUT(dev, MIDI_SYSTEM_PREFIX);
1241                     SEQ_MIDIOUT(dev, 0x7e);
1242                     SEQ_MIDIOUT(dev, 0x7f);
1243                     SEQ_MIDIOUT(dev, 0x09);
1244                     SEQ_MIDIOUT(dev, 0x01);
1245                     SEQ_MIDIOUT(dev, 0xf7);
1246                     break;
1247                 case 0x03:      /* Song Select. */
1248                     SEQ_MIDIOUT(dev, evt);
1249                     SEQ_MIDIOUT(dev, d1);
1250                 case 0x02:      /* Song Position Pointer. */
1251                     SEQ_MIDIOUT(dev, evt);
1252                     SEQ_MIDIOUT(dev, d1);
1253                     SEQ_MIDIOUT(dev, d2);
1254                 }
1255                 break;
1256             }
1257         }
1258         break;
1259     default:
1260         WARN(midi, "Technology not supported (yet) %d !\n",
1261              midiOutDevices[wDevID]->wTechnology);
1262         return MMSYSERR_NOTENABLED;
1263     }
1264
1265     SEQ_DUMPBUF();
1266 #else
1267     if (MidiOutDev[wDevID].unixdev == 0) {
1268         WARN(midi,"can't play !\n");
1269         return MIDIERR_NODEVICE;
1270     }
1271     {
1272         WORD    event = LOWORD(dwParam);
1273         if (write (MidiOutDev[wDevID].unixdev,
1274                    &event, sizeof(event)) != sizeof(WORD)) {
1275             WARN(midi, "error writting unixdev !\n");
1276         }
1277     }
1278 #endif /* HAVE_OSS */
1279     return MMSYSERR_NOERROR;
1280 }
1281
1282 /**************************************************************************
1283  *              modLongData                                     [internal]
1284  */
1285 static DWORD modLongData(WORD wDevID, LPMIDIHDR16 lpMidiHdr, DWORD dwSize)
1286 {
1287     int         count;
1288
1289     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1290
1291 #ifdef HAVE_OSS
1292     if (midiSeqFD == -1) {
1293         WARN(midi,"can't play !\n");
1294         return MIDIERR_NODEVICE;
1295     }
1296 #else /* HAVE_OSS */
1297     if (MidiOutDev[wDevID].unixdev == 0) {
1298         WARN(midi,"can't play !\n");
1299         return MIDIERR_NODEVICE;
1300     }
1301 #endif /* HAVE_OSS */
1302
1303     if (lpMidiHdr->lpData == NULL)
1304         return MIDIERR_UNPREPARED;
1305     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
1306         return MIDIERR_UNPREPARED;
1307     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
1308         return MIDIERR_STILLPLAYING;
1309     lpMidiHdr->dwFlags &= ~MHDR_DONE;
1310     lpMidiHdr->dwFlags |= MHDR_INQUEUE;
1311
1312     TRACE(midi, "dwBytesRecorded %lu !\n", lpMidiHdr->dwBytesRecorded);
1313     TRACE(midi, "                 %02X %02X %02X %02X\n",
1314           ((LPBYTE)(lpMidiHdr->reserved))[0],
1315           ((LPBYTE)(lpMidiHdr->reserved))[1],
1316           ((LPBYTE)(lpMidiHdr->reserved))[2],
1317           ((LPBYTE)(lpMidiHdr->reserved))[3]);
1318 #ifdef HAVE_OSS
1319     switch (midiOutDevices[wDevID]->wTechnology) {
1320     case MOD_FMSYNTH:
1321         /* FIXME: I don't think there is much to do here */
1322         break;
1323     case MOD_MIDIPORT:
1324         if (((LPBYTE)lpMidiHdr->reserved)[0] != 0xF0) {
1325             /* Send end of System Exclusive */
1326             SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS, 0xF0);
1327             TRACE(midi, "Adding missing 0xF0 marker at the begining of "
1328                   "system exclusive byte stream\n");
1329         }
1330         for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) {
1331             SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS,
1332                         ((LPBYTE)lpMidiHdr->reserved)[count]);
1333         }
1334         if (((LPBYTE)lpMidiHdr->reserved)[count - 1] != 0xF7) {
1335             /* Send end of System Exclusive */
1336             SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS, 0xF7);
1337             TRACE(midi, "Adding missing 0xF7 marker at the end of "
1338                   "system exclusive byte stream\n");
1339         }
1340         SEQ_DUMPBUF();
1341         break;
1342     default:
1343         WARN(midi, "Technology not supported (yet) %d !\n",
1344              midiOutDevices[wDevID]->wTechnology);
1345         return MMSYSERR_NOTENABLED;
1346     }
1347 #else /* HAVE_OSS */
1348     {
1349         LPWORD  ptr = (LPWORD)lpMidiHdr->reserved;
1350         int             en;
1351
1352         for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) {
1353             if (write(MidiOutDev[wDevID].unixdev,
1354                       ptr, sizeof(WORD)) != sizeof(WORD))
1355                 break;
1356             ptr++;
1357         }
1358
1359         en = errno;
1360         TRACE(midi, "after write count = %d\n",count);
1361         if (count != lpMidiHdr->dwBytesRecorded) {
1362             WARN(midi, "error writting unixdev #%d ! (%d != %ld)\n",
1363                  MidiOutDev[wDevID].unixdev, count,
1364                  lpMidiHdr->dwBytesRecorded);
1365             TRACE(midi, "\terrno = %d error = %s\n",en,strerror(en));
1366             return MMSYSERR_NOTENABLED;
1367         }
1368     }
1369 #endif /* HAVE_OSS */
1370
1371     lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1372     lpMidiHdr->dwFlags |= MHDR_DONE;
1373     if (MIDI_NotifyClient(wDevID, MOM_DONE, (DWORD)lpMidiHdr, 0L) != MMSYSERR_NOERROR) {
1374         WARN(midi,"can't notify client !\n");
1375         return MMSYSERR_INVALPARAM;
1376     }
1377     return MMSYSERR_NOERROR;
1378 }
1379
1380 /**************************************************************************
1381  *                      modPrepare                              [internal]
1382  */
1383 static DWORD modPrepare(WORD wDevID, LPMIDIHDR16 lpMidiHdr, DWORD dwSize)
1384 {
1385     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1386
1387 #ifdef HAVE_OSS
1388     if (midiSeqFD == -1) {
1389         WARN(midi,"can't prepare !\n");
1390         return MMSYSERR_NOTENABLED;
1391     }
1392 #else /* HAVE_OSS */
1393     if (MidiOutDev[wDevID].unixdev == 0) {
1394         WARN(midi,"can't prepare !\n");
1395         return MMSYSERR_NOTENABLED;
1396     }
1397 #endif /* HAVE_OSS */
1398     if (dwSize != sizeof(MIDIHDR16) || lpMidiHdr == 0 ||
1399         lpMidiHdr->lpData == 0 || lpMidiHdr->dwFlags != 0 ||
1400         lpMidiHdr->dwBufferLength >= 0x10000ul)
1401         return MMSYSERR_INVALPARAM;
1402
1403     lpMidiHdr->lpNext = 0;
1404     lpMidiHdr->dwFlags |= MHDR_PREPARED;
1405     lpMidiHdr->dwFlags &= ~MHDR_DONE;
1406     return MMSYSERR_NOERROR;
1407 }
1408
1409 /**************************************************************************
1410  *                              modUnprepare                    [internal]
1411  */
1412 static DWORD modUnprepare(WORD wDevID, LPMIDIHDR16 lpMidiHdr, DWORD dwSize)
1413 {
1414     TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1415
1416 #ifdef HAVE_OSS
1417     if (midiSeqFD == -1) {
1418         WARN(midi,"can't unprepare !\n");
1419         return MMSYSERR_NOTENABLED;
1420     }
1421 #else /* HAVE_OSS */
1422     if (MidiOutDev[wDevID].unixdev == 0) {
1423         WARN(midi,"can't unprepare !\n");
1424         return MMSYSERR_NOTENABLED;
1425     }
1426 #endif /* HAVE_OSS */
1427     if (dwSize != sizeof(MIDIHDR16) || lpMidiHdr == 0)
1428         return MMSYSERR_INVALPARAM;
1429     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
1430         return MIDIERR_STILLPLAYING;
1431     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
1432     return MMSYSERR_NOERROR;
1433 }
1434
1435 /**************************************************************************
1436  *                      modReset                                [internal]
1437  */
1438 static DWORD modReset(WORD wDevID)
1439 {
1440     TRACE(midi, "(%04X);\n", wDevID);
1441     /* FIXME: this function should :
1442      *  turn off every note, remove sustain on all channels
1443      *  remove any pending buffers
1444      */
1445     return MMSYSERR_NOTENABLED;
1446 }
1447 #endif
1448
1449 /*======================================================================*
1450  *                          MIDI entry points                           *
1451  *======================================================================*/
1452
1453 /**************************************************************************
1454  *                      midMessage                              [sample driver]
1455  */
1456 DWORD WINAPI midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1457                         DWORD dwParam1, DWORD dwParam2)
1458 {
1459     TRACE(midi, "(%04X, %04X, %08lX, %08lX, %08lX);\n",
1460           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1461     switch (wMsg) {
1462 #ifdef SNDCTL_MIDI_INFO
1463     case MIDM_OPEN:
1464         return midOpen(wDevID,(LPMIDIOPENDESC)dwParam1, dwParam2);
1465     case MIDM_CLOSE:
1466         return midClose(wDevID);
1467     case MIDM_ADDBUFFER:
1468         return midAddBuffer(wDevID,(LPMIDIHDR16)dwParam1, dwParam2);
1469     case MIDM_PREPARE:
1470         return midPrepare(wDevID,(LPMIDIHDR16)dwParam1, dwParam2);
1471     case MIDM_UNPREPARE:
1472         return midUnprepare(wDevID,(LPMIDIHDR16)dwParam1, dwParam2);
1473     case MIDM_GETDEVCAPS:
1474         return midGetDevCaps(wDevID,(LPMIDIINCAPS16)dwParam1,dwParam2);
1475     case MIDM_GETNUMDEVS:
1476         return MIDM_NUMDEVS;
1477     case MIDM_RESET:
1478         return midReset(wDevID);
1479     case MIDM_START:
1480         return midStart(wDevID);
1481     case MIDM_STOP:
1482         return midStop(wDevID);
1483 #endif
1484     default:
1485         TRACE(midi, "Unsupported message\n");
1486     }
1487     return MMSYSERR_NOTSUPPORTED;
1488 }
1489
1490 /**************************************************************************
1491  *                              modMessage              [sample driver]
1492  */
1493 DWORD WINAPI modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1494                         DWORD dwParam1, DWORD dwParam2)
1495 {
1496     TRACE(midi, "(%04X, %04X, %08lX, %08lX, %08lX);\n",
1497           wDevID, wMsg, dwUser, dwParam1, dwParam2);
1498
1499     switch (wMsg) {
1500 #ifdef SNDCTL_MIDI_INFO
1501     case MODM_OPEN:
1502         return modOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
1503     case MODM_CLOSE:
1504         return modClose(wDevID);
1505     case MODM_DATA:
1506         return modData(wDevID, dwParam1);
1507     case MODM_LONGDATA:
1508         return modLongData(wDevID, (LPMIDIHDR16)dwParam1, dwParam2);
1509     case MODM_PREPARE:
1510         return modPrepare(wDevID, (LPMIDIHDR16)dwParam1, dwParam2);
1511     case MODM_UNPREPARE:
1512         return modUnprepare(wDevID, (LPMIDIHDR16)dwParam1, dwParam2);
1513     case MODM_GETDEVCAPS:
1514         return modGetDevCaps(wDevID,(LPMIDIOUTCAPS16)dwParam1,dwParam2);
1515     case MODM_GETNUMDEVS:
1516         return MODM_NUMDEVS;
1517     case MODM_GETVOLUME:
1518         return 0;
1519     case MODM_SETVOLUME:
1520         return 0;
1521     case MODM_RESET:
1522         return modReset(wDevID);
1523 #endif
1524     default:
1525         TRACE(midi, "Unsupported message\n");
1526     }
1527     return MMSYSERR_NOTSUPPORTED;
1528 }
1529
1530 /**************************************************************************
1531  *                              MIDI_DriverProc32       [sample driver]
1532  */
1533 LONG MIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
1534                        DWORD dwParam1, DWORD dwParam2)
1535 {
1536     switch (wMsg) {
1537     case DRV_LOAD:              return 1;
1538     case DRV_FREE:              return 1;
1539     case DRV_OPEN:              return 1;
1540     case DRV_CLOSE:             return 1;
1541     case DRV_ENABLE:            return 1;
1542     case DRV_DISABLE:           return 1;
1543     case DRV_QUERYCONFIGURE:    return 1;
1544     case DRV_CONFIGURE:         MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK); return 1;
1545     case DRV_INSTALL:           return DRVCNF_RESTART;
1546     case DRV_REMOVE:            return DRVCNF_RESTART;
1547     default:
1548         TRACE(midi, "Sending msg=%lu to default driver proc\n", wMsg);
1549         return DefDriverProc16(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1550     }
1551 }
1552
1553 /**************************************************************************
1554  *                              MIDI_DriverProc16       [sample driver]
1555  */
1556 LONG MIDI_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
1557                        DWORD dwParam1, DWORD dwParam2)
1558 {
1559     switch (wMsg) {
1560     case DRV_LOAD:              return 1;
1561     case DRV_FREE:              return 1;
1562     case DRV_OPEN:              return 1;
1563     case DRV_CLOSE:             return 1;
1564     case DRV_ENABLE:            return 1;
1565     case DRV_DISABLE:           return 1;
1566     case DRV_QUERYCONFIGURE:    return 1;
1567     case DRV_CONFIGURE:         MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK); return 1;
1568     case DRV_INSTALL:           return DRVCNF_RESTART;
1569     case DRV_REMOVE:            return DRVCNF_RESTART;
1570     default:
1571         TRACE(midi, "Sending msg=%u to default driver proc\n", wMsg);
1572         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1573     }
1574 }
1575
1576 /*-----------------------------------------------------------------------*/