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