1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
4 * Sample MIDI Wine Driver for Open Sound System (basically Linux)
6 * Copyright 1994 Martin Ayotte
7 * Copyright 1998 Luiz Otavio L. Zorzella (init procedures)
8 * Copyright 1998/1999 Eric POUECH :
9 * 98/7 changes for making this MIDI driver work on OSS
10 * current support is limited to MIDI ports of OSS systems
11 * 98/9 rewriting MCI code for MIDI
12 * 98/11 splitted in midi.c and mcimidi.c
18 #include <sys/ioctl.h>
23 #include "debugtools.h"
27 DEFAULT_DEBUG_CHANNEL(midi
)
31 #define MIDI_SEQ "/dev/sequencer"
36 LPMIDIOPENDESC midiDesc
;
38 LPMIDIHDR16 lpQueueHdr
;
40 unsigned char incoming
[3];
41 unsigned char incPrev
;
49 LPMIDIOPENDESC midiDesc
;
51 LPMIDIHDR16 lpQueueHdr
;
53 void* lpExtra
; /* according to port type (MIDI, FM...), extra data when needed */
56 static WINE_MIDIIN MidiInDev
[MAX_MIDIINDRV
];
57 static WINE_MIDIOUT MidiOutDev
[MAX_MIDIOUTDRV
];
59 /* this is the total number of MIDI out devices found */
60 static int MODM_NUMDEVS
= 0;
61 /* this is the number of FM synthetizers (index from 0 to
62 NUMFMSYNTHDEVS - 1) */
63 static int MODM_NUMFMSYNTHDEVS
= 0;
64 /* this is the number of Midi ports (index from NUMFMSYNTHDEVS to
65 NUMFMSYNTHDEVS + NUMMIDIDEVS - 1) */
66 static int MODM_NUMMIDIDEVS
= 0;
68 /* this is the total number of MIDI out devices found */
69 static int MIDM_NUMDEVS
= 0;
71 static int midiSeqFD
= -1;
72 static int numOpenMidiSeq
= 0;
73 static UINT midiInTimerID
= 0;
74 static int numStartedMidiIn
= 0;
76 /* this structure holds pointers with information for each MIDI
79 static LPMIDIOUTCAPS16 midiOutDevices
[MAX_MIDIOUTDRV
];
81 /* this structure holds pointers with information for each MIDI
84 static LPMIDIINCAPS16 midiInDevices
[MAX_MIDIINDRV
];
88 * FIXME : all tests on device ID for midXXX and modYYY are made against
89 * MAX_MIDIxxDRV (when they are made) but should be done against the actual
90 * number of midi devices found...
93 /*======================================================================*
94 * Low level MIDI implementation *
95 *======================================================================*/
99 static int midiOpenSeq(void);
100 static int midiCloseSeq(void);
102 /**************************************************************************
103 * unixToWindowsDeviceType [internal]
105 * return the Windows equivalent to a Unix Device Type
108 static int MIDI_UnixToWindowsDeviceType(int type
)
110 /* MOD_MIDIPORT output port
111 * MOD_SYNTH generic internal synth
112 * MOD_SQSYNTH square wave internal synth
113 * MOD_FMSYNTH FM internal synth
114 * MOD_MAPPER MIDI mapper
117 /* FIXME Is this really the correct equivalence from UNIX to
118 Windows Sound type */
121 case SYNTH_TYPE_FM
: return MOD_FMSYNTH
;
122 case SYNTH_TYPE_SAMPLE
: return MOD_SYNTH
;
123 case SYNTH_TYPE_MIDI
: return MOD_MIDIPORT
;
125 ERR("Cannot determine the type of this midi device. "
126 "Assuming FM Synth\n");
133 /**************************************************************************
134 * OSS_MidiInit [internal]
136 * Initializes the MIDI devices information variables
139 /* FIXME: this function shall be moved to the OSS drivers DLL entry point */
140 BOOL
OSS_MidiInit(void)
143 int i
, status
, numsynthdevs
= 255, nummididevs
= 255;
144 struct synth_info sinfo
;
145 struct midi_info minfo
;
147 TRACE("Initializing the MIDI variables.\n");
149 /* try to open device */
150 if (midiOpenSeq() == -1) {
154 /* find how many Synth devices are there in the system */
155 status
= ioctl(midiSeqFD
, SNDCTL_SEQ_NRSYNTHS
, &numsynthdevs
);
158 ERR("ioctl for nr synth failed.\n");
163 if (numsynthdevs
> MAX_MIDIOUTDRV
) {
164 ERR("MAX_MIDIOUTDRV (%d) was enough for the number of devices (%d). "
165 "Some FM devices will not be available.\n",MAX_MIDIOUTDRV
,numsynthdevs
);
166 numsynthdevs
= MAX_MIDIOUTDRV
;
169 for (i
= 0; i
< numsynthdevs
; i
++) {
170 LPMIDIOUTCAPS16 tmplpCaps
;
173 status
= ioctl(midiSeqFD
, SNDCTL_SYNTH_INFO
, &sinfo
);
175 ERR("ioctl for synth info failed.\n");
180 tmplpCaps
= HeapAlloc(SystemHeap
, 0, sizeof(MIDIOUTCAPS16
));
183 /* We also have the information sinfo.synth_subtype, not used here
186 /* Manufac ID. We do not have access to this with soundcard.h
187 * Does not seem to be a problem, because in mmsystem.h only
188 * Microsoft's ID is listed.
190 tmplpCaps
->wMid
= 0x00FF;
191 tmplpCaps
->wPid
= 0x0001; /* FIXME Product ID */
192 /* Product Version. We simply say "1" */
193 tmplpCaps
->vDriverVersion
= 0x001;
194 strcpy(tmplpCaps
->szPname
, sinfo
.name
);
196 tmplpCaps
->wTechnology
= MIDI_UnixToWindowsDeviceType(sinfo
.synth_type
);
197 tmplpCaps
->wVoices
= sinfo
.nr_voices
;
199 /* FIXME Is it possible to know the maximum
200 * number of simultaneous notes of a soundcard ?
201 * I believe we don't have this information, but
202 * it's probably equal or more than wVoices
204 tmplpCaps
->wNotes
= sinfo
.nr_voices
;
206 /* FIXME Do we have this information?
207 * Assuming the soundcards can handle
208 * MIDICAPS_VOLUME and MIDICAPS_LRVOLUME but
209 * not MIDICAPS_CACHE.
211 tmplpCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
213 midiOutDevices
[i
] = tmplpCaps
;
215 if (sinfo
.capabilities
& SYNTH_CAP_INPUT
) {
216 FIXME("Synthetizer support MIDI in. Not supported yet (please report)\n");
219 TRACE("name='%s', techn=%d voices=%d notes=%d support=%ld\n",
220 tmplpCaps
->szPname
, tmplpCaps
->wTechnology
,
221 tmplpCaps
->wVoices
, tmplpCaps
->wNotes
, tmplpCaps
->dwSupport
);
222 TRACE("OSS info: synth subtype=%d capa=%Xh\n",
223 sinfo
.synth_subtype
, sinfo
.capabilities
);
226 /* find how many MIDI devices are there in the system */
227 status
= ioctl(midiSeqFD
, SNDCTL_SEQ_NRMIDIS
, &nummididevs
);
229 ERR("ioctl on nr midi failed.\n");
234 /* FIXME: the two restrictions below could be loosen in some cases */
235 if (numsynthdevs
+ nummididevs
> MAX_MIDIOUTDRV
) {
236 ERR("MAX_MIDIOUTDRV was not enough for the number of devices. "
237 "Some MIDI devices will not be available.\n");
238 nummididevs
= MAX_MIDIOUTDRV
- numsynthdevs
;
241 if (nummididevs
> MAX_MIDIINDRV
) {
242 ERR("MAX_MIDIINDRV (%d) was not enough for the number of devices (%d). "
243 "Some MIDI devices will not be available.\n",MAX_MIDIINDRV
,nummididevs
);
244 nummididevs
= MAX_MIDIINDRV
;
247 for (i
= 0; i
< nummididevs
; i
++) {
248 LPMIDIOUTCAPS16 tmplpOutCaps
;
249 LPMIDIINCAPS16 tmplpInCaps
;
252 status
= ioctl(midiSeqFD
, SNDCTL_MIDI_INFO
, &minfo
);
254 ERR("ioctl on midi info failed.\n");
259 tmplpOutCaps
= HeapAlloc(SystemHeap
, 0, sizeof(MIDIOUTCAPS16
));
262 /* This whole part is somewhat obscure to me. I'll keep trying to dig
263 info about it. If you happen to know, please tell us. The very
264 descritive minfo.dev_type was not used here.
266 /* Manufac ID. We do not have access to this with soundcard.h
267 Does not seem to be a problem, because in mmsystem.h only
268 Microsoft's ID is listed */
269 tmplpOutCaps
->wMid
= 0x00FF;
270 tmplpOutCaps
->wPid
= 0x0001; /* FIXME Product ID */
271 /* Product Version. We simply say "1" */
272 tmplpOutCaps
->vDriverVersion
= 0x001;
273 strcpy(tmplpOutCaps
->szPname
, minfo
.name
);
275 tmplpOutCaps
->wTechnology
= MOD_MIDIPORT
; /* FIXME Is this right? */
276 /* Does it make any difference? */
277 tmplpOutCaps
->wVoices
= 16;
278 /* Does it make any difference? */
279 tmplpOutCaps
->wNotes
= 16;
280 /* FIXME Does it make any difference? */
281 tmplpOutCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
283 midiOutDevices
[numsynthdevs
+ i
] = tmplpOutCaps
;
285 tmplpInCaps
= HeapAlloc(SystemHeap
, 0, sizeof(MIDIOUTCAPS16
));
288 /* This whole part is somewhat obscure to me. I'll keep trying to dig
289 info about it. If you happen to know, please tell us. The very
290 descritive minfo.dev_type was not used here.
292 /* Manufac ID. We do not have access to this with soundcard.h
293 Does not seem to be a problem, because in mmsystem.h only
294 Microsoft's ID is listed */
295 tmplpInCaps
->wMid
= 0x00FF;
296 tmplpInCaps
->wPid
= 0x0001; /* FIXME Product ID */
297 /* Product Version. We simply say "1" */
298 tmplpInCaps
->vDriverVersion
= 0x001;
299 strcpy(tmplpInCaps
->szPname
, minfo
.name
);
301 /* FIXME : could we get better information than that ? */
302 tmplpInCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
304 midiInDevices
[i
] = tmplpInCaps
;
306 TRACE("name='%s' techn=%d voices=%d notes=%d support=%ld\n",
307 tmplpOutCaps
->szPname
, tmplpOutCaps
->wTechnology
, tmplpOutCaps
->wVoices
,
308 tmplpOutCaps
->wNotes
, tmplpOutCaps
->dwSupport
);
309 TRACE("OSS info: midi dev-type=%d, capa=%d\n",
310 minfo
.dev_type
, minfo
.capabilities
);
313 /* windows does not seem to differentiate Synth from MIDI devices */
314 MODM_NUMFMSYNTHDEVS
= numsynthdevs
;
315 MODM_NUMMIDIDEVS
= nummididevs
;
316 MODM_NUMDEVS
= numsynthdevs
+ nummididevs
;
318 MIDM_NUMDEVS
= nummididevs
;
320 /* close file and exit */
322 #endif /* HAVE_OSS_MIDI */
329 /**************************************************************************
330 * MIDI_NotifyClient [internal]
332 static DWORD
MIDI_NotifyClient(UINT16 wDevID
, WORD wMsg
,
333 DWORD dwParam1
, DWORD dwParam2
)
340 TRACE("wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
341 wDevID
, wMsg
, dwParam1
, dwParam2
);
347 if (wDevID
> MAX_MIDIOUTDRV
)
348 return MCIERR_INTERNAL
;
350 dwCallBack
= MidiOutDev
[wDevID
].midiDesc
->dwCallback
;
351 uFlags
= MidiOutDev
[wDevID
].wFlags
;
352 hDev
= MidiOutDev
[wDevID
].midiDesc
->hMidi
;
353 dwInstance
= MidiOutDev
[wDevID
].midiDesc
->dwInstance
;
360 if (wDevID
> MAX_MIDIINDRV
)
361 return MCIERR_INTERNAL
;
363 dwCallBack
= MidiInDev
[wDevID
].midiDesc
->dwCallback
;
364 uFlags
= MidiInDev
[wDevID
].wFlags
;
365 hDev
= MidiInDev
[wDevID
].midiDesc
->hMidi
;
366 dwInstance
= MidiInDev
[wDevID
].midiDesc
->dwInstance
;
369 WARN("Unsupported MSW-MIDI message %u\n", wMsg
);
370 return MCIERR_INTERNAL
;
373 return DriverCallback16(dwCallBack
, uFlags
, hDev
, wMsg
, dwInstance
, dwParam1
, dwParam2
) ?
377 /**************************************************************************
378 * midiOpenSeq [internal]
380 static int midiOpenSeq(void)
382 if (numOpenMidiSeq
== 0) {
383 midiSeqFD
= open(MIDI_SEQ
, O_RDWR
, 0);
384 if (midiSeqFD
== -1) {
385 ERR("can't open '%s' ! (%d)\n", MIDI_SEQ
, errno
);
388 if (fcntl(midiSeqFD
, F_SETFL
, O_NONBLOCK
) < 0) {
389 WARN("can't set sequencer fd to non blocking (%d)\n", errno
);
394 ioctl(midiSeqFD
, SNDCTL_SEQ_RESET
);
400 /**************************************************************************
401 * midiCloseSeq [internal]
403 static int midiCloseSeq(void)
405 if (--numOpenMidiSeq
== 0) {
412 /* FIXME: this is a bad idea, it's even not static... */
415 /* FIXME: this is not reentrant, not static - because of global variable
418 /**************************************************************************
419 * seqbuf_dump [internal]
421 void seqbuf_dump(void)
424 if (write(midiSeqFD
, _seqbuf
, _seqbufptr
) == -1) {
425 WARN("Can't write data to sequencer (%d/%d)!\n",
429 * in any case buffer is lost so that if many errors occur the buffer
436 static void midReceiveChar(WORD wDevID
, unsigned char value
, DWORD dwTime
)
440 TRACE("Adding %02xh to %d[%d]\n", value
, wDevID
, MidiInDev
[wDevID
].incLen
);
442 if (wDevID
>= MAX_MIDIINDRV
) {
446 if (MidiInDev
[wDevID
].state
== 0) {
447 TRACE("input not started, thrown away\n");
451 if (MidiInDev
[wDevID
].state
& 2) { /* system exclusive */
452 LPMIDIHDR16 lpMidiHdr
= MidiInDev
[wDevID
].lpQueueHdr
;
456 LPBYTE lpData
= ((DWORD
)lpMidiHdr
== lpMidiHdr
->reserved
) ?
457 (LPBYTE
)lpMidiHdr
->lpData
: (LPBYTE
)PTR_SEG_TO_LIN(lpMidiHdr
->lpData
);
459 lpData
[lpMidiHdr
->dwBytesRecorded
++] = value
;
460 if (lpMidiHdr
->dwBytesRecorded
== lpMidiHdr
->dwBufferLength
) {
464 if (value
== 0xF7) { /* then end */
465 MidiInDev
[wDevID
].state
&= ~2;
468 if (sbfb
&& lpMidiHdr
!= NULL
) {
469 lpMidiHdr
= MidiInDev
[wDevID
].lpQueueHdr
;
470 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
471 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
472 MidiInDev
[wDevID
].lpQueueHdr
= (LPMIDIHDR16
)lpMidiHdr
->lpNext
;
473 if (MIDI_NotifyClient(wDevID
, MIM_LONGDATA
, (DWORD
)lpMidiHdr
->reserved
, dwTime
) != MMSYSERR_NOERROR
) {
474 WARN("Couldn't notify client\n");
480 #define IS_CMD(_x) (((_x) & 0x80) == 0x80)
481 #define IS_SYS_CMD(_x) (((_x) & 0xF0) == 0xF0)
483 if (!IS_CMD(value
) && MidiInDev
[wDevID
].incLen
== 0) { /* try to reuse old cmd */
484 if (IS_CMD(MidiInDev
[wDevID
].incPrev
) && !IS_SYS_CMD(MidiInDev
[wDevID
].incPrev
)) {
485 MidiInDev
[wDevID
].incoming
[0] = MidiInDev
[wDevID
].incPrev
;
486 MidiInDev
[wDevID
].incLen
= 1;
487 TRACE("Reusing old command %02xh\n", MidiInDev
[wDevID
].incPrev
);
489 FIXME("error for midi-in, should generate MIM_ERROR notification:"
490 " prev=%02Xh, incLen=%02Xh\n",
491 MidiInDev
[wDevID
].incPrev
, MidiInDev
[wDevID
].incLen
);
495 MidiInDev
[wDevID
].incoming
[(int)(MidiInDev
[wDevID
].incLen
++)] = value
;
496 if (MidiInDev
[wDevID
].incLen
== 1 && !IS_SYS_CMD(MidiInDev
[wDevID
].incoming
[0])) {
497 /* store new cmd, just in case */
498 MidiInDev
[wDevID
].incPrev
= MidiInDev
[wDevID
].incoming
[0];
502 #undef IS_SYS_CMD(_x)
504 switch (MidiInDev
[wDevID
].incoming
[0] & 0xF0) {
507 case MIDI_KEY_PRESSURE
:
508 case MIDI_CTL_CHANGE
:
509 case MIDI_PITCH_BEND
:
510 if (MidiInDev
[wDevID
].incLen
== 3) {
511 toSend
= (MidiInDev
[wDevID
].incoming
[2] << 16) |
512 (MidiInDev
[wDevID
].incoming
[1] << 8) |
513 (MidiInDev
[wDevID
].incoming
[0] << 0);
516 case MIDI_PGM_CHANGE
:
517 case MIDI_CHN_PRESSURE
:
518 if (MidiInDev
[wDevID
].incLen
== 2) {
519 toSend
= (MidiInDev
[wDevID
].incoming
[1] << 8) |
520 (MidiInDev
[wDevID
].incoming
[0] << 0);
523 case MIDI_SYSTEM_PREFIX
:
524 if (MidiInDev
[wDevID
].incoming
[0] == 0xF0) {
525 MidiInDev
[wDevID
].state
|= 2;
526 MidiInDev
[wDevID
].incLen
= 0;
528 if (MidiInDev
[wDevID
].incLen
== 1) {
529 toSend
= (MidiInDev
[wDevID
].incoming
[0] << 0);
534 WARN("This shouldn't happen (%02X)\n", MidiInDev
[wDevID
].incoming
[0]);
537 TRACE("Sending event %08lx\n", toSend
);
538 MidiInDev
[wDevID
].incLen
= 0;
539 dwTime
-= MidiInDev
[wDevID
].startTime
;
540 if (MIDI_NotifyClient(wDevID
, MIM_DATA
, toSend
, dwTime
) != MMSYSERR_NOERROR
) {
541 WARN("Couldn't notify client\n");
546 static VOID WINAPI
midTimeCallback(HWND hwnd
, UINT msg
, UINT id
, DWORD dwTime
)
548 unsigned char buffer
[256];
551 TRACE("(%04X, %d, %d, %lu)\n", hwnd
, msg
, id
, dwTime
);
553 len
= read(midiSeqFD
, buffer
, sizeof(buffer
));
555 if ((len
% 4) != 0) {
556 WARN("bad length %d (%d)\n", len
, errno
);
560 for (idx
= 0; idx
< len
; ) {
561 if (buffer
[idx
] & 0x80) {
563 "reading<8> %02x %02x %02x %02x %02x %02x %02x %02x\n",
564 buffer
[idx
+ 0], buffer
[idx
+ 1],
565 buffer
[idx
+ 2], buffer
[idx
+ 3],
566 buffer
[idx
+ 4], buffer
[idx
+ 5],
567 buffer
[idx
+ 6], buffer
[idx
+ 7]);
570 switch (buffer
[idx
+ 0]) {
575 midReceiveChar(buffer
[idx
+ 2], buffer
[idx
+ 1], dwTime
);
578 TRACE("Unsupported event %d\n", buffer
[idx
+ 0]);
586 /**************************************************************************
587 * midGetDevCaps [internal]
589 static DWORD
midGetDevCaps(WORD wDevID
, LPMIDIINCAPS16 lpCaps
, DWORD dwSize
)
591 LPMIDIINCAPS16 tmplpCaps
;
593 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
595 if (wDevID
>= MIDM_NUMDEVS
) {
596 return MMSYSERR_BADDEVICEID
;
598 if (lpCaps
== NULL
) {
599 return MMSYSERR_INVALPARAM
;
602 tmplpCaps
= midiInDevices
[wDevID
];
603 lpCaps
->wMid
= tmplpCaps
->wMid
;
604 lpCaps
->wPid
= tmplpCaps
->wPid
;
605 lpCaps
->vDriverVersion
= tmplpCaps
->vDriverVersion
;
606 strcpy(lpCaps
->szPname
, tmplpCaps
->szPname
);
607 if (dwSize
== sizeof(MIDIINCAPS16
)) {
608 /* we should run win 95, so make use of dwSupport */
609 lpCaps
->dwSupport
= tmplpCaps
->dwSupport
;
610 } else if (dwSize
!= sizeof(MIDIINCAPS16
) - sizeof(DWORD
)) {
611 TRACE("bad size for lpCaps\n");
612 return MMSYSERR_INVALPARAM
;
615 return MMSYSERR_NOERROR
;
618 /**************************************************************************
621 static DWORD
midOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
623 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
625 if (lpDesc
== NULL
) {
626 WARN("Invalid Parameter !\n");
627 return MMSYSERR_INVALPARAM
;
630 * how to check that content of lpDesc is correct ?
632 if (wDevID
>= MAX_MIDIINDRV
) {
633 WARN("wDevID too large (%u) !\n", wDevID
);
634 return MMSYSERR_BADDEVICEID
;
636 if (MidiInDev
[wDevID
].midiDesc
!= 0) {
637 WARN("device already open !\n");
638 return MMSYSERR_ALLOCATED
;
640 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
641 FIXME("No support for MIDI_IO_STATUS in dwFlags\n");
642 return MMSYSERR_INVALFLAG
;
645 if (midiOpenSeq() < 0) {
646 return MMSYSERR_ERROR
;
649 if (numStartedMidiIn
++ == 0) {
650 midiInTimerID
= SetTimer(0, 0, 250, midTimeCallback
);
651 if (!midiInTimerID
) {
652 numStartedMidiIn
= 0;
653 WARN("Couldn't start timer for midi-in\n");
655 return MMSYSERR_ERROR
;
657 TRACE("Starting timer (%u) for midi-in\n", midiInTimerID
);
660 MidiInDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
662 MidiInDev
[wDevID
].lpQueueHdr
= NULL
;
663 MidiInDev
[wDevID
].dwTotalPlayed
= 0;
664 MidiInDev
[wDevID
].bufsize
= 0x3FFF;
665 MidiInDev
[wDevID
].midiDesc
= lpDesc
;
666 MidiInDev
[wDevID
].state
= 0;
667 MidiInDev
[wDevID
].incLen
= 0;
668 MidiInDev
[wDevID
].startTime
= 0;
670 if (MIDI_NotifyClient(wDevID
, MIM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
671 WARN("can't notify client !\n");
672 return MMSYSERR_INVALPARAM
;
674 return MMSYSERR_NOERROR
;
677 /**************************************************************************
678 * midClose [internal]
680 static DWORD
midClose(WORD wDevID
)
682 int ret
= MMSYSERR_NOERROR
;
684 TRACE("(%04X);\n", wDevID
);
686 if (wDevID
>= MAX_MIDIINDRV
) {
687 WARN("wDevID too bif (%u) !\n", wDevID
);
688 return MMSYSERR_BADDEVICEID
;
690 if (MidiInDev
[wDevID
].midiDesc
== 0) {
691 WARN("device not opened !\n");
692 return MMSYSERR_ERROR
;
694 if (MidiInDev
[wDevID
].lpQueueHdr
!= 0) {
695 return MIDIERR_STILLPLAYING
;
698 if (midiSeqFD
== -1) {
700 return MMSYSERR_ERROR
;
702 if (--numStartedMidiIn
== 0) {
703 TRACE("Stopping timer for midi-in\n");
704 if (!KillTimer(0, midiInTimerID
)) {
705 WARN("Couldn't stop timer for midi-in\n");
711 MidiInDev
[wDevID
].bufsize
= 0;
712 if (MIDI_NotifyClient(wDevID
, MIM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
713 WARN("can't notify client !\n");
714 ret
= MMSYSERR_INVALPARAM
;
716 MidiInDev
[wDevID
].midiDesc
= 0;
720 /**************************************************************************
721 * midAddBuffer [internal]
723 static DWORD
midAddBuffer(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
725 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
727 if (lpMidiHdr
== NULL
) return MMSYSERR_INVALPARAM
;
728 if (sizeof(MIDIHDR16
) > dwSize
) return MMSYSERR_INVALPARAM
;
729 if (lpMidiHdr
->dwBufferLength
== 0) return MMSYSERR_INVALPARAM
;
730 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
731 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
733 if (MidiInDev
[wDevID
].lpQueueHdr
== 0) {
734 MidiInDev
[wDevID
].lpQueueHdr
= lpMidiHdr
;
738 for (ptr
= MidiInDev
[wDevID
].lpQueueHdr
;
740 ptr
= (LPMIDIHDR16
)ptr
->lpNext
);
741 ptr
->lpNext
= (struct midihdr_tag
*)lpMidiHdr
;
743 return MMSYSERR_NOERROR
;
746 /**************************************************************************
747 * midPrepare [internal]
749 static DWORD
midPrepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
751 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
753 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
754 lpMidiHdr
->lpData
== 0 || lpMidiHdr
->dwFlags
!= 0 ||
755 lpMidiHdr
->dwBufferLength
>= 0x10000ul
)
756 return MMSYSERR_INVALPARAM
;
758 lpMidiHdr
->lpNext
= 0;
759 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
760 lpMidiHdr
->dwBytesRecorded
= 0;
762 return MMSYSERR_NOERROR
;
765 /**************************************************************************
766 * midUnprepare [internal]
768 static DWORD
midUnprepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
770 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
772 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
773 lpMidiHdr
->lpData
== 0 || lpMidiHdr
->dwBufferLength
>= 0x10000ul
)
774 return MMSYSERR_INVALPARAM
;
776 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
777 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
779 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
781 return MMSYSERR_NOERROR
;
784 /**************************************************************************
785 * midReset [internal]
787 static DWORD
midReset(WORD wDevID
)
789 DWORD dwTime
= GetTickCount();
791 TRACE("(%04X);\n", wDevID
);
793 while (MidiInDev
[wDevID
].lpQueueHdr
) {
794 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
&= ~MHDR_INQUEUE
;
795 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
|= MHDR_DONE
;
796 /* FIXME: when called from 16 bit, lpQueueHdr needs to be a segmented ptr */
797 if (MIDI_NotifyClient(wDevID
, MIM_LONGDATA
,
798 (DWORD
)MidiInDev
[wDevID
].lpQueueHdr
, dwTime
) != MMSYSERR_NOERROR
) {
799 WARN("Couldn't notify client\n");
801 MidiInDev
[wDevID
].lpQueueHdr
= (LPMIDIHDR16
)MidiInDev
[wDevID
].lpQueueHdr
->lpNext
;
804 return MMSYSERR_NOERROR
;
808 /**************************************************************************
809 * midStart [internal]
811 static DWORD
midStart(WORD wDevID
)
813 TRACE("(%04X);\n", wDevID
);
815 /* FIXME : should test value of wDevID */
817 MidiInDev
[wDevID
].state
= 1;
818 MidiInDev
[wDevID
].startTime
= GetTickCount();
819 return MMSYSERR_NOERROR
;
822 /**************************************************************************
825 static DWORD
midStop(WORD wDevID
)
827 TRACE("(%04X);\n", wDevID
);
829 /* FIXME : should test value of wDevID */
830 MidiInDev
[wDevID
].state
= 0;
831 return MMSYSERR_NOERROR
;
834 /*-----------------------------------------------------------------------*/
836 typedef struct sVoice
{
837 int note
; /* 0 means not used */
839 unsigned cntMark
: 30,
842 #define sVS_PLAYING 1
843 #define sVS_SUSTAINED 2
846 typedef struct sChannel
{
852 int bank
; /* CTL_BANK_SELECT */
853 int volume
; /* CTL_MAIN_VOLUME */
854 int balance
; /* CTL_BALANCE */
855 int expression
; /* CTL_EXPRESSION */
856 int sustain
; /* CTL_SUSTAIN */
858 unsigned char nrgPmtMSB
; /* Non register Parameters */
859 unsigned char nrgPmtLSB
;
860 unsigned char regPmtMSB
; /* Non register Parameters */
861 unsigned char regPmtLSB
;
864 typedef struct sFMextra
{
867 sChannel channel
[16]; /* MIDI has only 16 channels */
868 sVoice voice
[1]; /* dyn allocated according to sound card */
869 /* do not append fields below voice[1] since the size of this structure
870 * depends on the number of available voices on the FM synth...
874 extern unsigned char midiFMInstrumentPatches
[16 * 128];
875 extern unsigned char midiFMDrumsPatches
[16 * 128];
877 /**************************************************************************
878 * modFMLoad [internal]
880 static int modFMLoad(int dev
)
883 struct sbi_instrument sbi
;
888 memset(sbi
.operators
+ 16, 0, 16);
889 for (i
= 0; i
< 128; i
++) {
891 memcpy(sbi
.operators
, midiFMInstrumentPatches
+ i
* 16, 16);
893 if (write(midiSeqFD
, (char*)&sbi
, sizeof(sbi
)) == -1) {
894 WARN("Couldn't write patch for instrument %d (%d)!\n", sbi
.channel
, errno
);
898 for (i
= 0; i
< 128; i
++) {
899 sbi
.channel
= 128 + i
;
900 memcpy(sbi
.operators
, midiFMDrumsPatches
+ i
* 16, 16);
902 if (write(midiSeqFD
, (char*)&sbi
, sizeof(sbi
)) == -1) {
903 WARN("Couldn't write patch for drum %d (%d)!\n", sbi
.channel
, errno
);
910 /**************************************************************************
911 * modFMReset [internal]
913 static void modFMReset(WORD wDevID
)
915 sFMextra
* extra
= (sFMextra
*)MidiOutDev
[wDevID
].lpExtra
;
916 sVoice
* voice
= extra
->voice
;
917 sChannel
* channel
= extra
->channel
;
920 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
921 if (voice
[i
].status
!= sVS_UNUSED
) {
922 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
924 SEQ_KEY_PRESSURE(wDevID
, i
, 127, 0);
925 SEQ_CONTROL(wDevID
, i
, SEQ_VOLMODE
, VOL_METHOD_LINEAR
);
927 voice
[i
].channel
= -1;
928 voice
[i
].cntMark
= 0;
929 voice
[i
].status
= sVS_UNUSED
;
931 for (i
= 0; i
< 16; i
++) {
932 channel
[i
].program
= 0;
933 channel
[i
].bender
= 8192;
934 channel
[i
].benderRange
= 2;
936 channel
[i
].volume
= 127;
937 channel
[i
].balance
= 64;
938 channel
[i
].expression
= 0;
939 channel
[i
].sustain
= 0;
942 extra
->drumSetMask
= 1 << 9; /* channel 10 is normally drums, sometimes 16 also */
946 #define IS_DRUM_CHANNEL(_xtra, _chn) ((_xtra)->drumSetMask & (1 << (_chn)))
948 /**************************************************************************
949 * modGetDevCaps [internal]
951 static DWORD
modGetDevCaps(WORD wDevID
, LPMIDIOUTCAPS16 lpCaps
,
954 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
955 if (wDevID
== (WORD
) MIDI_MAPPER
) {
956 lpCaps
->wMid
= 0x00FF; /* Manufac ID */
957 lpCaps
->wPid
= 0x0001; /* Product ID */
958 lpCaps
->vDriverVersion
= 0x001; /* Product Version */
959 strcpy(lpCaps
->szPname
, "MIDI Mapper (not functional yet)");
960 /* FIXME Does it make any difference ? */
961 lpCaps
->wTechnology
= MOD_FMSYNTH
;
962 lpCaps
->wVoices
= 14; /* FIXME */
963 lpCaps
->wNotes
= 14; /* FIXME */
964 /* FIXME Does it make any difference ? */
965 lpCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
967 LPMIDIOUTCAPS16 tmplpCaps
;
969 if (wDevID
>= MODM_NUMDEVS
) {
970 TRACE("MAX_MIDIOUTDRV reached !\n");
971 return MMSYSERR_BADDEVICEID
;
973 /* FIXME There is a way to do it so easily, but I'm too
974 * sleepy to think and I want to test
977 tmplpCaps
= midiOutDevices
[wDevID
];
978 lpCaps
->wMid
= tmplpCaps
->wMid
;
979 lpCaps
->wPid
= tmplpCaps
->wPid
;
980 lpCaps
->vDriverVersion
= tmplpCaps
->vDriverVersion
;
981 strcpy(lpCaps
->szPname
, tmplpCaps
->szPname
);
982 lpCaps
->wTechnology
= tmplpCaps
->wTechnology
;
983 lpCaps
->wVoices
= tmplpCaps
->wVoices
;
984 lpCaps
->wNotes
= tmplpCaps
->wNotes
;
985 lpCaps
->dwSupport
= tmplpCaps
->dwSupport
;
987 return MMSYSERR_NOERROR
;
990 /**************************************************************************
993 static DWORD
modOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
995 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
996 if (lpDesc
== NULL
) {
997 WARN("Invalid Parameter !\n");
998 return MMSYSERR_INVALPARAM
;
1000 if (wDevID
>= MAX_MIDIOUTDRV
) {
1001 TRACE("MAX_MIDIOUTDRV reached !\n");
1002 return MMSYSERR_BADDEVICEID
;
1004 if (MidiOutDev
[wDevID
].midiDesc
!= 0) {
1005 WARN("device already open !\n");
1006 return MMSYSERR_ALLOCATED
;
1008 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
1009 WARN("bad dwFlags\n");
1010 return MMSYSERR_INVALFLAG
;
1012 if (midiOutDevices
[wDevID
] == NULL
) {
1013 TRACE("un-allocated wDevID\n");
1014 return MMSYSERR_BADDEVICEID
;
1017 MidiOutDev
[wDevID
].lpExtra
= 0;
1019 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1022 void* extra
= HeapAlloc(GetProcessHeap(), 0,
1023 sizeof(struct sFMextra
) +
1024 sizeof(struct sVoice
) * (midiOutDevices
[wDevID
]->wVoices
- 1));
1027 WARN("can't alloc extra data !\n");
1028 return MMSYSERR_NOMEM
;
1030 MidiOutDev
[wDevID
].lpExtra
= extra
;
1031 if (midiOpenSeq() < 0) {
1032 MidiOutDev
[wDevID
].lpExtra
= 0;
1033 HeapFree(GetProcessHeap(), 0, extra
);
1034 return MMSYSERR_ERROR
;
1036 if (modFMLoad(wDevID
) < 0) {
1038 MidiOutDev
[wDevID
].lpExtra
= 0;
1039 HeapFree(GetProcessHeap(), 0, extra
);
1040 return MMSYSERR_ERROR
;
1046 if (midiOpenSeq() < 0) {
1047 return MMSYSERR_ALLOCATED
;
1051 WARN("Technology not supported (yet) %d !\n",
1052 midiOutDevices
[wDevID
]->wTechnology
);
1053 return MMSYSERR_NOTENABLED
;
1056 MidiOutDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
1058 MidiOutDev
[wDevID
].lpQueueHdr
= NULL
;
1059 MidiOutDev
[wDevID
].dwTotalPlayed
= 0;
1060 MidiOutDev
[wDevID
].bufsize
= 0x3FFF;
1061 MidiOutDev
[wDevID
].midiDesc
= lpDesc
;
1063 if (MIDI_NotifyClient(wDevID
, MOM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
1064 WARN("can't notify client !\n");
1065 return MMSYSERR_INVALPARAM
;
1067 TRACE("Succesful !\n");
1068 return MMSYSERR_NOERROR
;
1072 /**************************************************************************
1073 * modClose [internal]
1075 static DWORD
modClose(WORD wDevID
)
1077 int ret
= MMSYSERR_NOERROR
;
1079 TRACE("(%04X);\n", wDevID
);
1081 if (MidiOutDev
[wDevID
].midiDesc
== 0) {
1082 WARN("device not opened !\n");
1083 return MMSYSERR_ERROR
;
1085 /* FIXME: should test that no pending buffer is still in the queue for
1088 if (midiSeqFD
== -1) {
1089 WARN("can't close !\n");
1090 return MMSYSERR_ERROR
;
1093 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1099 WARN("Technology not supported (yet) %d !\n",
1100 midiOutDevices
[wDevID
]->wTechnology
);
1101 return MMSYSERR_NOTENABLED
;
1104 if (MidiOutDev
[wDevID
].lpExtra
!= 0) {
1105 HeapFree(GetProcessHeap(), 0, MidiOutDev
[wDevID
].lpExtra
);
1106 MidiOutDev
[wDevID
].lpExtra
= 0;
1109 MidiOutDev
[wDevID
].bufsize
= 0;
1110 if (MIDI_NotifyClient(wDevID
, MOM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
1111 WARN("can't notify client !\n");
1112 ret
= MMSYSERR_INVALPARAM
;
1114 MidiOutDev
[wDevID
].midiDesc
= 0;
1118 /**************************************************************************
1119 * modData [internal]
1121 static DWORD
modData(WORD wDevID
, DWORD dwParam
)
1123 WORD evt
= LOBYTE(LOWORD(dwParam
));
1124 WORD d1
= HIBYTE(LOWORD(dwParam
));
1125 WORD d2
= LOBYTE(HIWORD(dwParam
));
1127 TRACE("(%04X, %08lX);\n", wDevID
, dwParam
);
1129 if (midiSeqFD
== -1) {
1130 WARN("can't play !\n");
1131 return MIDIERR_NODEVICE
;
1133 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1136 * - chorus depth controller is not used
1139 sFMextra
* extra
= (sFMextra
*)MidiOutDev
[wDevID
].lpExtra
;
1140 sVoice
* voice
= extra
->voice
;
1141 sChannel
* channel
= extra
->channel
;
1142 int chn
= (evt
& 0x0F);
1145 switch (evt
& 0xF0) {
1147 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1148 /* don't stop sustained notes */
1149 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1150 voice
[i
].status
= sVS_UNUSED
;
1151 SEQ_STOP_NOTE(wDevID
, i
, d1
, d2
);
1156 if (d2
== 0) { /* note off if velocity == 0 */
1157 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1158 /* don't stop sustained notes */
1159 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1160 voice
[i
].status
= sVS_UNUSED
;
1161 SEQ_STOP_NOTE(wDevID
, i
, d1
, 64);
1166 /* finding out in this order :
1168 * - if replaying the same note on the same channel
1169 * - the older voice (LRU)
1171 for (i
= nv
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1172 if (voice
[i
].status
== sVS_UNUSED
||
1173 (voice
[i
].note
== d1
&& voice
[i
].channel
== chn
)) {
1177 if (voice
[i
].cntMark
< voice
[0].cntMark
) {
1182 "playing on voice=%d, pgm=%d, pan=0x%02X, vol=0x%02X, "
1183 "bender=0x%02X, note=0x%02X, vel=0x%02X\n",
1184 nv
, channel
[chn
].program
,
1185 channel
[chn
].balance
,
1186 channel
[chn
].volume
,
1187 channel
[chn
].bender
, d1
, d2
);
1189 SEQ_SET_PATCH(wDevID
, nv
, IS_DRUM_CHANNEL(extra
, chn
) ?
1190 (128 + d1
) : channel
[chn
].program
);
1191 SEQ_BENDER_RANGE(wDevID
, nv
, channel
[chn
].benderRange
* 100);
1192 SEQ_BENDER(wDevID
, nv
, channel
[chn
].bender
);
1193 SEQ_CONTROL(wDevID
, nv
, CTL_PAN
, channel
[chn
].balance
);
1194 SEQ_CONTROL(wDevID
, nv
, CTL_EXPRESSION
, channel
[chn
].expression
);
1196 /* FIXME: does not really seem to work on my SB card and
1197 * screws everything up... so lay it down
1199 SEQ_CONTROL(wDevID
, nv
, CTL_MAIN_VOLUME
, channel
[chn
].volume
);
1201 SEQ_START_NOTE(wDevID
, nv
, d1
, d2
);
1202 voice
[nv
].status
= channel
[chn
].sustain
? sVS_SUSTAINED
: sVS_PLAYING
;
1203 voice
[nv
].note
= d1
;
1204 voice
[nv
].channel
= chn
;
1205 voice
[nv
].cntMark
= extra
->counter
++;
1207 case MIDI_KEY_PRESSURE
:
1208 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1209 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1210 SEQ_KEY_PRESSURE(wDevID
, i
, d1
, d2
);
1214 case MIDI_CTL_CHANGE
:
1216 case CTL_BANK_SELECT
: channel
[chn
].bank
= d2
; break;
1217 case CTL_MAIN_VOLUME
: channel
[chn
].volume
= d2
; break;
1218 case CTL_PAN
: channel
[chn
].balance
= d2
; break;
1219 case CTL_EXPRESSION
: channel
[chn
].expression
= d2
; break;
1220 case CTL_SUSTAIN
: channel
[chn
].sustain
= d2
;
1222 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1223 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1224 voice
[i
].status
= sVS_SUSTAINED
;
1228 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1229 if (voice
[i
].status
== sVS_SUSTAINED
&& voice
[i
].channel
== chn
) {
1230 voice
[i
].status
= sVS_UNUSED
;
1231 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1236 case CTL_NONREG_PARM_NUM_LSB
: channel
[chn
].nrgPmtLSB
= d2
; break;
1237 case CTL_NONREG_PARM_NUM_MSB
: channel
[chn
].nrgPmtMSB
= d2
; break;
1238 case CTL_REGIST_PARM_NUM_LSB
: channel
[chn
].regPmtLSB
= d2
; break;
1239 case CTL_REGIST_PARM_NUM_MSB
: channel
[chn
].regPmtMSB
= d2
; break;
1240 case CTL_DATA_ENTRY
:
1241 switch ((channel
[chn
].regPmtMSB
<< 8) | channel
[chn
].regPmtLSB
) {
1243 if (channel
[chn
].benderRange
!= d2
) {
1244 channel
[chn
].benderRange
= d2
;
1245 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1246 if (voice
[i
].channel
== chn
) {
1247 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1254 channel
[chn
].benderRange
= 2;
1255 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1256 if (voice
[i
].channel
== chn
) {
1257 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1262 TRACE("Data entry: regPmt=0x%02x%02x, nrgPmt=0x%02x%02x with %x\n",
1263 channel
[chn
].regPmtMSB
, channel
[chn
].regPmtLSB
,
1264 channel
[chn
].nrgPmtMSB
, channel
[chn
].nrgPmtLSB
,
1270 case 0x78: /* all sounds off */
1271 /* FIXME: I don't know if I have to take care of the channel
1272 * for this control ?
1274 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1275 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1276 voice
[i
].status
= sVS_UNUSED
;
1277 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1281 case 0x7B: /* all notes off */
1282 /* FIXME: I don't know if I have to take care of the channel
1283 * for this control ?
1285 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1286 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1287 voice
[i
].status
= sVS_UNUSED
;
1288 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1293 TRACE("Dropping MIDI control event 0x%02x(%02x) on channel %d\n",
1298 case MIDI_PGM_CHANGE
:
1299 channel
[chn
].program
= d1
;
1301 case MIDI_CHN_PRESSURE
:
1302 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1303 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1304 SEQ_KEY_PRESSURE(wDevID
, i
, voice
[i
].note
, d1
);
1308 case MIDI_PITCH_BEND
:
1309 channel
[chn
].bender
= (d2
<< 7) + d1
;
1310 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1311 if (voice
[i
].channel
== chn
) {
1312 SEQ_BENDER(wDevID
, i
, channel
[chn
].bender
);
1316 case MIDI_SYSTEM_PREFIX
:
1317 switch (evt
& 0x0F) {
1318 case 0x0F: /* Reset */
1322 WARN("Unsupported (yet) system event %02x\n", evt
& 0x0F);
1326 WARN("Internal error, shouldn't happen (event=%08x)\n", evt
& 0xF0);
1327 return MMSYSERR_NOTENABLED
;
1333 int dev
= wDevID
- MODM_NUMFMSYNTHDEVS
;
1335 WARN("Internal error on devID (%u) !\n", wDevID
);
1336 return MIDIERR_NODEVICE
;
1339 switch (evt
& 0xF0) {
1342 case MIDI_KEY_PRESSURE
:
1343 case MIDI_CTL_CHANGE
:
1344 case MIDI_PITCH_BEND
:
1345 SEQ_MIDIOUT(dev
, evt
);
1346 SEQ_MIDIOUT(dev
, d1
);
1347 SEQ_MIDIOUT(dev
, d2
);
1349 case MIDI_PGM_CHANGE
:
1350 case MIDI_CHN_PRESSURE
:
1351 SEQ_MIDIOUT(dev
, evt
);
1352 SEQ_MIDIOUT(dev
, d1
);
1354 case MIDI_SYSTEM_PREFIX
:
1355 switch (evt
& 0x0F) {
1356 case 0x00: /* System Exclusive, don't do it on modData,
1357 * should require modLongData*/
1358 case 0x01: /* Undefined */
1359 case 0x04: /* Undefined. */
1360 case 0x05: /* Undefined. */
1361 case 0x07: /* End of Exclusive. */
1362 case 0x09: /* Undefined. */
1363 case 0x0D: /* Undefined. */
1365 case 0x06: /* Tune Request */
1366 case 0x08: /* Timing Clock. */
1367 case 0x0A: /* Start. */
1368 case 0x0B: /* Continue */
1369 case 0x0C: /* Stop */
1370 case 0x0E: /* Active Sensing. */
1371 SEQ_MIDIOUT(dev
, evt
);
1373 case 0x0F: /* Reset */
1374 /* SEQ_MIDIOUT(dev, evt);
1375 this other way may be better */
1376 SEQ_MIDIOUT(dev
, MIDI_SYSTEM_PREFIX
);
1377 SEQ_MIDIOUT(dev
, 0x7e);
1378 SEQ_MIDIOUT(dev
, 0x7f);
1379 SEQ_MIDIOUT(dev
, 0x09);
1380 SEQ_MIDIOUT(dev
, 0x01);
1381 SEQ_MIDIOUT(dev
, 0xf7);
1383 case 0x03: /* Song Select. */
1384 SEQ_MIDIOUT(dev
, evt
);
1385 SEQ_MIDIOUT(dev
, d1
);
1386 case 0x02: /* Song Position Pointer. */
1387 SEQ_MIDIOUT(dev
, evt
);
1388 SEQ_MIDIOUT(dev
, d1
);
1389 SEQ_MIDIOUT(dev
, d2
);
1396 WARN("Technology not supported (yet) %d !\n",
1397 midiOutDevices
[wDevID
]->wTechnology
);
1398 return MMSYSERR_NOTENABLED
;
1403 return MMSYSERR_NOERROR
;
1406 /**************************************************************************
1407 * modLongData [internal]
1409 static DWORD
modLongData(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1414 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1416 if (midiSeqFD
== -1) {
1417 WARN("can't play !\n");
1418 return MIDIERR_NODEVICE
;
1421 lpData
= ((DWORD
)lpMidiHdr
== lpMidiHdr
->reserved
) ?
1422 (LPBYTE
)lpMidiHdr
->lpData
: (LPBYTE
)PTR_SEG_TO_LIN(lpMidiHdr
->lpData
);
1425 return MIDIERR_UNPREPARED
;
1426 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
))
1427 return MIDIERR_UNPREPARED
;
1428 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1429 return MIDIERR_STILLPLAYING
;
1430 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1431 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
1433 /* FIXME: MS doc is not 100% clear. Will lpData only contain system exclusive
1434 * data, or can it also contain raw MIDI data, to be split up and sent to
1436 * If the latest is true, then the following WARNing will fire up
1438 if (lpData
[0] != 0xF0 || lpData
[lpMidiHdr
->dwBufferLength
- 1] != 0xF7) {
1439 WARN("Alledged system exclusive buffer is not correct\n\tPlease report with MIDI file\n");
1442 TRACE("dwBufferLength=%lu !\n", lpMidiHdr
->dwBufferLength
);
1443 TRACE(" %02X %02X %02X ... %02X %02X %02X\n",
1444 lpData
[0], lpData
[1], lpData
[2], lpData
[lpMidiHdr
->dwBufferLength
-3],
1445 lpData
[lpMidiHdr
->dwBufferLength
-2], lpData
[lpMidiHdr
->dwBufferLength
-1]);
1447 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1449 /* FIXME: I don't think there is much to do here */
1452 if (lpData
[0] != 0xF0) {
1453 /* Send end of System Exclusive */
1454 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, 0xF0);
1455 WARN("Adding missing 0xF0 marker at the begining of "
1456 "system exclusive byte stream\n");
1458 for (count
= 0; count
< lpMidiHdr
->dwBytesRecorded
; count
++) {
1459 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, lpData
[count
]);
1461 if (lpData
[count
- 1] != 0xF7) {
1462 /* Send end of System Exclusive */
1463 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, 0xF7);
1464 WARN("Adding missing 0xF7 marker at the end of "
1465 "system exclusive byte stream\n");
1470 WARN("Technology not supported (yet) %d !\n",
1471 midiOutDevices
[wDevID
]->wTechnology
);
1472 return MMSYSERR_NOTENABLED
;
1475 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1476 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1477 if (MIDI_NotifyClient(wDevID
, MOM_DONE
, lpMidiHdr
->reserved
, 0L) != MMSYSERR_NOERROR
) {
1478 WARN("can't notify client !\n");
1479 return MMSYSERR_INVALPARAM
;
1481 return MMSYSERR_NOERROR
;
1484 /**************************************************************************
1485 * modPrepare [internal]
1487 static DWORD
modPrepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1489 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1491 if (midiSeqFD
== -1) {
1492 WARN("can't prepare !\n");
1493 return MMSYSERR_NOTENABLED
;
1496 /* MS doc says taht dwFlags must be set to zero, but (kinda funny) MS mciseq drivers
1497 * asks to prepare MIDIHDR which dwFlags != 0.
1498 * So at least check for the inqueue flag
1500 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
1501 lpMidiHdr
->lpData
== 0 || (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) != 0 ||
1502 lpMidiHdr
->dwBufferLength
>= 0x10000ul
) {
1503 WARN("%p %p %08lx %d/%ld\n", lpMidiHdr
, lpMidiHdr
->lpData
,
1504 lpMidiHdr
->dwFlags
, sizeof(MIDIHDR16
), dwSize
);
1505 return MMSYSERR_INVALPARAM
;
1508 lpMidiHdr
->lpNext
= 0;
1509 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
1510 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1511 return MMSYSERR_NOERROR
;
1514 /**************************************************************************
1515 * modUnprepare [internal]
1517 static DWORD
modUnprepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1519 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1521 if (midiSeqFD
== -1) {
1522 WARN("can't unprepare !\n");
1523 return MMSYSERR_NOTENABLED
;
1526 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0)
1527 return MMSYSERR_INVALPARAM
;
1528 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1529 return MIDIERR_STILLPLAYING
;
1530 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
1531 return MMSYSERR_NOERROR
;
1534 /**************************************************************************
1535 * modReset [internal]
1537 static DWORD
modReset(WORD wDevID
)
1539 TRACE("(%04X);\n", wDevID
);
1540 /* FIXME: this function should :
1541 * turn off every note, remove sustain on all channels
1542 * remove any pending buffers
1544 return MMSYSERR_NOTENABLED
;
1547 #endif /* HAVE_OSS_MIDI */
1549 /*======================================================================*
1550 * MIDI entry points *
1551 *======================================================================*/
1553 /**************************************************************************
1554 * midMessage [sample driver]
1556 DWORD WINAPI
midMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1557 DWORD dwParam1
, DWORD dwParam2
)
1559 TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1560 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1562 #ifdef HAVE_OSS_MIDI
1564 return midOpen(wDevID
,(LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1566 return midClose(wDevID
);
1567 case MIDM_ADDBUFFER
:
1568 return midAddBuffer(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1570 return midPrepare(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1571 case MIDM_UNPREPARE
:
1572 return midUnprepare(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1573 case MIDM_GETDEVCAPS
:
1574 return midGetDevCaps(wDevID
,(LPMIDIINCAPS16
)dwParam1
,dwParam2
);
1575 case MIDM_GETNUMDEVS
:
1576 return MIDM_NUMDEVS
;
1578 return midReset(wDevID
);
1580 return midStart(wDevID
);
1582 return midStop(wDevID
);
1585 TRACE("Unsupported message\n");
1587 return MMSYSERR_NOTSUPPORTED
;
1590 /**************************************************************************
1591 * modMessage [sample driver]
1593 DWORD WINAPI
modMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1594 DWORD dwParam1
, DWORD dwParam2
)
1596 TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1597 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1600 #ifdef HAVE_OSS_MIDI
1602 return modOpen(wDevID
, (LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1604 return modClose(wDevID
);
1606 return modData(wDevID
, dwParam1
);
1608 return modLongData(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1610 return modPrepare(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1611 case MODM_UNPREPARE
:
1612 return modUnprepare(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1613 case MODM_GETDEVCAPS
:
1614 return modGetDevCaps(wDevID
, (LPMIDIOUTCAPS16
)dwParam1
, dwParam2
);
1615 case MODM_GETNUMDEVS
:
1616 return MODM_NUMDEVS
;
1617 case MODM_GETVOLUME
:
1619 case MODM_SETVOLUME
:
1622 return modReset(wDevID
);
1625 TRACE("Unsupported message\n");
1627 return MMSYSERR_NOTSUPPORTED
;
1630 /**************************************************************************
1631 * MIDI_DriverProc32 [sample driver]
1633 LONG CALLBACK
MIDI_DriverProc(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
1634 DWORD dwParam1
, DWORD dwParam2
)
1637 case DRV_LOAD
: return 1;
1638 case DRV_FREE
: return 1;
1639 case DRV_OPEN
: return 1;
1640 case DRV_CLOSE
: return 1;
1641 case DRV_ENABLE
: return 1;
1642 case DRV_DISABLE
: return 1;
1643 case DRV_QUERYCONFIGURE
: return 1;
1644 case DRV_CONFIGURE
: MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1645 case DRV_INSTALL
: return DRVCNF_RESTART
;
1646 case DRV_REMOVE
: return DRVCNF_RESTART
;
1648 TRACE("Sending msg=%lu to default driver proc\n", wMsg
);
1649 return DefDriverProc16(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1653 /**************************************************************************
1654 * MIDI_DriverProc16 [sample driver]
1656 LONG CALLBACK
MIDI_DriverProc16(DWORD dwDevID
, HDRVR16 hDriv
, WORD wMsg
,
1657 DWORD dwParam1
, DWORD dwParam2
)
1660 case DRV_LOAD
: return 1;
1661 case DRV_FREE
: return 1;
1662 case DRV_OPEN
: return 1;
1663 case DRV_CLOSE
: return 1;
1664 case DRV_ENABLE
: return 1;
1665 case DRV_DISABLE
: return 1;
1666 case DRV_QUERYCONFIGURE
: return 1;
1667 case DRV_CONFIGURE
: MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1668 case DRV_INSTALL
: return DRVCNF_RESTART
;
1669 case DRV_REMOVE
: return DRVCNF_RESTART
;
1671 TRACE("Sending msg=%u to default driver proc\n", wMsg
);
1672 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1676 /*-----------------------------------------------------------------------*/