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 split in midi.c and mcimidi.c
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 * + use better instrument definition for OPL/2 (midiPatch.c) or
31 * use existing instrument definition (from playmidi or kmid)
32 * with a .winerc option
33 * + have a look at OPL/3 ?
34 * + implement asynchronous playback of MidiHdr
35 * + implement STREAM'ed MidiHdr (question: how shall we share the
36 * code between the midiStream functions in MMSYSTEM/WINMM and
37 * the code for the low level driver)
38 * + use a more accurate read mechanism than the one of snooping on
39 * timers (like select on fd)
43 #include "wine/port.h"
54 #ifdef HAVE_SYS_IOCTL_H
55 # include <sys/ioctl.h>
60 #ifdef HAVE_SYS_POLL_H
63 #if defined(HAVE_SYS_SOUNDCARD_H)
64 # include <sys/soundcard.h>
65 #elif defined(HAVE_MACHINE_SOUNDCARD_H)
66 # include <machine/soundcard.h>
67 #elif defined(HAVE_SOUNDCARD_H)
68 # include <soundcard.h>
70 #ifdef HAVE_SYS_ERRNO_H
71 #include <sys/errno.h>
80 #include "wine/unicode.h"
81 #include "wine/debug.h"
83 WINE_DEFAULT_DEBUG_CHANNEL(midi
);
85 #ifdef SNDCTL_SEQ_NRMIDIS
92 int state
; /* -1 disabled, 0 is no recording started, 1 in recording, bit 2 set if in sys exclusive recording */
94 MIDIOPENDESC midiDesc
;
98 unsigned char incoming
[3];
99 unsigned char incPrev
;
108 MIDIOPENDESC midiDesc
;
110 LPMIDIHDR lpQueueHdr
;
112 void* lpExtra
; /* according to port type (MIDI, FM...), extra data when needed */
116 static WINE_MIDIIN MidiInDev
[MAX_MIDIINDRV
];
117 static WINE_MIDIOUT MidiOutDev
[MAX_MIDIOUTDRV
];
119 /* this is the total number of MIDI out devices found (synth and port) */
120 static int MODM_NumDevs
= 0;
121 /* this is the number of FM synthesizers (index from 0 to NUMFMSYNTHDEVS - 1) */
122 static int MODM_NumFMSynthDevs
= 0;
123 /* the Midi ports have index from NUMFMSYNTHDEVS to NumDevs - 1 */
125 /* this is the total number of MIDI out devices found */
126 static int MIDM_NumDevs
= 0;
128 static int midiSeqFD
= -1;
129 static int numOpenMidiSeq
= 0;
130 static int numStartedMidiIn
= 0;
132 static CRITICAL_SECTION crit_sect
; /* protects all MidiIn buffers queues */
133 static CRITICAL_SECTION_DEBUG critsect_debug
=
136 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
137 0, 0, { (DWORD_PTR
)(__FILE__
": crit_sect") }
139 static CRITICAL_SECTION crit_sect
= { &critsect_debug
, -1, 0, 0, 0, 0 };
141 static int end_thread
;
142 static HANDLE hThread
;
144 /*======================================================================*
145 * Low level MIDI implementation *
146 *======================================================================*/
148 static int midiOpenSeq(void);
149 static int midiCloseSeq(void);
151 /**************************************************************************
152 * MIDI_unixToWindowsDeviceType [internal]
154 * return the Windows equivalent to a Unix Device Type
157 static int MIDI_UnixToWindowsDeviceType(int type
)
159 /* MOD_MIDIPORT output port
160 * MOD_SYNTH generic internal synth
161 * MOD_SQSYNTH square wave internal synth
162 * MOD_FMSYNTH FM internal synth
163 * MOD_MAPPER MIDI mapper
164 * MOD_WAVETABLE hardware watetable internal synth
165 * MOD_SWSYNTH software internal synth
168 /* FIXME Is this really the correct equivalence from UNIX to
169 Windows Sound type */
172 case SYNTH_TYPE_FM
: return MOD_FMSYNTH
;
173 case SYNTH_TYPE_SAMPLE
: return MOD_SYNTH
;
174 case SYNTH_TYPE_MIDI
: return MOD_MIDIPORT
;
176 ERR("Cannot determine the type of this midi device. "
177 "Assuming FM Synth\n");
182 static int MIDI_loadcount
;
183 /**************************************************************************
184 * OSS_MidiInit [internal]
186 * Initializes the MIDI devices information variables
188 static LRESULT
OSS_MidiInit(void)
190 int i
, status
, numsynthdevs
= 255, nummididevs
= 255;
191 struct synth_info sinfo
;
192 struct midi_info minfo
;
194 TRACE("(%i)\n", MIDI_loadcount
);
195 if (MIDI_loadcount
++)
198 TRACE("Initializing the MIDI variables.\n");
200 /* try to open device */
201 if (midiOpenSeq() == -1) {
205 /* find how many Synth devices are there in the system */
206 status
= ioctl(midiSeqFD
, SNDCTL_SEQ_NRSYNTHS
, &numsynthdevs
);
209 ERR("ioctl for nr synth failed.\n");
214 if (numsynthdevs
> MAX_MIDIOUTDRV
) {
215 ERR("MAX_MIDIOUTDRV (%d) was enough for the number of devices (%d). "
216 "Some FM devices will not be available.\n",MAX_MIDIOUTDRV
,numsynthdevs
);
217 numsynthdevs
= MAX_MIDIOUTDRV
;
220 for (i
= 0; i
< numsynthdevs
; i
++) {
221 /* Manufac ID. We do not have access to this with soundcard.h
222 * Does not seem to be a problem, because in mmsystem.h only
223 * Microsoft's ID is listed.
225 MidiOutDev
[i
].caps
.wMid
= 0x00FF;
226 MidiOutDev
[i
].caps
.wPid
= 0x0001; /* FIXME Product ID */
227 /* Product Version. We simply say "1" */
228 MidiOutDev
[i
].caps
.vDriverVersion
= 0x001;
229 /* The following are mandatory for MOD_MIDIPORT */
230 MidiOutDev
[i
].caps
.wChannelMask
= 0xFFFF;
231 MidiOutDev
[i
].caps
.wVoices
= 0;
232 MidiOutDev
[i
].caps
.wNotes
= 0;
233 MidiOutDev
[i
].caps
.dwSupport
= 0;
236 status
= ioctl(midiSeqFD
, SNDCTL_SYNTH_INFO
, &sinfo
);
238 static const WCHAR fmt
[] = {'W','i','n','e',' ','O','S','S',' ','M','i','d','i',' ','O','u','t',' ','#','%','d',' ','d','i','s','a','b','l','e','d',0};
239 ERR("ioctl for synth info failed on %d, disabling it.\n", i
);
241 wsprintfW(MidiOutDev
[i
].caps
.szPname
, fmt
, i
);
243 MidiOutDev
[i
].caps
.wTechnology
= MOD_MIDIPORT
;
244 MidiOutDev
[i
].bEnabled
= FALSE
;
246 MultiByteToWideChar( CP_UNIXCP
, 0, sinfo
.name
, -1,
247 MidiOutDev
[i
].caps
.szPname
,
248 sizeof(MidiOutDev
[i
].caps
.szPname
)/sizeof(WCHAR
) );
249 MidiOutDev
[i
].caps
.wTechnology
= MIDI_UnixToWindowsDeviceType(sinfo
.synth_type
);
251 if (MOD_MIDIPORT
!= MidiOutDev
[i
].caps
.wTechnology
) {
252 /* FIXME Do we have this information?
253 * Assuming the soundcards can handle
254 * MIDICAPS_VOLUME and MIDICAPS_LRVOLUME but
255 * not MIDICAPS_CACHE.
257 MidiOutDev
[i
].caps
.dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
258 MidiOutDev
[i
].caps
.wVoices
= sinfo
.nr_voices
;
260 /* FIXME Is it possible to know the maximum
261 * number of simultaneous notes of a soundcard ?
262 * I believe we don't have this information, but
263 * it's probably equal or more than wVoices
265 MidiOutDev
[i
].caps
.wNotes
= sinfo
.nr_voices
;
267 MidiOutDev
[i
].bEnabled
= TRUE
;
269 /* We also have the information sinfo.synth_subtype, not used here
271 if (sinfo
.capabilities
& SYNTH_CAP_INPUT
) {
272 FIXME("Synthesizer supports MIDI in. Not yet supported.\n");
274 TRACE("SynthOut[%d]\tOSS info: synth type=%d/%d capa=%lx\n",
275 i
, sinfo
.synth_type
, sinfo
.synth_subtype
, (long)sinfo
.capabilities
);
278 TRACE("SynthOut[%d]\tname='%s' techn=%d voices=%d notes=%d chnMsk=%04x support=%d\n",
279 i
, wine_dbgstr_w(MidiOutDev
[i
].caps
.szPname
),
280 MidiOutDev
[i
].caps
.wTechnology
,
281 MidiOutDev
[i
].caps
.wVoices
, MidiOutDev
[i
].caps
.wNotes
,
282 MidiOutDev
[i
].caps
.wChannelMask
, MidiOutDev
[i
].caps
.dwSupport
);
285 /* find how many MIDI devices are there in the system */
286 status
= ioctl(midiSeqFD
, SNDCTL_SEQ_NRMIDIS
, &nummididevs
);
288 ERR("ioctl on nr midi failed.\n");
293 /* FIXME: the two restrictions below could be loosened in some cases */
294 if (numsynthdevs
+ nummididevs
> MAX_MIDIOUTDRV
) {
295 ERR("MAX_MIDIOUTDRV was not enough for the number of devices. "
296 "Some MIDI devices will not be available.\n");
297 nummididevs
= MAX_MIDIOUTDRV
- numsynthdevs
;
300 if (nummididevs
> MAX_MIDIINDRV
) {
301 ERR("MAX_MIDIINDRV (%d) was not enough for the number of devices (%d). "
302 "Some MIDI devices will not be available.\n",MAX_MIDIINDRV
,nummididevs
);
303 nummididevs
= MAX_MIDIINDRV
;
306 for (i
= 0; i
< nummididevs
; i
++) {
308 status
= ioctl(midiSeqFD
, SNDCTL_MIDI_INFO
, &minfo
);
309 if (status
== -1) WARN("ioctl on midi info for device %d failed.\n", i
);
311 /* This whole part is somewhat obscure to me. I'll keep trying to dig
312 info about it. If you happen to know, please tell us. The very
313 descriptive minfo.dev_type was not used here.
315 /* Manufacturer ID. We do not have access to this with soundcard.h
316 Does not seem to be a problem, because in mmsystem.h only
317 Microsoft's ID is listed */
318 MidiOutDev
[numsynthdevs
+ i
].caps
.wMid
= 0x00FF;
319 MidiOutDev
[numsynthdevs
+ i
].caps
.wPid
= 0x0001; /* FIXME Product ID */
320 /* Product Version. We simply say "1" */
321 MidiOutDev
[numsynthdevs
+ i
].caps
.vDriverVersion
= 0x001;
323 static const WCHAR fmt
[] = {'W','i','n','e',' ','O','S','S',' ','M','i','d','i',' ','O','u','t',' ','#','%','d',' ','d','i','s','a','b','l','e','d',0};
324 wsprintfW(MidiOutDev
[numsynthdevs
+ i
].caps
.szPname
, fmt
, numsynthdevs
+ i
);
325 MidiOutDev
[numsynthdevs
+ i
].bEnabled
= FALSE
;
327 MultiByteToWideChar(CP_UNIXCP
, 0, minfo
.name
, -1,
328 MidiOutDev
[numsynthdevs
+ i
].caps
.szPname
,
329 sizeof(MidiOutDev
[numsynthdevs
+ i
].caps
.szPname
) / sizeof(WCHAR
));
330 MidiOutDev
[numsynthdevs
+ i
].bEnabled
= TRUE
;
332 MidiOutDev
[numsynthdevs
+ i
].caps
.wTechnology
= MOD_MIDIPORT
;
333 MidiOutDev
[numsynthdevs
+ i
].caps
.wVoices
= 0;
334 MidiOutDev
[numsynthdevs
+ i
].caps
.wNotes
= 0;
335 MidiOutDev
[numsynthdevs
+ i
].caps
.wChannelMask
= 0xFFFF;
336 MidiOutDev
[numsynthdevs
+ i
].caps
.dwSupport
= 0;
338 /* This whole part is somewhat obscure to me. I'll keep trying to dig
339 info about it. If you happen to know, please tell us. The very
340 descriptive minfo.dev_type was not used here.
342 /* Manufac ID. We do not have access to this with soundcard.h
343 Does not seem to be a problem, because in mmsystem.h only
344 Microsoft's ID is listed */
345 MidiInDev
[i
].caps
.wMid
= 0x00FF;
346 MidiInDev
[i
].caps
.wPid
= 0x0001; /* FIXME Product ID */
347 /* Product Version. We simply say "1" */
348 MidiInDev
[i
].caps
.vDriverVersion
= 0x001;
350 static const WCHAR fmt
[] = {'W','i','n','e',' ','O','S','S',' ','M','i','d','i',' ','I','n',' ','#','%','d',' ','d','i','s','a','b','l','e','d',0};
351 wsprintfW(MidiInDev
[i
].caps
.szPname
, fmt
, numsynthdevs
+ i
);
352 MidiInDev
[i
].state
= -1;
354 MultiByteToWideChar(CP_UNIXCP
, 0, minfo
.name
, -1,
355 MidiInDev
[i
].caps
.szPname
,
356 sizeof(MidiInDev
[i
].caps
.szPname
) / sizeof(WCHAR
));
357 MidiInDev
[i
].state
= 0;
359 MidiInDev
[i
].caps
.dwSupport
= 0; /* mandatory with MIDIINCAPS */
361 TRACE("OSS info: midi[%d] dev-type=%d capa=%lx\n"
362 "\tMidiOut[%d] name='%s' techn=%d voices=%d notes=%d chnMsk=%04x support=%d\n"
363 "\tMidiIn [%d] name='%s' support=%d\n",
364 i
, minfo
.dev_type
, (long)minfo
.capabilities
,
365 numsynthdevs
+ i
, wine_dbgstr_w(MidiOutDev
[numsynthdevs
+ i
].caps
.szPname
),
366 MidiOutDev
[numsynthdevs
+ i
].caps
.wTechnology
,
367 MidiOutDev
[numsynthdevs
+ i
].caps
.wVoices
, MidiOutDev
[numsynthdevs
+ i
].caps
.wNotes
,
368 MidiOutDev
[numsynthdevs
+ i
].caps
.wChannelMask
, MidiOutDev
[numsynthdevs
+ i
].caps
.dwSupport
,
369 i
, wine_dbgstr_w(MidiInDev
[i
].caps
.szPname
), MidiInDev
[i
].caps
.dwSupport
);
373 /* windows does not seem to differentiate Synth from MIDI devices */
374 MODM_NumFMSynthDevs
= numsynthdevs
;
375 MODM_NumDevs
= numsynthdevs
+ nummididevs
;
377 MIDM_NumDevs
= nummididevs
;
379 /* close file and exit */
385 /**************************************************************************
386 * OSS_MidiExit [internal]
388 * Release the MIDI devices information variables
390 static LRESULT
OSS_MidiExit(void)
392 TRACE("(%i)\n", MIDI_loadcount
);
394 if (--MIDI_loadcount
)
397 ZeroMemory(MidiInDev
, sizeof(MidiInDev
));
398 ZeroMemory(MidiOutDev
, sizeof(MidiOutDev
));
401 MODM_NumFMSynthDevs
= 0;
407 /**************************************************************************
408 * MIDI_NotifyClient [internal]
410 static void MIDI_NotifyClient(UINT wDevID
, WORD wMsg
,
411 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
418 TRACE("wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
419 wDevID
, wMsg
, dwParam1
, dwParam2
);
426 if (wDevID
> MODM_NumDevs
) return;
428 dwCallBack
= MidiOutDev
[wDevID
].midiDesc
.dwCallback
;
429 uFlags
= MidiOutDev
[wDevID
].wFlags
;
430 hDev
= MidiOutDev
[wDevID
].midiDesc
.hMidi
;
431 dwInstance
= MidiOutDev
[wDevID
].midiDesc
.dwInstance
;
441 if (wDevID
> MIDM_NumDevs
) return;
443 dwCallBack
= MidiInDev
[wDevID
].midiDesc
.dwCallback
;
444 uFlags
= MidiInDev
[wDevID
].wFlags
;
445 hDev
= MidiInDev
[wDevID
].midiDesc
.hMidi
;
446 dwInstance
= MidiInDev
[wDevID
].midiDesc
.dwInstance
;
449 ERR("Unsupported MSW-MIDI message %u\n", wMsg
);
453 DriverCallback(dwCallBack
, uFlags
, hDev
, wMsg
, dwInstance
, dwParam1
, dwParam2
);
456 static int midi_warn
= 1;
457 /**************************************************************************
458 * midiOpenSeq [internal]
460 static int midiOpenSeq(void)
462 if (numOpenMidiSeq
== 0) {
464 device
=getenv("MIDIDEV");
465 if (!device
) device
="/dev/sequencer";
466 midiSeqFD
= open(device
, O_RDWR
, 0);
467 if (midiSeqFD
== -1) {
470 WARN("Can't open MIDI device '%s' ! (%s). If your "
471 "program needs this (probably not): %s\n",
472 device
, strerror(errno
),
474 "create it ! (\"man MAKEDEV\" ?)" :
476 "load MIDI sequencer kernel driver !" :
478 "grant access ! (\"man chmod\")" : ""
485 if (fcntl(midiSeqFD
, F_SETFL
, O_NONBLOCK
) < 0) {
486 WARN("can't set sequencer fd to non-blocking, errno %d (%s)\n", errno
, strerror(errno
));
492 fcntl(midiSeqFD
, F_SETFD
, 1); /* set close on exec flag */
493 ioctl(midiSeqFD
, SNDCTL_SEQ_RESET
);
499 /**************************************************************************
500 * midiCloseSeq [internal]
502 static int midiCloseSeq(void)
504 if (--numOpenMidiSeq
== 0) {
511 /* FIXME: this is a bad idea, it's even not static... */
514 /* FIXME: this is not reentrant, not static - because of global variable
517 /**************************************************************************
518 * seqbuf_dump [internal]
520 * Used by SEQ_DUMPBUF to flush the buffer.
523 void seqbuf_dump(void)
526 if (write(midiSeqFD
, _seqbuf
, _seqbufptr
) == -1) {
527 WARN("Can't write data to sequencer %d, errno %d (%s)!\n",
528 midiSeqFD
, errno
, strerror(errno
));
531 * in any case buffer is lost so that if many errors occur the buffer
538 /**************************************************************************
539 * midReceiveChar [internal]
541 static void midReceiveChar(WORD wDevID
, unsigned char value
, DWORD dwTime
)
545 TRACE("Adding %02xh to %d[%d]\n", value
, wDevID
, MidiInDev
[wDevID
].incLen
);
547 if (wDevID
>= MIDM_NumDevs
) {
551 if (MidiInDev
[wDevID
].state
<= 0) {
552 TRACE("disabled or input not started, thrown away\n");
556 if (MidiInDev
[wDevID
].state
& 2) { /* system exclusive */
560 EnterCriticalSection(&crit_sect
);
561 if ((lpMidiHdr
= MidiInDev
[wDevID
].lpQueueHdr
) != NULL
) {
562 LPBYTE lpData
= (LPBYTE
) lpMidiHdr
->lpData
;
564 lpData
[lpMidiHdr
->dwBytesRecorded
++] = value
;
565 if (lpMidiHdr
->dwBytesRecorded
== lpMidiHdr
->dwBufferLength
) {
569 if (value
== 0xF7) { /* then end */
570 MidiInDev
[wDevID
].state
&= ~2;
573 if (sbfb
&& lpMidiHdr
!= NULL
) {
574 lpMidiHdr
= MidiInDev
[wDevID
].lpQueueHdr
;
575 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
576 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
577 MidiInDev
[wDevID
].lpQueueHdr
= lpMidiHdr
->lpNext
;
578 MIDI_NotifyClient(wDevID
, MIM_LONGDATA
, (DWORD_PTR
)lpMidiHdr
, dwTime
);
580 LeaveCriticalSection(&crit_sect
);
584 #define IS_CMD(_x) (((_x) & 0x80) == 0x80)
585 #define IS_SYS_CMD(_x) (((_x) & 0xF0) == 0xF0)
587 if (!IS_CMD(value
) && MidiInDev
[wDevID
].incLen
== 0) { /* try to reuse old cmd */
588 if (IS_CMD(MidiInDev
[wDevID
].incPrev
) && !IS_SYS_CMD(MidiInDev
[wDevID
].incPrev
)) {
589 MidiInDev
[wDevID
].incoming
[0] = MidiInDev
[wDevID
].incPrev
;
590 MidiInDev
[wDevID
].incLen
= 1;
591 TRACE("Reusing old command %02xh\n", MidiInDev
[wDevID
].incPrev
);
593 FIXME("error for midi-in, should generate MIM_ERROR notification:"
594 " prev=%02Xh, incLen=%02Xh\n",
595 MidiInDev
[wDevID
].incPrev
, MidiInDev
[wDevID
].incLen
);
599 MidiInDev
[wDevID
].incoming
[(int)(MidiInDev
[wDevID
].incLen
++)] = value
;
600 if (MidiInDev
[wDevID
].incLen
== 1 && !IS_SYS_CMD(MidiInDev
[wDevID
].incoming
[0])) {
601 /* store new cmd, just in case */
602 MidiInDev
[wDevID
].incPrev
= MidiInDev
[wDevID
].incoming
[0];
608 switch (MidiInDev
[wDevID
].incoming
[0] & 0xF0) {
611 case MIDI_KEY_PRESSURE
:
612 case MIDI_CTL_CHANGE
:
613 case MIDI_PITCH_BEND
:
614 if (MidiInDev
[wDevID
].incLen
== 3) {
615 toSend
= (MidiInDev
[wDevID
].incoming
[2] << 16) |
616 (MidiInDev
[wDevID
].incoming
[1] << 8) |
617 (MidiInDev
[wDevID
].incoming
[0] << 0);
620 case MIDI_PGM_CHANGE
:
621 case MIDI_CHN_PRESSURE
:
622 if (MidiInDev
[wDevID
].incLen
== 2) {
623 toSend
= (MidiInDev
[wDevID
].incoming
[1] << 8) |
624 (MidiInDev
[wDevID
].incoming
[0] << 0);
627 case MIDI_SYSTEM_PREFIX
:
628 if (MidiInDev
[wDevID
].incoming
[0] == 0xF0) {
629 MidiInDev
[wDevID
].state
|= 2;
630 MidiInDev
[wDevID
].incLen
= 0;
632 if (MidiInDev
[wDevID
].incLen
== 1) {
633 toSend
= (MidiInDev
[wDevID
].incoming
[0] << 0);
638 WARN("This shouldn't happen (%02X)\n", MidiInDev
[wDevID
].incoming
[0]);
641 TRACE("Sending event %08x\n", toSend
);
642 MidiInDev
[wDevID
].incLen
= 0;
643 dwTime
-= MidiInDev
[wDevID
].startTime
;
644 MIDI_NotifyClient(wDevID
, MIM_DATA
, toSend
, dwTime
);
648 static DWORD WINAPI
midRecThread(LPVOID arg
)
650 unsigned char buffer
[256];
655 TRACE("Thread startup\n");
661 TRACE("Thread loop\n");
663 /* Check if an event is present */
664 if (poll(&pfd
, 1, 250) <= 0)
667 len
= read(midiSeqFD
, buffer
, sizeof(buffer
));
668 TRACE("Received %d bytes\n", len
);
670 if (len
< 0) continue;
671 if ((len
% 4) != 0) {
672 WARN("Bad length %d, errno %d (%s)\n", len
, errno
, strerror(errno
));
676 dwTime
= GetTickCount();
678 for (idx
= 0; idx
< len
; ) {
679 if (buffer
[idx
] & 0x80) {
681 "Reading<8> %02x %02x %02x %02x %02x %02x %02x %02x\n",
682 buffer
[idx
+ 0], buffer
[idx
+ 1],
683 buffer
[idx
+ 2], buffer
[idx
+ 3],
684 buffer
[idx
+ 4], buffer
[idx
+ 5],
685 buffer
[idx
+ 6], buffer
[idx
+ 7]);
688 switch (buffer
[idx
+ 0]) {
693 midReceiveChar(buffer
[idx
+ 2], buffer
[idx
+ 1], dwTime
);
696 TRACE("Unsupported event %d\n", buffer
[idx
+ 0]);
706 /**************************************************************************
707 * midGetDevCaps [internal]
709 static DWORD
midGetDevCaps(WORD wDevID
, LPMIDIINCAPSW lpCaps
, DWORD dwSize
)
711 TRACE("(%04X, %p, %08X);\n", wDevID
, lpCaps
, dwSize
);
713 if (wDevID
>= MIDM_NumDevs
) return MMSYSERR_BADDEVICEID
;
714 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
716 memcpy(lpCaps
, &MidiInDev
[wDevID
].caps
, min(dwSize
, sizeof(*lpCaps
)));
718 return MMSYSERR_NOERROR
;
721 /**************************************************************************
724 static DWORD
midOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
726 TRACE("(%04X, %p, %08X);\n", wDevID
, lpDesc
, dwFlags
);
728 if (lpDesc
== NULL
) {
729 WARN("Invalid Parameter !\n");
730 return MMSYSERR_INVALPARAM
;
734 * how to check that content of lpDesc is correct ?
736 if (wDevID
>= MIDM_NumDevs
) {
737 WARN("wDevID too large (%u) !\n", wDevID
);
738 return MMSYSERR_BADDEVICEID
;
740 if (MidiInDev
[wDevID
].state
== -1) {
741 WARN("device disabled\n");
742 return MIDIERR_NODEVICE
;
744 if (MidiInDev
[wDevID
].midiDesc
.hMidi
!= 0) {
745 WARN("device already open !\n");
746 return MMSYSERR_ALLOCATED
;
748 if ((dwFlags
& MIDI_IO_STATUS
) != 0) {
749 WARN("No support for MIDI_IO_STATUS in dwFlags yet, ignoring it\n");
750 dwFlags
&= ~MIDI_IO_STATUS
;
752 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
753 FIXME("Bad dwFlags\n");
754 return MMSYSERR_INVALFLAG
;
757 if (midiOpenSeq() < 0) {
758 return MMSYSERR_ERROR
;
761 if (numStartedMidiIn
++ == 0) {
763 hThread
= CreateThread(NULL
, 0, midRecThread
, NULL
, 0, NULL
);
765 numStartedMidiIn
= 0;
766 WARN("Couldn't create thread for midi-in\n");
768 return MMSYSERR_ERROR
;
770 SetThreadPriority(hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
771 TRACE("Created thread for midi-in\n");
774 MidiInDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
776 MidiInDev
[wDevID
].lpQueueHdr
= NULL
;
777 MidiInDev
[wDevID
].dwTotalPlayed
= 0;
778 MidiInDev
[wDevID
].bufsize
= 0x3FFF;
779 MidiInDev
[wDevID
].midiDesc
= *lpDesc
;
780 MidiInDev
[wDevID
].state
= 0;
781 MidiInDev
[wDevID
].incLen
= 0;
782 MidiInDev
[wDevID
].startTime
= 0;
784 MIDI_NotifyClient(wDevID
, MIM_OPEN
, 0L, 0L);
785 return MMSYSERR_NOERROR
;
788 /**************************************************************************
789 * midClose [internal]
791 static DWORD
midClose(WORD wDevID
)
793 int ret
= MMSYSERR_NOERROR
;
795 TRACE("(%04X);\n", wDevID
);
797 if (wDevID
>= MIDM_NumDevs
) {
798 WARN("wDevID too big (%u) !\n", wDevID
);
799 return MMSYSERR_BADDEVICEID
;
801 if (MidiInDev
[wDevID
].midiDesc
.hMidi
== 0) {
802 WARN("device not opened !\n");
803 return MMSYSERR_ERROR
;
805 if (MidiInDev
[wDevID
].lpQueueHdr
!= 0) {
806 return MIDIERR_STILLPLAYING
;
809 if (midiSeqFD
== -1) {
811 return MMSYSERR_ERROR
;
813 if (--numStartedMidiIn
== 0) {
814 TRACE("Stopping thread for midi-in\n");
816 if (WaitForSingleObject(hThread
, 5000) != WAIT_OBJECT_0
) {
817 WARN("Thread end not signaled, force termination\n");
818 TerminateThread(hThread
, 0);
820 TRACE("Stopped thread for midi-in\n");
824 MidiInDev
[wDevID
].bufsize
= 0;
825 MIDI_NotifyClient(wDevID
, MIM_CLOSE
, 0L, 0L);
826 MidiInDev
[wDevID
].midiDesc
.hMidi
= 0;
830 /**************************************************************************
831 * midAddBuffer [internal]
833 static DWORD
midAddBuffer(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
835 TRACE("(%04X, %p, %08X);\n", wDevID
, lpMidiHdr
, dwSize
);
837 if (wDevID
>= MIDM_NumDevs
) return MMSYSERR_BADDEVICEID
;
838 if (MidiInDev
[wDevID
].state
== -1) return MIDIERR_NODEVICE
;
840 if (lpMidiHdr
== NULL
) return MMSYSERR_INVALPARAM
;
841 if (dwSize
< offsetof(MIDIHDR
,dwOffset
)) return MMSYSERR_INVALPARAM
;
842 if (lpMidiHdr
->dwBufferLength
== 0) return MMSYSERR_INVALPARAM
;
843 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
844 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
846 EnterCriticalSection(&crit_sect
);
847 lpMidiHdr
->dwFlags
&= ~WHDR_DONE
;
848 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
849 lpMidiHdr
->dwBytesRecorded
= 0;
850 lpMidiHdr
->lpNext
= 0;
851 if (MidiInDev
[wDevID
].lpQueueHdr
== 0) {
852 MidiInDev
[wDevID
].lpQueueHdr
= lpMidiHdr
;
856 for (ptr
= MidiInDev
[wDevID
].lpQueueHdr
;
859 ptr
->lpNext
= lpMidiHdr
;
861 LeaveCriticalSection(&crit_sect
);
863 return MMSYSERR_NOERROR
;
866 /**************************************************************************
867 * midPrepare [internal]
869 static DWORD
midPrepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
871 TRACE("(%04X, %p, %08X);\n", wDevID
, lpMidiHdr
, dwSize
);
873 if (dwSize
< offsetof(MIDIHDR
,dwOffset
) || lpMidiHdr
== 0 ||
874 lpMidiHdr
->lpData
== 0 || (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) != 0)
875 return MMSYSERR_INVALPARAM
;
877 lpMidiHdr
->lpNext
= 0;
878 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
879 lpMidiHdr
->dwBytesRecorded
= 0;
881 return MMSYSERR_NOERROR
;
884 /**************************************************************************
885 * midUnprepare [internal]
887 static DWORD
midUnprepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
889 TRACE("(%04X, %p, %08X);\n", wDevID
, lpMidiHdr
, dwSize
);
891 if (wDevID
>= MIDM_NumDevs
) return MMSYSERR_BADDEVICEID
;
892 if (MidiInDev
[wDevID
].state
== -1) return MIDIERR_NODEVICE
;
894 if (dwSize
< offsetof(MIDIHDR
,dwOffset
) || lpMidiHdr
== 0 ||
895 lpMidiHdr
->lpData
== 0)
896 return MMSYSERR_INVALPARAM
;
898 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
899 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
901 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
903 return MMSYSERR_NOERROR
;
906 /**************************************************************************
907 * midReset [internal]
909 static DWORD
midReset(WORD wDevID
)
911 DWORD dwTime
= GetTickCount();
913 TRACE("(%04X);\n", wDevID
);
915 if (wDevID
>= MIDM_NumDevs
) return MMSYSERR_BADDEVICEID
;
916 if (MidiInDev
[wDevID
].state
== -1) return MIDIERR_NODEVICE
;
918 EnterCriticalSection(&crit_sect
);
919 while (MidiInDev
[wDevID
].lpQueueHdr
) {
920 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
&= ~MHDR_INQUEUE
;
921 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
|= MHDR_DONE
;
922 /* FIXME: when called from 16 bit, lpQueueHdr needs to be a segmented ptr */
923 MIDI_NotifyClient(wDevID
, MIM_LONGDATA
,
924 (DWORD_PTR
)MidiInDev
[wDevID
].lpQueueHdr
, dwTime
);
925 MidiInDev
[wDevID
].lpQueueHdr
= MidiInDev
[wDevID
].lpQueueHdr
->lpNext
;
927 LeaveCriticalSection(&crit_sect
);
929 return MMSYSERR_NOERROR
;
933 /**************************************************************************
934 * midStart [internal]
936 static DWORD
midStart(WORD wDevID
)
938 TRACE("(%04X);\n", wDevID
);
940 if (wDevID
>= MIDM_NumDevs
) return MMSYSERR_BADDEVICEID
;
941 if (MidiInDev
[wDevID
].state
== -1) return MIDIERR_NODEVICE
;
943 MidiInDev
[wDevID
].state
= 1;
944 MidiInDev
[wDevID
].startTime
= GetTickCount();
945 return MMSYSERR_NOERROR
;
948 /**************************************************************************
951 static DWORD
midStop(WORD wDevID
)
953 TRACE("(%04X);\n", wDevID
);
955 if (wDevID
>= MIDM_NumDevs
) return MMSYSERR_BADDEVICEID
;
956 if (MidiInDev
[wDevID
].state
== -1) return MIDIERR_NODEVICE
;
958 MidiInDev
[wDevID
].state
= 0;
959 return MMSYSERR_NOERROR
;
962 /*-----------------------------------------------------------------------*/
964 typedef struct sVoice
{
965 int note
; /* 0 means not used */
967 unsigned cntMark
: 30,
970 #define sVS_PLAYING 1
971 #define sVS_SUSTAINED 2
974 typedef struct sChannel
{
980 int bank
; /* CTL_BANK_SELECT */
981 int volume
; /* CTL_MAIN_VOLUME */
982 int balance
; /* CTL_BALANCE */
983 int expression
; /* CTL_EXPRESSION */
984 int sustain
; /* CTL_SUSTAIN */
986 unsigned char nrgPmtMSB
; /* Non register Parameters */
987 unsigned char nrgPmtLSB
;
988 unsigned char regPmtMSB
; /* Non register Parameters */
989 unsigned char regPmtLSB
;
992 typedef struct sFMextra
{
995 sChannel channel
[16]; /* MIDI has only 16 channels */
996 sVoice voice
[1]; /* dyn allocated according to sound card */
997 /* do not append fields below voice[1] since the size of this structure
998 * depends on the number of available voices on the FM synth...
1002 extern const unsigned char midiFMInstrumentPatches
[16 * 128];
1003 extern const unsigned char midiFMDrumsPatches
[16 * 128];
1005 /**************************************************************************
1006 * modFMLoad [internal]
1008 static int modFMLoad(int dev
)
1011 struct sbi_instrument sbi
;
1016 memset(sbi
.operators
+ 16, 0, 16);
1017 for (i
= 0; i
< 128; i
++) {
1019 memcpy(sbi
.operators
, midiFMInstrumentPatches
+ i
* 16, 16);
1021 if (write(midiSeqFD
, &sbi
, sizeof(sbi
)) == -1) {
1022 WARN("Couldn't write patch for instrument %d, errno %d (%s)!\n", sbi
.channel
, errno
, strerror(errno
));
1026 for (i
= 0; i
< 128; i
++) {
1027 sbi
.channel
= 128 + i
;
1028 memcpy(sbi
.operators
, midiFMDrumsPatches
+ i
* 16, 16);
1030 if (write(midiSeqFD
, &sbi
, sizeof(sbi
)) == -1) {
1031 WARN("Couldn't write patch for drum %d, errno %d (%s)!\n", sbi
.channel
, errno
, strerror(errno
));
1038 /**************************************************************************
1039 * modFMReset [internal]
1041 static void modFMReset(WORD wDevID
)
1043 sFMextra
* extra
= MidiOutDev
[wDevID
].lpExtra
;
1044 sVoice
* voice
= extra
->voice
;
1045 sChannel
* channel
= extra
->channel
;
1048 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1049 if (voice
[i
].status
!= sVS_UNUSED
) {
1050 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1052 SEQ_KEY_PRESSURE(wDevID
, i
, 127, 0);
1053 SEQ_CONTROL(wDevID
, i
, SEQ_VOLMODE
, VOL_METHOD_LINEAR
);
1055 voice
[i
].channel
= -1;
1056 voice
[i
].cntMark
= 0;
1057 voice
[i
].status
= sVS_UNUSED
;
1059 for (i
= 0; i
< 16; i
++) {
1060 channel
[i
].program
= 0;
1061 channel
[i
].bender
= 8192;
1062 channel
[i
].benderRange
= 2;
1063 channel
[i
].bank
= 0;
1064 channel
[i
].volume
= 127;
1065 channel
[i
].balance
= 64;
1066 channel
[i
].expression
= 0;
1067 channel
[i
].sustain
= 0;
1070 extra
->drumSetMask
= 1 << 9; /* channel 10 is normally drums, sometimes 16 also */
1074 #define IS_DRUM_CHANNEL(_xtra, _chn) ((_xtra)->drumSetMask & (1 << (_chn)))
1076 /**************************************************************************
1077 * modGetDevCaps [internal]
1079 static DWORD
modGetDevCaps(WORD wDevID
, LPMIDIOUTCAPSW lpCaps
, DWORD dwSize
)
1081 TRACE("(%04X, %p, %08X);\n", wDevID
, lpCaps
, dwSize
);
1083 if (wDevID
>= MODM_NumDevs
) return MMSYSERR_BADDEVICEID
;
1084 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
1086 memcpy(lpCaps
, &MidiOutDev
[wDevID
].caps
, min(dwSize
, sizeof(*lpCaps
)));
1088 return MMSYSERR_NOERROR
;
1091 /**************************************************************************
1092 * modOpen [internal]
1094 static DWORD
modOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
1096 TRACE("(%04X, %p, %08X);\n", wDevID
, lpDesc
, dwFlags
);
1097 if (lpDesc
== NULL
) {
1098 WARN("Invalid Parameter !\n");
1099 return MMSYSERR_INVALPARAM
;
1101 if (wDevID
>= MODM_NumDevs
) {
1102 TRACE("MAX_MIDIOUTDRV reached !\n");
1103 return MMSYSERR_BADDEVICEID
;
1105 if (MidiOutDev
[wDevID
].midiDesc
.hMidi
!= 0) {
1106 WARN("device already open !\n");
1107 return MMSYSERR_ALLOCATED
;
1109 if (!MidiOutDev
[wDevID
].bEnabled
) {
1110 WARN("device disabled !\n");
1111 return MIDIERR_NODEVICE
;
1113 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
1114 WARN("bad dwFlags\n");
1115 return MMSYSERR_INVALFLAG
;
1117 if (!MidiOutDev
[wDevID
].bEnabled
) {
1118 TRACE("disabled wDevID\n");
1119 return MMSYSERR_NOTENABLED
;
1122 MidiOutDev
[wDevID
].lpExtra
= 0;
1124 switch (MidiOutDev
[wDevID
].caps
.wTechnology
) {
1129 extra
= HeapAlloc(GetProcessHeap(), 0,
1130 sizeof(struct sFMextra
) +
1131 sizeof(struct sVoice
) * (MidiOutDev
[wDevID
].caps
.wVoices
- 1));
1134 WARN("can't alloc extra data !\n");
1135 return MMSYSERR_NOMEM
;
1137 MidiOutDev
[wDevID
].lpExtra
= extra
;
1138 if (midiOpenSeq() < 0) {
1139 MidiOutDev
[wDevID
].lpExtra
= 0;
1140 HeapFree(GetProcessHeap(), 0, extra
);
1141 return MMSYSERR_ERROR
;
1143 if (modFMLoad(wDevID
) < 0) {
1145 MidiOutDev
[wDevID
].lpExtra
= 0;
1146 HeapFree(GetProcessHeap(), 0, extra
);
1147 return MMSYSERR_ERROR
;
1154 if (midiOpenSeq() < 0) {
1155 return MMSYSERR_ALLOCATED
;
1159 WARN("Technology not supported (yet) %d !\n",
1160 MidiOutDev
[wDevID
].caps
.wTechnology
);
1161 return MMSYSERR_NOTENABLED
;
1164 MidiOutDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
1166 MidiOutDev
[wDevID
].lpQueueHdr
= NULL
;
1167 MidiOutDev
[wDevID
].dwTotalPlayed
= 0;
1168 MidiOutDev
[wDevID
].bufsize
= 0x3FFF;
1169 MidiOutDev
[wDevID
].midiDesc
= *lpDesc
;
1171 MIDI_NotifyClient(wDevID
, MOM_OPEN
, 0L, 0L);
1172 TRACE("Successful !\n");
1173 return MMSYSERR_NOERROR
;
1177 /**************************************************************************
1178 * modClose [internal]
1180 static DWORD
modClose(WORD wDevID
)
1182 int ret
= MMSYSERR_NOERROR
;
1184 TRACE("(%04X);\n", wDevID
);
1186 if (MidiOutDev
[wDevID
].midiDesc
.hMidi
== 0) {
1187 WARN("device not opened !\n");
1188 return MMSYSERR_ERROR
;
1190 /* FIXME: should test that no pending buffer is still in the queue for
1193 if (midiSeqFD
== -1) {
1194 WARN("can't close !\n");
1195 return MMSYSERR_ERROR
;
1198 switch (MidiOutDev
[wDevID
].caps
.wTechnology
) {
1204 WARN("Technology not supported (yet) %d !\n",
1205 MidiOutDev
[wDevID
].caps
.wTechnology
);
1206 return MMSYSERR_NOTENABLED
;
1209 HeapFree(GetProcessHeap(), 0, MidiOutDev
[wDevID
].lpExtra
);
1210 MidiOutDev
[wDevID
].lpExtra
= 0;
1212 MidiOutDev
[wDevID
].bufsize
= 0;
1213 MIDI_NotifyClient(wDevID
, MOM_CLOSE
, 0L, 0L);
1214 MidiOutDev
[wDevID
].midiDesc
.hMidi
= 0;
1218 /**************************************************************************
1219 * modData [internal]
1221 static DWORD
modData(WORD wDevID
, DWORD dwParam
)
1223 WORD evt
= LOBYTE(LOWORD(dwParam
));
1224 WORD d1
= HIBYTE(LOWORD(dwParam
));
1225 WORD d2
= LOBYTE(HIWORD(dwParam
));
1227 TRACE("(%04X, %08X);\n", wDevID
, dwParam
);
1229 if (wDevID
>= MODM_NumDevs
) return MMSYSERR_BADDEVICEID
;
1230 if (!MidiOutDev
[wDevID
].bEnabled
) return MIDIERR_NODEVICE
;
1232 if (midiSeqFD
== -1) {
1233 WARN("can't play !\n");
1234 return MIDIERR_NODEVICE
;
1236 switch (MidiOutDev
[wDevID
].caps
.wTechnology
) {
1239 * - chorus depth controller is not used
1242 sFMextra
* extra
= MidiOutDev
[wDevID
].lpExtra
;
1243 sVoice
* voice
= extra
->voice
;
1244 sChannel
* channel
= extra
->channel
;
1245 int chn
= (evt
& 0x0F);
1248 switch (evt
& 0xF0) {
1250 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1251 /* don't stop sustained notes */
1252 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1253 voice
[i
].status
= sVS_UNUSED
;
1254 SEQ_STOP_NOTE(wDevID
, i
, d1
, d2
);
1259 if (d2
== 0) { /* note off if velocity == 0 */
1260 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1261 /* don't stop sustained notes */
1262 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1263 voice
[i
].status
= sVS_UNUSED
;
1264 SEQ_STOP_NOTE(wDevID
, i
, d1
, 64);
1269 /* finding out in this order :
1271 * - if replaying the same note on the same channel
1272 * - the older voice (LRU)
1274 for (i
= nv
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1275 if (voice
[i
].status
== sVS_UNUSED
||
1276 (voice
[i
].note
== d1
&& voice
[i
].channel
== chn
)) {
1280 if (voice
[i
].cntMark
< voice
[0].cntMark
) {
1285 "playing on voice=%d, pgm=%d, pan=0x%02X, vol=0x%02X, "
1286 "bender=0x%02X, note=0x%02X, vel=0x%02X\n",
1287 nv
, channel
[chn
].program
,
1288 channel
[chn
].balance
,
1289 channel
[chn
].volume
,
1290 channel
[chn
].bender
, d1
, d2
);
1292 SEQ_SET_PATCH(wDevID
, nv
, IS_DRUM_CHANNEL(extra
, chn
) ?
1293 (128 + d1
) : channel
[chn
].program
);
1294 SEQ_BENDER_RANGE(wDevID
, nv
, channel
[chn
].benderRange
* 100);
1295 SEQ_BENDER(wDevID
, nv
, channel
[chn
].bender
);
1296 SEQ_CONTROL(wDevID
, nv
, CTL_PAN
, channel
[chn
].balance
);
1297 SEQ_CONTROL(wDevID
, nv
, CTL_EXPRESSION
, channel
[chn
].expression
);
1299 /* FIXME: does not really seem to work on my SB card and
1300 * screws everything up... so lay it down
1302 SEQ_CONTROL(wDevID
, nv
, CTL_MAIN_VOLUME
, channel
[chn
].volume
);
1304 SEQ_START_NOTE(wDevID
, nv
, d1
, d2
);
1305 voice
[nv
].status
= channel
[chn
].sustain
? sVS_SUSTAINED
: sVS_PLAYING
;
1306 voice
[nv
].note
= d1
;
1307 voice
[nv
].channel
= chn
;
1308 voice
[nv
].cntMark
= extra
->counter
++;
1310 case MIDI_KEY_PRESSURE
:
1311 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1312 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1313 SEQ_KEY_PRESSURE(wDevID
, i
, d1
, d2
);
1317 case MIDI_CTL_CHANGE
:
1319 case CTL_BANK_SELECT
: channel
[chn
].bank
= d2
; break;
1320 case CTL_MAIN_VOLUME
: channel
[chn
].volume
= d2
; break;
1321 case CTL_PAN
: channel
[chn
].balance
= d2
; break;
1322 case CTL_EXPRESSION
: channel
[chn
].expression
= d2
; break;
1323 case CTL_SUSTAIN
: channel
[chn
].sustain
= d2
;
1325 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1326 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1327 voice
[i
].status
= sVS_SUSTAINED
;
1331 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1332 if (voice
[i
].status
== sVS_SUSTAINED
&& voice
[i
].channel
== chn
) {
1333 voice
[i
].status
= sVS_UNUSED
;
1334 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1339 case CTL_NONREG_PARM_NUM_LSB
: channel
[chn
].nrgPmtLSB
= d2
; break;
1340 case CTL_NONREG_PARM_NUM_MSB
: channel
[chn
].nrgPmtMSB
= d2
; break;
1341 case CTL_REGIST_PARM_NUM_LSB
: channel
[chn
].regPmtLSB
= d2
; break;
1342 case CTL_REGIST_PARM_NUM_MSB
: channel
[chn
].regPmtMSB
= d2
; break;
1343 case CTL_DATA_ENTRY
:
1344 switch ((channel
[chn
].regPmtMSB
<< 8) | channel
[chn
].regPmtLSB
) {
1346 if (channel
[chn
].benderRange
!= d2
) {
1347 channel
[chn
].benderRange
= d2
;
1348 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1349 if (voice
[i
].channel
== chn
) {
1350 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1357 channel
[chn
].benderRange
= 2;
1358 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1359 if (voice
[i
].channel
== chn
) {
1360 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1365 TRACE("Data entry: regPmt=0x%02x%02x, nrgPmt=0x%02x%02x with %x\n",
1366 channel
[chn
].regPmtMSB
, channel
[chn
].regPmtLSB
,
1367 channel
[chn
].nrgPmtMSB
, channel
[chn
].nrgPmtLSB
,
1373 case 0x78: /* all sounds off */
1374 /* FIXME: I don't know if I have to take care of the channel
1375 * for this control ?
1377 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1378 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1379 voice
[i
].status
= sVS_UNUSED
;
1380 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1384 case 0x7B: /* all notes off */
1385 /* FIXME: I don't know if I have to take care of the channel
1386 * for this control ?
1388 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1389 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1390 voice
[i
].status
= sVS_UNUSED
;
1391 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1396 TRACE("Dropping MIDI control event 0x%02x(%02x) on channel %d\n",
1401 case MIDI_PGM_CHANGE
:
1402 channel
[chn
].program
= d1
;
1404 case MIDI_CHN_PRESSURE
:
1405 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1406 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1407 SEQ_KEY_PRESSURE(wDevID
, i
, voice
[i
].note
, d1
);
1411 case MIDI_PITCH_BEND
:
1412 channel
[chn
].bender
= (d2
<< 7) + d1
;
1413 for (i
= 0; i
< MidiOutDev
[wDevID
].caps
.wVoices
; i
++) {
1414 if (voice
[i
].channel
== chn
) {
1415 SEQ_BENDER(wDevID
, i
, channel
[chn
].bender
);
1419 case MIDI_SYSTEM_PREFIX
:
1420 switch (evt
& 0x0F) {
1421 case 0x0F: /* Reset */
1425 WARN("Unsupported (yet) system event %02x\n", evt
& 0x0F);
1429 WARN("Internal error, shouldn't happen (event=%08x)\n", evt
& 0xF0);
1430 return MMSYSERR_NOTENABLED
;
1436 int dev
= wDevID
- MODM_NumFMSynthDevs
;
1438 WARN("Internal error on devID (%u) !\n", wDevID
);
1439 return MIDIERR_NODEVICE
;
1442 switch (evt
& 0xF0) {
1445 case MIDI_KEY_PRESSURE
:
1446 case MIDI_CTL_CHANGE
:
1447 case MIDI_PITCH_BEND
:
1448 SEQ_MIDIOUT(dev
, evt
);
1449 SEQ_MIDIOUT(dev
, d1
);
1450 SEQ_MIDIOUT(dev
, d2
);
1452 case MIDI_PGM_CHANGE
:
1453 case MIDI_CHN_PRESSURE
:
1454 SEQ_MIDIOUT(dev
, evt
);
1455 SEQ_MIDIOUT(dev
, d1
);
1457 case MIDI_SYSTEM_PREFIX
:
1458 switch (evt
& 0x0F) {
1459 case 0x00: /* System Exclusive, don't do it on modData,
1460 * should require modLongData*/
1461 case 0x01: /* Undefined */
1462 case 0x04: /* Undefined. */
1463 case 0x05: /* Undefined. */
1464 case 0x07: /* End of Exclusive. */
1465 case 0x09: /* Undefined. */
1466 case 0x0D: /* Undefined. */
1468 case 0x06: /* Tune Request */
1469 case 0x08: /* Timing Clock. */
1470 case 0x0A: /* Start. */
1471 case 0x0B: /* Continue */
1472 case 0x0C: /* Stop */
1473 case 0x0E: /* Active Sensing. */
1474 SEQ_MIDIOUT(dev
, evt
);
1476 case 0x0F: /* Reset */
1477 /* SEQ_MIDIOUT(dev, evt);
1478 this other way may be better */
1479 SEQ_MIDIOUT(dev
, MIDI_SYSTEM_PREFIX
);
1480 SEQ_MIDIOUT(dev
, 0x7e);
1481 SEQ_MIDIOUT(dev
, 0x7f);
1482 SEQ_MIDIOUT(dev
, 0x09);
1483 SEQ_MIDIOUT(dev
, 0x01);
1484 SEQ_MIDIOUT(dev
, 0xf7);
1486 case 0x03: /* Song Select. */
1487 SEQ_MIDIOUT(dev
, evt
);
1488 SEQ_MIDIOUT(dev
, d1
);
1489 case 0x02: /* Song Position Pointer. */
1490 SEQ_MIDIOUT(dev
, evt
);
1491 SEQ_MIDIOUT(dev
, d1
);
1492 SEQ_MIDIOUT(dev
, d2
);
1499 WARN("Technology not supported (yet) %d !\n",
1500 MidiOutDev
[wDevID
].caps
.wTechnology
);
1501 return MMSYSERR_NOTENABLED
;
1506 return MMSYSERR_NOERROR
;
1509 /**************************************************************************
1510 * modLongData [internal]
1512 static DWORD
modLongData(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1517 TRACE("(%04X, %p, %08X);\n", wDevID
, lpMidiHdr
, dwSize
);
1519 /* Note: MS doc does not say much about the dwBytesRecorded member of the MIDIHDR structure
1520 * but it seems to be used only for midi input.
1521 * Taking a look at the WAVEHDR structure (which is quite similar) confirms this assumption.
1524 if (wDevID
>= MODM_NumDevs
) return MMSYSERR_BADDEVICEID
;
1525 if (!MidiOutDev
[wDevID
].bEnabled
) return MIDIERR_NODEVICE
;
1527 if (midiSeqFD
== -1) {
1528 WARN("can't play !\n");
1529 return MIDIERR_NODEVICE
;
1532 lpData
= (LPBYTE
) lpMidiHdr
->lpData
;
1535 return MIDIERR_UNPREPARED
;
1536 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
))
1537 return MIDIERR_UNPREPARED
;
1538 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1539 return MIDIERR_STILLPLAYING
;
1540 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1541 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
1543 /* FIXME: MS doc is not 100% clear. Will lpData only contain system exclusive
1544 * data, or can it also contain raw MIDI data, to be split up and sent to
1546 * If the latest is true, then the following WARNing will fire up
1548 if (lpData
[0] != 0xF0 || lpData
[lpMidiHdr
->dwBufferLength
- 1] != 0xF7) {
1549 WARN("Alledged system exclusive buffer is not correct\n\tPlease report with MIDI file\n");
1552 TRACE("dwBufferLength=%u !\n", lpMidiHdr
->dwBufferLength
);
1553 TRACE(" %02X %02X %02X ... %02X %02X %02X\n",
1554 lpData
[0], lpData
[1], lpData
[2], lpData
[lpMidiHdr
->dwBufferLength
-3],
1555 lpData
[lpMidiHdr
->dwBufferLength
-2], lpData
[lpMidiHdr
->dwBufferLength
-1]);
1557 switch (MidiOutDev
[wDevID
].caps
.wTechnology
) {
1559 /* FIXME: I don't think there is much to do here */
1562 if (lpData
[0] != 0xF0) {
1563 /* Send end of System Exclusive */
1564 SEQ_MIDIOUT(wDevID
- MODM_NumFMSynthDevs
, 0xF0);
1565 WARN("Adding missing 0xF0 marker at the beginning of "
1566 "system exclusive byte stream\n");
1568 for (count
= 0; count
< lpMidiHdr
->dwBufferLength
; count
++) {
1569 SEQ_MIDIOUT(wDevID
- MODM_NumFMSynthDevs
, lpData
[count
]);
1571 if (lpData
[count
- 1] != 0xF7) {
1572 /* Send end of System Exclusive */
1573 SEQ_MIDIOUT(wDevID
- MODM_NumFMSynthDevs
, 0xF7);
1574 WARN("Adding missing 0xF7 marker at the end of "
1575 "system exclusive byte stream\n");
1580 WARN("Technology not supported (yet) %d !\n",
1581 MidiOutDev
[wDevID
].caps
.wTechnology
);
1582 return MMSYSERR_NOTENABLED
;
1585 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1586 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1587 MIDI_NotifyClient(wDevID
, MOM_DONE
, (DWORD_PTR
)lpMidiHdr
, 0L);
1588 return MMSYSERR_NOERROR
;
1591 /**************************************************************************
1592 * modPrepare [internal]
1594 static DWORD
modPrepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1596 TRACE("(%04X, %p, %08X);\n", wDevID
, lpMidiHdr
, dwSize
);
1598 if (midiSeqFD
== -1) {
1599 WARN("can't prepare !\n");
1600 return MMSYSERR_NOTENABLED
;
1603 /* MS doc says that dwFlags must be set to zero, but (kinda funny) MS mciseq drivers
1604 * asks to prepare MIDIHDR which dwFlags != 0.
1605 * So at least check for the inqueue flag
1607 if (dwSize
< offsetof(MIDIHDR
,dwOffset
) || lpMidiHdr
== 0 ||
1608 lpMidiHdr
->lpData
== 0 || (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) != 0) {
1609 WARN("%p %p %08x %d\n", lpMidiHdr
, lpMidiHdr
? lpMidiHdr
->lpData
: NULL
,
1610 lpMidiHdr
? lpMidiHdr
->dwFlags
: 0, dwSize
);
1611 return MMSYSERR_INVALPARAM
;
1614 lpMidiHdr
->lpNext
= 0;
1615 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
1616 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1617 return MMSYSERR_NOERROR
;
1620 /**************************************************************************
1621 * modUnprepare [internal]
1623 static DWORD
modUnprepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1625 TRACE("(%04X, %p, %08X);\n", wDevID
, lpMidiHdr
, dwSize
);
1627 if (midiSeqFD
== -1) {
1628 WARN("can't unprepare !\n");
1629 return MMSYSERR_NOTENABLED
;
1632 if (dwSize
< offsetof(MIDIHDR
,dwOffset
) || lpMidiHdr
== 0)
1633 return MMSYSERR_INVALPARAM
;
1634 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1635 return MIDIERR_STILLPLAYING
;
1636 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
1637 return MMSYSERR_NOERROR
;
1640 /**************************************************************************
1641 * modGetVolume [internal]
1643 static DWORD
modGetVolume(WORD wDevID
, DWORD
* lpdwVolume
)
1645 if (!lpdwVolume
) return MMSYSERR_INVALPARAM
;
1646 if (wDevID
>= MODM_NumDevs
) return MMSYSERR_BADDEVICEID
;
1647 *lpdwVolume
= 0xFFFFFFFF;
1648 return (MidiOutDev
[wDevID
].caps
.dwSupport
& MIDICAPS_VOLUME
) ? 0 : MMSYSERR_NOTSUPPORTED
;
1651 /**************************************************************************
1652 * modReset [internal]
1654 static DWORD
modReset(WORD wDevID
)
1658 TRACE("(%04X);\n", wDevID
);
1660 if (wDevID
>= MODM_NumDevs
) return MMSYSERR_BADDEVICEID
;
1661 if (!MidiOutDev
[wDevID
].bEnabled
) return MIDIERR_NODEVICE
;
1663 /* stop all notes */
1664 /* FIXME: check if 0x78B0 is channel dependent or not. I coded it so that
1665 * it's channel dependent...
1667 for (chn
= 0; chn
< 16; chn
++) {
1668 /* turn off every note */
1669 modData(wDevID
, 0x7800 | MIDI_CTL_CHANGE
| chn
);
1670 /* remove sustain on all channels */
1671 modData(wDevID
, (CTL_SUSTAIN
<< 8) | MIDI_CTL_CHANGE
| chn
);
1673 /* FIXME: the LongData buffers must also be returned to the app */
1674 return MMSYSERR_NOERROR
;
1677 #endif /* HAVE_OSS_MIDI */
1679 /*======================================================================*
1680 * MIDI entry points *
1681 *======================================================================*/
1683 /**************************************************************************
1684 * midMessage (WINEOSS.@)
1686 DWORD WINAPI
OSS_midMessage(UINT wDevID
, UINT wMsg
, DWORD_PTR dwUser
,
1687 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1689 TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1690 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1692 #ifdef HAVE_OSS_MIDI
1694 return OSS_MidiInit();
1696 return OSS_MidiExit();
1699 /* FIXME: Pretend this is supported */
1702 return midOpen(wDevID
, (LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1704 return midClose(wDevID
);
1705 case MIDM_ADDBUFFER
:
1706 return midAddBuffer(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1708 return midPrepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1709 case MIDM_UNPREPARE
:
1710 return midUnprepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1711 case MIDM_GETDEVCAPS
:
1712 return midGetDevCaps(wDevID
, (LPMIDIINCAPSW
)dwParam1
,dwParam2
);
1713 case MIDM_GETNUMDEVS
:
1714 return MIDM_NumDevs
;
1716 return midReset(wDevID
);
1718 return midStart(wDevID
);
1720 return midStop(wDevID
);
1723 case MIDM_GETNUMDEVS
:
1727 TRACE("Unsupported message\n");
1729 return MMSYSERR_NOTSUPPORTED
;
1732 /**************************************************************************
1733 * modMessage (WINEOSS.@)
1735 DWORD WINAPI
OSS_modMessage(UINT wDevID
, UINT wMsg
, DWORD_PTR dwUser
,
1736 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1738 TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1739 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1742 #ifdef HAVE_OSS_MIDI
1744 return OSS_MidiInit();
1746 return OSS_MidiExit();
1749 /* FIXME: Pretend this is supported */
1752 return modOpen(wDevID
, (LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1754 return modClose(wDevID
);
1756 return modData(wDevID
, dwParam1
);
1758 return modLongData(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1760 return modPrepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1761 case MODM_UNPREPARE
:
1762 return modUnprepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1763 case MODM_GETDEVCAPS
:
1764 return modGetDevCaps(wDevID
, (LPMIDIOUTCAPSW
)dwParam1
, dwParam2
);
1765 case MODM_GETNUMDEVS
:
1766 return MODM_NumDevs
;
1767 case MODM_GETVOLUME
:
1768 return modGetVolume(wDevID
, (DWORD
*)dwParam1
);
1769 case MODM_SETVOLUME
:
1772 return modReset(wDevID
);
1775 case MODM_GETNUMDEVS
:
1779 TRACE("Unsupported message\n");
1781 return MMSYSERR_NOTSUPPORTED
;
1784 /*-----------------------------------------------------------------------*/