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
21 #include <sys/ioctl.h>
23 #include "multimedia.h"
25 #include "debugtools.h"
28 DEFAULT_DEBUG_CHANNEL(midi
)
35 LPMIDIOPENDESC midiDesc
;
37 LPMIDIHDR16 lpQueueHdr
;
39 unsigned char incoming
[3];
40 unsigned char incPrev
;
48 LPMIDIOPENDESC midiDesc
;
50 LPMIDIHDR16 lpQueueHdr
;
52 void* lpExtra
; /* according to port type (MIDI, FM...), extra data when needed */
55 static WINE_MIDIIN MidiInDev
[MAX_MIDIINDRV
];
56 static WINE_MIDIOUT MidiOutDev
[MAX_MIDIOUTDRV
];
58 /* this is the total number of MIDI out devices found */
59 static int MODM_NUMDEVS
= 0;
60 /* this is the number of FM synthetizers (index from 0 to
61 NUMFMSYNTHDEVS - 1) */
62 static int MODM_NUMFMSYNTHDEVS
= 0;
63 /* this is the number of Midi ports (index from NUMFMSYNTHDEVS to
64 NUMFMSYNTHDEVS + NUMMIDIDEVS - 1) */
65 static int MODM_NUMMIDIDEVS
= 0;
67 /* this is the total number of MIDI out devices found */
68 static int MIDM_NUMDEVS
= 0;
70 static int midiSeqFD
= -1;
71 static int numOpenMidiSeq
= 0;
72 static UINT midiInTimerID
= 0;
73 static int numStartedMidiIn
= 0;
75 /* this structure holds pointers with information for each MIDI
78 static LPMIDIOUTCAPS16 midiOutDevices
[MAX_MIDIOUTDRV
];
80 /* this structure holds pointers with information for each MIDI
83 static LPMIDIINCAPS16 midiInDevices
[MAX_MIDIINDRV
];
87 * FIXME : all tests on device ID for midXXX and modYYY are made against
88 * MAX_MIDIxxDRV (when they are made) but should be done against the actual
89 * number of midi devices found...
92 /*======================================================================*
93 * Low level MIDI implementation *
94 *======================================================================*/
98 /**************************************************************************
99 * unixToWindowsDeviceType [internal]
101 * return the Windows equivalent to a Unix Device Type
104 static int MIDI_UnixToWindowsDeviceType(int type
)
106 /* MOD_MIDIPORT output port
107 * MOD_SYNTH generic internal synth
108 * MOD_SQSYNTH square wave internal synth
109 * MOD_FMSYNTH FM internal synth
110 * MOD_MAPPER MIDI mapper
113 /* FIXME Is this really the correct equivalence from UNIX to
114 Windows Sound type */
117 case SYNTH_TYPE_FM
: return MOD_FMSYNTH
;
118 case SYNTH_TYPE_SAMPLE
: return MOD_SYNTH
;
119 case SYNTH_TYPE_MIDI
: return MOD_MIDIPORT
;
121 ERR("Cannot determine the type of this midi device. "
122 "Assuming FM Synth\n");
129 /**************************************************************************
130 * MULTIMEDIA_MidiInit [internal]
132 * Initializes the MIDI devices information variables
135 BOOL
MULTIMEDIA_MidiInit(void)
138 int i
, status
, numsynthdevs
= 255, nummididevs
= 255;
139 struct synth_info sinfo
;
140 struct midi_info minfo
;
141 int fd
; /* file descriptor for MIDI_SEQ */
143 TRACE("Initializing the MIDI variables.\n");
145 /* try to open device */
146 /* FIXME: should use function midiOpenSeq() in midi.c */
147 fd
= open(MIDI_SEQ
, O_WRONLY
);
149 TRACE("No sequencer found: unable to open `%s'.\n", MIDI_SEQ
);
153 /* find how many Synth devices are there in the system */
154 status
= ioctl(fd
, SNDCTL_SEQ_NRSYNTHS
, &numsynthdevs
);
157 ERR("ioctl for nr synth failed.\n");
162 if (numsynthdevs
> MAX_MIDIOUTDRV
) {
163 ERR("MAX_MIDIOUTDRV (%d) was enough for the number of devices (%d). "
164 "Some FM devices will not be available.\n",MAX_MIDIOUTDRV
,numsynthdevs
);
165 numsynthdevs
= MAX_MIDIOUTDRV
;
168 for (i
= 0; i
< numsynthdevs
; i
++) {
169 LPMIDIOUTCAPS16 tmplpCaps
;
172 status
= ioctl(fd
, SNDCTL_SYNTH_INFO
, &sinfo
);
174 ERR("ioctl for synth info failed.\n");
179 tmplpCaps
= malloc(sizeof(MIDIOUTCAPS16
));
182 /* We also have the information sinfo.synth_subtype, not used here
185 /* Manufac ID. We do not have access to this with soundcard.h
186 * Does not seem to be a problem, because in mmsystem.h only
187 * Microsoft's ID is listed.
189 tmplpCaps
->wMid
= 0x00FF;
190 tmplpCaps
->wPid
= 0x0001; /* FIXME Product ID */
191 /* Product Version. We simply say "1" */
192 tmplpCaps
->vDriverVersion
= 0x001;
193 strcpy(tmplpCaps
->szPname
, sinfo
.name
);
195 tmplpCaps
->wTechnology
= MIDI_UnixToWindowsDeviceType(sinfo
.synth_type
);
196 tmplpCaps
->wVoices
= sinfo
.nr_voices
;
198 /* FIXME Is it possible to know the maximum
199 * number of simultaneous notes of a soundcard ?
200 * I believe we don't have this information, but
201 * it's probably equal or more than wVoices
203 tmplpCaps
->wNotes
= sinfo
.nr_voices
;
205 /* FIXME Do we have this information?
206 * Assuming the soundcards can handle
207 * MIDICAPS_VOLUME and MIDICAPS_LRVOLUME but
208 * not MIDICAPS_CACHE.
210 tmplpCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
212 midiOutDevices
[i
] = tmplpCaps
;
214 if (sinfo
.capabilities
& SYNTH_CAP_INPUT
) {
215 FIXME("Synthetizer support MIDI in. Not supported yet (please report)\n");
218 TRACE("name='%s', techn=%d voices=%d notes=%d support=%ld\n",
219 tmplpCaps
->szPname
, tmplpCaps
->wTechnology
,
220 tmplpCaps
->wVoices
, tmplpCaps
->wNotes
, tmplpCaps
->dwSupport
);
221 TRACE("OSS info: synth subtype=%d capa=%Xh\n",
222 sinfo
.synth_subtype
, sinfo
.capabilities
);
225 /* find how many MIDI devices are there in the system */
226 status
= ioctl(fd
, SNDCTL_SEQ_NRMIDIS
, &nummididevs
);
228 ERR("ioctl on nr midi failed.\n");
232 /* FIXME: the two restrictions below could be loosen in some cases */
233 if (numsynthdevs
+ nummididevs
> MAX_MIDIOUTDRV
) {
234 ERR("MAX_MIDIOUTDRV was not enough for the number of devices. "
235 "Some MIDI devices will not be available.\n");
236 nummididevs
= MAX_MIDIOUTDRV
- numsynthdevs
;
239 if (nummididevs
> MAX_MIDIINDRV
) {
240 ERR("MAX_MIDIINDRV (%d) was not enough for the number of devices (%d). "
241 "Some MIDI devices will not be available.\n",MAX_MIDIINDRV
,nummididevs
);
242 nummididevs
= MAX_MIDIINDRV
;
245 for (i
= 0; i
< nummididevs
; i
++) {
246 LPMIDIOUTCAPS16 tmplpOutCaps
;
247 LPMIDIINCAPS16 tmplpInCaps
;
250 status
= ioctl(fd
, SNDCTL_MIDI_INFO
, &minfo
);
252 ERR("ioctl on midi info failed.\n");
257 tmplpOutCaps
= malloc(sizeof(MIDIOUTCAPS16
));
260 /* This whole part is somewhat obscure to me. I'll keep trying to dig
261 info about it. If you happen to know, please tell us. The very
262 descritive minfo.dev_type was not used here.
264 /* Manufac ID. We do not have access to this with soundcard.h
265 Does not seem to be a problem, because in mmsystem.h only
266 Microsoft's ID is listed */
267 tmplpOutCaps
->wMid
= 0x00FF;
268 tmplpOutCaps
->wPid
= 0x0001; /* FIXME Product ID */
269 /* Product Version. We simply say "1" */
270 tmplpOutCaps
->vDriverVersion
= 0x001;
271 strcpy(tmplpOutCaps
->szPname
, minfo
.name
);
273 tmplpOutCaps
->wTechnology
= MOD_MIDIPORT
; /* FIXME Is this right? */
274 /* Does it make any difference? */
275 tmplpOutCaps
->wVoices
= 16;
276 /* Does it make any difference? */
277 tmplpOutCaps
->wNotes
= 16;
278 /* FIXME Does it make any difference? */
279 tmplpOutCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
281 midiOutDevices
[numsynthdevs
+ i
] = tmplpOutCaps
;
283 tmplpInCaps
= malloc(sizeof(MIDIOUTCAPS16
));
286 /* This whole part is somewhat obscure to me. I'll keep trying to dig
287 info about it. If you happen to know, please tell us. The very
288 descritive minfo.dev_type was not used here.
290 /* Manufac ID. We do not have access to this with soundcard.h
291 Does not seem to be a problem, because in mmsystem.h only
292 Microsoft's ID is listed */
293 tmplpInCaps
->wMid
= 0x00FF;
294 tmplpInCaps
->wPid
= 0x0001; /* FIXME Product ID */
295 /* Product Version. We simply say "1" */
296 tmplpInCaps
->vDriverVersion
= 0x001;
297 strcpy(tmplpInCaps
->szPname
, minfo
.name
);
299 /* FIXME : could we get better information than that ? */
300 tmplpInCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
302 midiInDevices
[i
] = tmplpInCaps
;
304 TRACE("name='%s' techn=%d voices=%d notes=%d support=%ld\n",
305 tmplpOutCaps
->szPname
, tmplpOutCaps
->wTechnology
, tmplpOutCaps
->wVoices
,
306 tmplpOutCaps
->wNotes
, tmplpOutCaps
->dwSupport
);
307 TRACE("OSS info: midi dev-type=%d, capa=%d\n",
308 minfo
.dev_type
, minfo
.capabilities
);
311 /* windows does not seem to differentiate Synth from MIDI devices */
312 MODM_NUMFMSYNTHDEVS
= numsynthdevs
;
313 MODM_NUMMIDIDEVS
= nummididevs
;
314 MODM_NUMDEVS
= numsynthdevs
+ nummididevs
;
316 MIDM_NUMDEVS
= nummididevs
;
318 /* close file and exit */
320 #endif /* HAVE_OSS_MIDI */
327 /**************************************************************************
328 * MIDI_NotifyClient [internal]
330 static DWORD
MIDI_NotifyClient(UINT16 wDevID
, WORD wMsg
,
331 DWORD dwParam1
, DWORD dwParam2
)
338 TRACE("wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
339 wDevID
, wMsg
, dwParam1
, dwParam2
);
345 if (wDevID
> MAX_MIDIOUTDRV
)
346 return MCIERR_INTERNAL
;
348 dwCallBack
= MidiOutDev
[wDevID
].midiDesc
->dwCallback
;
349 uFlags
= MidiOutDev
[wDevID
].wFlags
;
350 hDev
= MidiOutDev
[wDevID
].midiDesc
->hMidi
;
351 dwInstance
= MidiOutDev
[wDevID
].midiDesc
->dwInstance
;
358 if (wDevID
> MAX_MIDIINDRV
)
359 return MCIERR_INTERNAL
;
361 dwCallBack
= MidiInDev
[wDevID
].midiDesc
->dwCallback
;
362 uFlags
= MidiInDev
[wDevID
].wFlags
;
363 hDev
= MidiInDev
[wDevID
].midiDesc
->hMidi
;
364 dwInstance
= MidiInDev
[wDevID
].midiDesc
->dwInstance
;
367 WARN("Unsupported MSW-MIDI message %u\n", wMsg
);
368 return MCIERR_INTERNAL
;
371 return DriverCallback16(dwCallBack
, uFlags
, hDev
, wMsg
, dwInstance
, dwParam1
, dwParam2
) ?
375 /**************************************************************************
376 * midiOpenSeq [internal]
378 static int midiOpenSeq(void)
380 if (numOpenMidiSeq
== 0) {
381 midiSeqFD
= open(MIDI_SEQ
, O_RDWR
, 0);
382 if (midiSeqFD
== -1) {
383 ERR("can't open '%s' ! (%d)\n", MIDI_SEQ
, errno
);
386 if (fcntl(midiSeqFD
, F_SETFL
, O_NONBLOCK
) < 0) {
387 WARN("can't set sequencer fd to non blocking (%d)\n", errno
);
392 ioctl(midiSeqFD
, SNDCTL_SEQ_RESET
);
398 /**************************************************************************
399 * midiCloseSeq [internal]
401 static int midiCloseSeq(void)
403 if (--numOpenMidiSeq
== 0) {
410 /* FIXME: this is a bad idea, it's even not static... */
413 /* FIXME: this is not reentrant, not static - because of global variable
415 /**************************************************************************
416 * seqbuf_dump [internal]
418 void seqbuf_dump(void)
421 if (write(midiSeqFD
, _seqbuf
, _seqbufptr
) == -1) {
422 WARN("Can't write data to sequencer (%d/%d)!\n",
426 * in any case buffer is lost so that if many errors occur the buffer
433 static void midReceiveChar(WORD wDevID
, unsigned char value
, DWORD dwTime
)
437 TRACE("Adding %02xh to %d[%d]\n", value
, wDevID
, MidiInDev
[wDevID
].incLen
);
439 if (wDevID
>= MAX_MIDIINDRV
) {
443 if (MidiInDev
[wDevID
].state
== 0) {
444 TRACE("input not started, thrown away\n");
448 if (MidiInDev
[wDevID
].state
& 2) { /* system exclusive */
449 LPMIDIHDR16 lpMidiHdr
= MidiInDev
[wDevID
].lpQueueHdr
;
453 LPBYTE lpData
= ((DWORD
)lpMidiHdr
== lpMidiHdr
->reserved
) ?
454 (LPBYTE
)lpMidiHdr
->lpData
: (LPBYTE
)PTR_SEG_TO_LIN(lpMidiHdr
->lpData
);
456 lpData
[lpMidiHdr
->dwBytesRecorded
++] = value
;
457 if (lpMidiHdr
->dwBytesRecorded
== lpMidiHdr
->dwBufferLength
) {
461 if (value
== 0xF7) { /* then end */
462 MidiInDev
[wDevID
].state
&= ~2;
465 if (sbfb
&& lpMidiHdr
!= NULL
) {
466 lpMidiHdr
= MidiInDev
[wDevID
].lpQueueHdr
;
467 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
468 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
469 MidiInDev
[wDevID
].lpQueueHdr
= (LPMIDIHDR16
)lpMidiHdr
->lpNext
;
470 if (MIDI_NotifyClient(wDevID
, MIM_LONGDATA
, (DWORD
)lpMidiHdr
->reserved
, dwTime
) != MMSYSERR_NOERROR
) {
471 WARN("Couldn't notify client\n");
477 #define IS_CMD(_x) (((_x) & 0x80) == 0x80)
478 #define IS_SYS_CMD(_x) (((_x) & 0xF0) == 0xF0)
480 if (!IS_CMD(value
) && MidiInDev
[wDevID
].incLen
== 0) { /* try to reuse old cmd */
481 if (IS_CMD(MidiInDev
[wDevID
].incPrev
) && !IS_SYS_CMD(MidiInDev
[wDevID
].incPrev
)) {
482 MidiInDev
[wDevID
].incoming
[0] = MidiInDev
[wDevID
].incPrev
;
483 MidiInDev
[wDevID
].incLen
= 1;
484 TRACE("Reusing old command %02xh\n", MidiInDev
[wDevID
].incPrev
);
486 FIXME("error for midi-in, should generate MIM_ERROR notification:"
487 " prev=%02Xh, incLen=%02Xh\n",
488 MidiInDev
[wDevID
].incPrev
, MidiInDev
[wDevID
].incLen
);
492 MidiInDev
[wDevID
].incoming
[(int)(MidiInDev
[wDevID
].incLen
++)] = value
;
493 if (MidiInDev
[wDevID
].incLen
== 1 && !IS_SYS_CMD(MidiInDev
[wDevID
].incoming
[0])) {
494 /* store new cmd, just in case */
495 MidiInDev
[wDevID
].incPrev
= MidiInDev
[wDevID
].incoming
[0];
499 #undef IS_SYS_CMD(_x)
501 switch (MidiInDev
[wDevID
].incoming
[0] & 0xF0) {
504 case MIDI_KEY_PRESSURE
:
505 case MIDI_CTL_CHANGE
:
506 case MIDI_PITCH_BEND
:
507 if (MidiInDev
[wDevID
].incLen
== 3) {
508 toSend
= (MidiInDev
[wDevID
].incoming
[2] << 16) |
509 (MidiInDev
[wDevID
].incoming
[1] << 8) |
510 (MidiInDev
[wDevID
].incoming
[0] << 0);
513 case MIDI_PGM_CHANGE
:
514 case MIDI_CHN_PRESSURE
:
515 if (MidiInDev
[wDevID
].incLen
== 2) {
516 toSend
= (MidiInDev
[wDevID
].incoming
[1] << 8) |
517 (MidiInDev
[wDevID
].incoming
[0] << 0);
520 case MIDI_SYSTEM_PREFIX
:
521 if (MidiInDev
[wDevID
].incoming
[0] == 0xF0) {
522 MidiInDev
[wDevID
].state
|= 2;
523 MidiInDev
[wDevID
].incLen
= 0;
525 if (MidiInDev
[wDevID
].incLen
== 1) {
526 toSend
= (MidiInDev
[wDevID
].incoming
[0] << 0);
531 WARN("This shouldn't happen (%02X)\n", MidiInDev
[wDevID
].incoming
[0]);
534 TRACE("Sending event %08lx\n", toSend
);
535 MidiInDev
[wDevID
].incLen
= 0;
536 dwTime
-= MidiInDev
[wDevID
].startTime
;
537 if (MIDI_NotifyClient(wDevID
, MIM_DATA
, toSend
, dwTime
) != MMSYSERR_NOERROR
) {
538 WARN("Couldn't notify client\n");
543 static VOID WINAPI
midTimeCallback(HWND hwnd
, UINT msg
, UINT id
, DWORD dwTime
)
545 unsigned char buffer
[256];
548 TRACE("(%04X, %d, %d, %lu)\n", hwnd
, msg
, id
, dwTime
);
550 len
= read(midiSeqFD
, buffer
, sizeof(buffer
));
552 if ((len
% 4) != 0) {
553 WARN("bad length %d (%d)\n", len
, errno
);
557 for (idx
= 0; idx
< len
; ) {
558 if (buffer
[idx
] & 0x80) {
560 "reading<8> %02x %02x %02x %02x %02x %02x %02x %02x\n",
561 buffer
[idx
+ 0], buffer
[idx
+ 1],
562 buffer
[idx
+ 2], buffer
[idx
+ 3],
563 buffer
[idx
+ 4], buffer
[idx
+ 5],
564 buffer
[idx
+ 6], buffer
[idx
+ 7]);
567 switch (buffer
[idx
+ 0]) {
572 midReceiveChar(buffer
[idx
+ 2], buffer
[idx
+ 1], dwTime
);
575 TRACE("Unsupported event %d\n", buffer
[idx
+ 0]);
583 /**************************************************************************
584 * midGetDevCaps [internal]
586 static DWORD
midGetDevCaps(WORD wDevID
, LPMIDIINCAPS16 lpCaps
, DWORD dwSize
)
588 LPMIDIINCAPS16 tmplpCaps
;
590 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
592 if (wDevID
>= MIDM_NUMDEVS
) {
593 return MMSYSERR_BADDEVICEID
;
595 if (lpCaps
== NULL
) {
596 return MMSYSERR_INVALPARAM
;
599 tmplpCaps
= midiInDevices
[wDevID
];
600 lpCaps
->wMid
= tmplpCaps
->wMid
;
601 lpCaps
->wPid
= tmplpCaps
->wPid
;
602 lpCaps
->vDriverVersion
= tmplpCaps
->vDriverVersion
;
603 strcpy(lpCaps
->szPname
, tmplpCaps
->szPname
);
604 if (dwSize
== sizeof(MIDIINCAPS16
)) {
605 /* we should run win 95, so make use of dwSupport */
606 lpCaps
->dwSupport
= tmplpCaps
->dwSupport
;
607 } else if (dwSize
!= sizeof(MIDIINCAPS16
) - sizeof(DWORD
)) {
608 TRACE("bad size for lpCaps\n");
609 return MMSYSERR_INVALPARAM
;
612 return MMSYSERR_NOERROR
;
615 /**************************************************************************
618 static DWORD
midOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
620 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
622 if (lpDesc
== NULL
) {
623 WARN("Invalid Parameter !\n");
624 return MMSYSERR_INVALPARAM
;
627 * how to check that content of lpDesc is correct ?
629 if (wDevID
>= MAX_MIDIINDRV
) {
630 WARN("wDevID too large (%u) !\n", wDevID
);
631 return MMSYSERR_BADDEVICEID
;
633 if (MidiInDev
[wDevID
].midiDesc
!= 0) {
634 WARN("device already open !\n");
635 return MMSYSERR_ALLOCATED
;
637 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
638 FIXME("No support for MIDI_IO_STATUS in dwFlags\n");
639 return MMSYSERR_INVALFLAG
;
642 if (midiOpenSeq() < 0) {
643 return MMSYSERR_ERROR
;
646 if (numStartedMidiIn
++ == 0) {
647 midiInTimerID
= SetTimer(0, 0, 250, midTimeCallback
);
648 if (!midiInTimerID
) {
649 numStartedMidiIn
= 0;
650 WARN("Couldn't start timer for midi-in\n");
652 return MMSYSERR_ERROR
;
654 TRACE("Starting timer (%u) for midi-in\n", midiInTimerID
);
657 MidiInDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
659 MidiInDev
[wDevID
].lpQueueHdr
= NULL
;
660 MidiInDev
[wDevID
].dwTotalPlayed
= 0;
661 MidiInDev
[wDevID
].bufsize
= 0x3FFF;
662 MidiInDev
[wDevID
].midiDesc
= lpDesc
;
663 MidiInDev
[wDevID
].state
= 0;
664 MidiInDev
[wDevID
].incLen
= 0;
665 MidiInDev
[wDevID
].startTime
= 0;
667 if (MIDI_NotifyClient(wDevID
, MIM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
668 WARN("can't notify client !\n");
669 return MMSYSERR_INVALPARAM
;
671 return MMSYSERR_NOERROR
;
674 /**************************************************************************
675 * midClose [internal]
677 static DWORD
midClose(WORD wDevID
)
679 int ret
= MMSYSERR_NOERROR
;
681 TRACE("(%04X);\n", wDevID
);
683 if (wDevID
>= MAX_MIDIINDRV
) {
684 WARN("wDevID too bif (%u) !\n", wDevID
);
685 return MMSYSERR_BADDEVICEID
;
687 if (MidiInDev
[wDevID
].midiDesc
== 0) {
688 WARN("device not opened !\n");
689 return MMSYSERR_ERROR
;
691 if (MidiInDev
[wDevID
].lpQueueHdr
!= 0) {
692 return MIDIERR_STILLPLAYING
;
695 if (midiSeqFD
== -1) {
697 return MMSYSERR_ERROR
;
699 if (--numStartedMidiIn
== 0) {
700 TRACE("Stopping timer for midi-in\n");
701 if (!KillTimer(0, midiInTimerID
)) {
702 WARN("Couldn't stop timer for midi-in\n");
708 MidiInDev
[wDevID
].bufsize
= 0;
709 if (MIDI_NotifyClient(wDevID
, MIM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
710 WARN("can't notify client !\n");
711 ret
= MMSYSERR_INVALPARAM
;
713 MidiInDev
[wDevID
].midiDesc
= 0;
717 /**************************************************************************
718 * midAddBuffer [internal]
720 static DWORD
midAddBuffer(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
722 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
724 if (lpMidiHdr
== NULL
) return MMSYSERR_INVALPARAM
;
725 if (sizeof(MIDIHDR16
) > dwSize
) return MMSYSERR_INVALPARAM
;
726 if (lpMidiHdr
->dwBufferLength
== 0) return MMSYSERR_INVALPARAM
;
727 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
728 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
730 if (MidiInDev
[wDevID
].lpQueueHdr
== 0) {
731 MidiInDev
[wDevID
].lpQueueHdr
= lpMidiHdr
;
735 for (ptr
= MidiInDev
[wDevID
].lpQueueHdr
;
737 ptr
= (LPMIDIHDR16
)ptr
->lpNext
);
738 ptr
->lpNext
= (struct midihdr_tag
*)lpMidiHdr
;
740 return MMSYSERR_NOERROR
;
743 /**************************************************************************
744 * midPrepare [internal]
746 static DWORD
midPrepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
748 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
750 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
751 lpMidiHdr
->lpData
== 0 || lpMidiHdr
->dwFlags
!= 0 ||
752 lpMidiHdr
->dwBufferLength
>= 0x10000ul
)
753 return MMSYSERR_INVALPARAM
;
755 lpMidiHdr
->lpNext
= 0;
756 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
757 lpMidiHdr
->dwBytesRecorded
= 0;
759 return MMSYSERR_NOERROR
;
762 /**************************************************************************
763 * midUnprepare [internal]
765 static DWORD
midUnprepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
767 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
769 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
770 lpMidiHdr
->lpData
== 0 || lpMidiHdr
->dwBufferLength
>= 0x10000ul
)
771 return MMSYSERR_INVALPARAM
;
773 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
774 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
776 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
778 return MMSYSERR_NOERROR
;
781 /**************************************************************************
782 * midReset [internal]
784 static DWORD
midReset(WORD wDevID
)
786 DWORD dwTime
= GetTickCount();
788 TRACE("(%04X);\n", wDevID
);
790 while (MidiInDev
[wDevID
].lpQueueHdr
) {
791 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
&= ~MHDR_INQUEUE
;
792 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
|= MHDR_DONE
;
793 /* FIXME: when called from 16 bit, lpQueueHdr needs to be a segmented ptr */
794 if (MIDI_NotifyClient(wDevID
, MIM_LONGDATA
,
795 (DWORD
)MidiInDev
[wDevID
].lpQueueHdr
, dwTime
) != MMSYSERR_NOERROR
) {
796 WARN("Couldn't notify client\n");
798 MidiInDev
[wDevID
].lpQueueHdr
= (LPMIDIHDR16
)MidiInDev
[wDevID
].lpQueueHdr
->lpNext
;
801 return MMSYSERR_NOERROR
;
805 /**************************************************************************
806 * midStart [internal]
808 static DWORD
midStart(WORD wDevID
)
810 TRACE("(%04X);\n", wDevID
);
812 /* FIXME : should test value of wDevID */
814 MidiInDev
[wDevID
].state
= 1;
815 MidiInDev
[wDevID
].startTime
= GetTickCount();
816 return MMSYSERR_NOERROR
;
819 /**************************************************************************
822 static DWORD
midStop(WORD wDevID
)
824 TRACE("(%04X);\n", wDevID
);
826 /* FIXME : should test value of wDevID */
827 MidiInDev
[wDevID
].state
= 0;
828 return MMSYSERR_NOERROR
;
831 /*-----------------------------------------------------------------------*/
833 typedef struct sVoice
{
834 int note
; /* 0 means not used */
836 unsigned cntMark
: 30,
839 #define sVS_PLAYING 1
840 #define sVS_SUSTAINED 2
843 typedef struct sChannel
{
849 int bank
; /* CTL_BANK_SELECT */
850 int volume
; /* CTL_MAIN_VOLUME */
851 int balance
; /* CTL_BALANCE */
852 int expression
; /* CTL_EXPRESSION */
853 int sustain
; /* CTL_SUSTAIN */
855 unsigned char nrgPmtMSB
; /* Non register Parameters */
856 unsigned char nrgPmtLSB
;
857 unsigned char regPmtMSB
; /* Non register Parameters */
858 unsigned char regPmtLSB
;
861 typedef struct sFMextra
{
864 sChannel channel
[16]; /* MIDI has only 16 channels */
865 sVoice voice
[1]; /* dyn allocated according to sound card */
866 /* do not append fields below voice[1] since the size of this structure
867 * depends on the number of available voices on the FM synth...
871 extern unsigned char midiFMInstrumentPatches
[16 * 128];
872 extern unsigned char midiFMDrumsPatches
[16 * 128];
874 /**************************************************************************
875 * modFMLoad [internal]
877 static int modFMLoad(int dev
)
880 struct sbi_instrument sbi
;
885 memset(sbi
.operators
+ 16, 0, 16);
886 for (i
= 0; i
< 128; i
++) {
888 memcpy(sbi
.operators
, midiFMInstrumentPatches
+ i
* 16, 16);
890 if (write(midiSeqFD
, (char*)&sbi
, sizeof(sbi
)) == -1) {
891 WARN("Couldn't write patch for instrument %d (%d)!\n", sbi
.channel
, errno
);
895 for (i
= 0; i
< 128; i
++) {
896 sbi
.channel
= 128 + i
;
897 memcpy(sbi
.operators
, midiFMDrumsPatches
+ i
* 16, 16);
899 if (write(midiSeqFD
, (char*)&sbi
, sizeof(sbi
)) == -1) {
900 WARN("Couldn't write patch for drum %d (%d)!\n", sbi
.channel
, errno
);
907 /**************************************************************************
908 * modFMReset [internal]
910 static void modFMReset(WORD wDevID
)
912 sFMextra
* extra
= (sFMextra
*)MidiOutDev
[wDevID
].lpExtra
;
913 sVoice
* voice
= extra
->voice
;
914 sChannel
* channel
= extra
->channel
;
917 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
918 if (voice
[i
].status
!= sVS_UNUSED
) {
919 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
921 SEQ_KEY_PRESSURE(wDevID
, i
, 127, 0);
922 SEQ_CONTROL(wDevID
, i
, SEQ_VOLMODE
, VOL_METHOD_LINEAR
);
924 voice
[i
].channel
= -1;
925 voice
[i
].cntMark
= 0;
926 voice
[i
].status
= sVS_UNUSED
;
928 for (i
= 0; i
< 16; i
++) {
929 channel
[i
].program
= 0;
930 channel
[i
].bender
= 8192;
931 channel
[i
].benderRange
= 2;
933 channel
[i
].volume
= 127;
934 channel
[i
].balance
= 64;
935 channel
[i
].expression
= 0;
936 channel
[i
].sustain
= 0;
939 extra
->drumSetMask
= 1 << 9; /* channel 10 is normally drums, sometimes 16 also */
943 #define IS_DRUM_CHANNEL(_xtra, _chn) ((_xtra)->drumSetMask & (1 << (_chn)))
945 /**************************************************************************
946 * modGetDevCaps [internal]
948 static DWORD
modGetDevCaps(WORD wDevID
, LPMIDIOUTCAPS16 lpCaps
,
951 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
952 if (wDevID
== (WORD
) MIDI_MAPPER
) {
953 lpCaps
->wMid
= 0x00FF; /* Manufac ID */
954 lpCaps
->wPid
= 0x0001; /* Product ID */
955 lpCaps
->vDriverVersion
= 0x001; /* Product Version */
956 strcpy(lpCaps
->szPname
, "MIDI Mapper (not functional yet)");
957 /* FIXME Does it make any difference ? */
958 lpCaps
->wTechnology
= MOD_FMSYNTH
;
959 lpCaps
->wVoices
= 14; /* FIXME */
960 lpCaps
->wNotes
= 14; /* FIXME */
961 /* FIXME Does it make any difference ? */
962 lpCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
964 LPMIDIOUTCAPS16 tmplpCaps
;
966 if (wDevID
>= MODM_NUMDEVS
) {
967 TRACE("MAX_MIDIOUTDRV reached !\n");
968 return MMSYSERR_BADDEVICEID
;
970 /* FIXME There is a way to do it so easily, but I'm too
971 * sleepy to think and I want to test
974 tmplpCaps
= midiOutDevices
[wDevID
];
975 lpCaps
->wMid
= tmplpCaps
->wMid
;
976 lpCaps
->wPid
= tmplpCaps
->wPid
;
977 lpCaps
->vDriverVersion
= tmplpCaps
->vDriverVersion
;
978 strcpy(lpCaps
->szPname
, tmplpCaps
->szPname
);
979 lpCaps
->wTechnology
= tmplpCaps
->wTechnology
;
980 lpCaps
->wVoices
= tmplpCaps
->wVoices
;
981 lpCaps
->wNotes
= tmplpCaps
->wNotes
;
982 lpCaps
->dwSupport
= tmplpCaps
->dwSupport
;
984 return MMSYSERR_NOERROR
;
987 /**************************************************************************
990 static DWORD
modOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
992 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
993 if (lpDesc
== NULL
) {
994 WARN("Invalid Parameter !\n");
995 return MMSYSERR_INVALPARAM
;
997 if (wDevID
>= MAX_MIDIOUTDRV
) {
998 TRACE("MAX_MIDIOUTDRV reached !\n");
999 return MMSYSERR_BADDEVICEID
;
1001 if (MidiOutDev
[wDevID
].midiDesc
!= 0) {
1002 WARN("device already open !\n");
1003 return MMSYSERR_ALLOCATED
;
1005 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
1006 WARN("bad dwFlags\n");
1007 return MMSYSERR_INVALFLAG
;
1009 if (midiOutDevices
[wDevID
] == NULL
) {
1010 TRACE("un-allocated wDevID\n");
1011 return MMSYSERR_BADDEVICEID
;
1014 MidiOutDev
[wDevID
].lpExtra
= 0;
1016 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1019 void* extra
= malloc(sizeof(struct sFMextra
) +
1020 sizeof(struct sVoice
) * (midiOutDevices
[wDevID
]->wVoices
- 1));
1023 WARN("can't alloc extra data !\n");
1024 return MMSYSERR_NOMEM
;
1026 MidiOutDev
[wDevID
].lpExtra
= extra
;
1027 if (midiOpenSeq() < 0) {
1028 MidiOutDev
[wDevID
].lpExtra
= 0;
1030 return MMSYSERR_ERROR
;
1032 if (modFMLoad(wDevID
) < 0) {
1034 MidiOutDev
[wDevID
].lpExtra
= 0;
1036 return MMSYSERR_ERROR
;
1042 if (midiOpenSeq() < 0) {
1043 return MMSYSERR_ALLOCATED
;
1047 WARN("Technology not supported (yet) %d !\n",
1048 midiOutDevices
[wDevID
]->wTechnology
);
1049 return MMSYSERR_NOTENABLED
;
1052 MidiOutDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
1054 MidiOutDev
[wDevID
].lpQueueHdr
= NULL
;
1055 MidiOutDev
[wDevID
].dwTotalPlayed
= 0;
1056 MidiOutDev
[wDevID
].bufsize
= 0x3FFF;
1057 MidiOutDev
[wDevID
].midiDesc
= lpDesc
;
1059 if (MIDI_NotifyClient(wDevID
, MOM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
1060 WARN("can't notify client !\n");
1061 return MMSYSERR_INVALPARAM
;
1063 TRACE("Succesful !\n");
1064 return MMSYSERR_NOERROR
;
1068 /**************************************************************************
1069 * modClose [internal]
1071 static DWORD
modClose(WORD wDevID
)
1073 int ret
= MMSYSERR_NOERROR
;
1075 TRACE("(%04X);\n", wDevID
);
1077 if (MidiOutDev
[wDevID
].midiDesc
== 0) {
1078 WARN("device not opened !\n");
1079 return MMSYSERR_ERROR
;
1081 /* FIXME: should test that no pending buffer is still in the queue for
1084 if (midiSeqFD
== -1) {
1085 WARN("can't close !\n");
1086 return MMSYSERR_ERROR
;
1089 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1095 WARN("Technology not supported (yet) %d !\n",
1096 midiOutDevices
[wDevID
]->wTechnology
);
1097 return MMSYSERR_NOTENABLED
;
1100 if (MidiOutDev
[wDevID
].lpExtra
!= 0) {
1101 free(MidiOutDev
[wDevID
].lpExtra
);
1102 MidiOutDev
[wDevID
].lpExtra
= 0;
1105 MidiOutDev
[wDevID
].bufsize
= 0;
1106 if (MIDI_NotifyClient(wDevID
, MOM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
1107 WARN("can't notify client !\n");
1108 ret
= MMSYSERR_INVALPARAM
;
1110 MidiOutDev
[wDevID
].midiDesc
= 0;
1114 /**************************************************************************
1115 * modData [internal]
1117 static DWORD
modData(WORD wDevID
, DWORD dwParam
)
1119 WORD evt
= LOBYTE(LOWORD(dwParam
));
1120 WORD d1
= HIBYTE(LOWORD(dwParam
));
1121 WORD d2
= LOBYTE(HIWORD(dwParam
));
1123 TRACE("(%04X, %08lX);\n", wDevID
, dwParam
);
1125 if (midiSeqFD
== -1) {
1126 WARN("can't play !\n");
1127 return MIDIERR_NODEVICE
;
1129 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1132 * - chorus depth controller is not used
1135 sFMextra
* extra
= (sFMextra
*)MidiOutDev
[wDevID
].lpExtra
;
1136 sVoice
* voice
= extra
->voice
;
1137 sChannel
* channel
= extra
->channel
;
1138 int chn
= (evt
& 0x0F);
1141 switch (evt
& 0xF0) {
1143 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1144 /* don't stop sustained notes */
1145 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1146 voice
[i
].status
= sVS_UNUSED
;
1147 SEQ_STOP_NOTE(wDevID
, i
, d1
, d2
);
1152 if (d2
== 0) { /* note off if velocity == 0 */
1153 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1154 /* don't stop sustained notes */
1155 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1156 voice
[i
].status
= sVS_UNUSED
;
1157 SEQ_STOP_NOTE(wDevID
, i
, d1
, 64);
1162 /* finding out in this order :
1164 * - if replaying the same note on the same channel
1165 * - the older voice (LRU)
1167 for (i
= nv
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1168 if (voice
[i
].status
== sVS_UNUSED
||
1169 (voice
[i
].note
== d1
&& voice
[i
].channel
== chn
)) {
1173 if (voice
[i
].cntMark
< voice
[0].cntMark
) {
1178 "playing on voice=%d, pgm=%d, pan=0x%02X, vol=0x%02X, "
1179 "bender=0x%02X, note=0x%02X, vel=0x%02X\n",
1180 nv
, channel
[chn
].program
,
1181 channel
[chn
].balance
,
1182 channel
[chn
].volume
,
1183 channel
[chn
].bender
, d1
, d2
);
1185 SEQ_SET_PATCH(wDevID
, nv
, IS_DRUM_CHANNEL(extra
, chn
) ?
1186 (128 + d1
) : channel
[chn
].program
);
1187 SEQ_BENDER_RANGE(wDevID
, nv
, channel
[chn
].benderRange
* 100);
1188 SEQ_BENDER(wDevID
, nv
, channel
[chn
].bender
);
1189 SEQ_CONTROL(wDevID
, nv
, CTL_PAN
, channel
[chn
].balance
);
1190 SEQ_CONTROL(wDevID
, nv
, CTL_EXPRESSION
, channel
[chn
].expression
);
1192 /* FIXME: does not really seem to work on my SB card and
1193 * screws everything up... so lay it down
1195 SEQ_CONTROL(wDevID
, nv
, CTL_MAIN_VOLUME
, channel
[chn
].volume
);
1197 SEQ_START_NOTE(wDevID
, nv
, d1
, d2
);
1198 voice
[nv
].status
= channel
[chn
].sustain
? sVS_SUSTAINED
: sVS_PLAYING
;
1199 voice
[nv
].note
= d1
;
1200 voice
[nv
].channel
= chn
;
1201 voice
[nv
].cntMark
= extra
->counter
++;
1203 case MIDI_KEY_PRESSURE
:
1204 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1205 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1206 SEQ_KEY_PRESSURE(wDevID
, i
, d1
, d2
);
1210 case MIDI_CTL_CHANGE
:
1212 case CTL_BANK_SELECT
: channel
[chn
].bank
= d2
; break;
1213 case CTL_MAIN_VOLUME
: channel
[chn
].volume
= d2
; break;
1214 case CTL_PAN
: channel
[chn
].balance
= d2
; break;
1215 case CTL_EXPRESSION
: channel
[chn
].expression
= d2
; break;
1216 case CTL_SUSTAIN
: channel
[chn
].sustain
= d2
;
1218 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1219 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1220 voice
[i
].status
= sVS_SUSTAINED
;
1224 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1225 if (voice
[i
].status
== sVS_SUSTAINED
&& voice
[i
].channel
== chn
) {
1226 voice
[i
].status
= sVS_UNUSED
;
1227 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1232 case CTL_NONREG_PARM_NUM_LSB
: channel
[chn
].nrgPmtLSB
= d2
; break;
1233 case CTL_NONREG_PARM_NUM_MSB
: channel
[chn
].nrgPmtMSB
= d2
; break;
1234 case CTL_REGIST_PARM_NUM_LSB
: channel
[chn
].regPmtLSB
= d2
; break;
1235 case CTL_REGIST_PARM_NUM_MSB
: channel
[chn
].regPmtMSB
= d2
; break;
1237 case CTL_DATA_ENTRY
:
1238 switch ((channel
[chn
].regPmtMSB
<< 8) | channel
[chn
].regPmtLSB
) {
1240 if (channel
[chn
].benderRange
!= d2
) {
1241 channel
[chn
].benderRange
= d2
;
1242 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1243 if (voice
[i
].channel
== chn
) {
1244 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1251 channel
[chn
].benderRange
= 2;
1252 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1253 if (voice
[i
].channel
== chn
) {
1254 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1259 TRACE("Data entry: regPmt=0x%02x%02x, nrgPmt=0x%02x%02x with %x\n",
1260 channel
[chn
].regPmtMSB
, channel
[chn
].regPmtLSB
,
1261 channel
[chn
].nrgPmtMSB
, channel
[chn
].nrgPmtLSB
,
1267 case 0x78: /* all sounds off */
1268 /* FIXME: I don't know if I have to take care of the channel
1269 * for this control ?
1271 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1272 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1273 voice
[i
].status
= sVS_UNUSED
;
1274 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 0);
1278 case 0x7B: /* all notes off */
1279 /* FIXME: I don't know if I have to take care of the channel
1280 * for this control ?
1282 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1283 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1284 voice
[i
].status
= sVS_UNUSED
;
1285 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 0);
1290 TRACE("Dropping MIDI control event 0x%02x(%02x) on channel %d\n",
1295 case MIDI_PGM_CHANGE
:
1296 channel
[chn
].program
= d1
;
1298 case MIDI_CHN_PRESSURE
:
1299 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1300 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1301 SEQ_KEY_PRESSURE(wDevID
, i
, voice
[i
].note
, d1
);
1305 case MIDI_PITCH_BEND
:
1306 channel
[chn
].bender
= (d2
<< 7) + d1
;
1307 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1308 if (voice
[i
].channel
== chn
) {
1309 SEQ_BENDER(wDevID
, i
, channel
[chn
].bender
);
1313 case MIDI_SYSTEM_PREFIX
:
1314 switch (evt
& 0x0F) {
1315 case 0x0F: /* Reset */
1319 WARN("Unsupported (yet) system event %02x\n", evt
& 0x0F);
1323 WARN("Internal error, shouldn't happen (event=%08x)\n", evt
& 0xF0);
1324 return MMSYSERR_NOTENABLED
;
1330 int dev
= wDevID
- MODM_NUMFMSYNTHDEVS
;
1332 WARN("Internal error on devID (%u) !\n", wDevID
);
1333 return MIDIERR_NODEVICE
;
1336 switch (evt
& 0xF0) {
1339 case MIDI_KEY_PRESSURE
:
1340 case MIDI_CTL_CHANGE
:
1341 case MIDI_PITCH_BEND
:
1342 SEQ_MIDIOUT(dev
, evt
);
1343 SEQ_MIDIOUT(dev
, d1
);
1344 SEQ_MIDIOUT(dev
, d2
);
1346 case MIDI_PGM_CHANGE
:
1347 case MIDI_CHN_PRESSURE
:
1348 SEQ_MIDIOUT(dev
, evt
);
1349 SEQ_MIDIOUT(dev
, d1
);
1351 case MIDI_SYSTEM_PREFIX
:
1352 switch (evt
& 0x0F) {
1353 case 0x00: /* System Exclusive, don't do it on modData,
1354 * should require modLongData*/
1355 case 0x01: /* Undefined */
1356 case 0x04: /* Undefined. */
1357 case 0x05: /* Undefined. */
1358 case 0x07: /* End of Exclusive. */
1359 case 0x09: /* Undefined. */
1360 case 0x0D: /* Undefined. */
1362 case 0x06: /* Tune Request */
1363 case 0x08: /* Timing Clock. */
1364 case 0x0A: /* Start. */
1365 case 0x0B: /* Continue */
1366 case 0x0C: /* Stop */
1367 case 0x0E: /* Active Sensing. */
1368 SEQ_MIDIOUT(dev
, evt
);
1370 case 0x0F: /* Reset */
1371 /* SEQ_MIDIOUT(dev, evt);
1372 this other way may be better */
1373 SEQ_MIDIOUT(dev
, MIDI_SYSTEM_PREFIX
);
1374 SEQ_MIDIOUT(dev
, 0x7e);
1375 SEQ_MIDIOUT(dev
, 0x7f);
1376 SEQ_MIDIOUT(dev
, 0x09);
1377 SEQ_MIDIOUT(dev
, 0x01);
1378 SEQ_MIDIOUT(dev
, 0xf7);
1380 case 0x03: /* Song Select. */
1381 SEQ_MIDIOUT(dev
, evt
);
1382 SEQ_MIDIOUT(dev
, d1
);
1383 case 0x02: /* Song Position Pointer. */
1384 SEQ_MIDIOUT(dev
, evt
);
1385 SEQ_MIDIOUT(dev
, d1
);
1386 SEQ_MIDIOUT(dev
, d2
);
1393 WARN("Technology not supported (yet) %d !\n",
1394 midiOutDevices
[wDevID
]->wTechnology
);
1395 return MMSYSERR_NOTENABLED
;
1400 return MMSYSERR_NOERROR
;
1403 /**************************************************************************
1404 * modLongData [internal]
1406 static DWORD
modLongData(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1411 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1413 if (midiSeqFD
== -1) {
1414 WARN("can't play !\n");
1415 return MIDIERR_NODEVICE
;
1418 lpData
= ((DWORD
)lpMidiHdr
== lpMidiHdr
->reserved
) ?
1419 (LPBYTE
)lpMidiHdr
->lpData
: (LPBYTE
)PTR_SEG_TO_LIN(lpMidiHdr
->lpData
);
1422 return MIDIERR_UNPREPARED
;
1423 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
))
1424 return MIDIERR_UNPREPARED
;
1425 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1426 return MIDIERR_STILLPLAYING
;
1427 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1428 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
1430 /* FIXME: MS doc is not 100% clear. Will lpData only contain system exclusive
1431 * data, or can it also contain raw MIDI data, to be split up and sent to
1433 * If the latest is true, then the following WARNing will fire up
1435 if (lpData
[0] != 0xF0 || lpData
[lpMidiHdr
->dwBufferLength
- 1] != 0xF7) {
1436 WARN("Alledged system exclusive buffer is not correct\n\tPlease report with MIDI file\n");
1439 TRACE("dwBufferLength=%lu !\n", lpMidiHdr
->dwBufferLength
);
1440 TRACE(" %02X %02X %02X ... %02X %02X %02X\n",
1441 lpData
[0], lpData
[1], lpData
[2], lpData
[lpMidiHdr
->dwBufferLength
-3],
1442 lpData
[lpMidiHdr
->dwBufferLength
-2], lpData
[lpMidiHdr
->dwBufferLength
-1]);
1444 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1446 /* FIXME: I don't think there is much to do here */
1449 if (lpData
[0] != 0xF0) {
1450 /* Send end of System Exclusive */
1451 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, 0xF0);
1452 WARN("Adding missing 0xF0 marker at the begining of "
1453 "system exclusive byte stream\n");
1455 for (count
= 0; count
< lpMidiHdr
->dwBytesRecorded
; count
++) {
1456 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, lpData
[count
]);
1458 if (lpData
[count
- 1] != 0xF7) {
1459 /* Send end of System Exclusive */
1460 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, 0xF7);
1461 WARN("Adding missing 0xF7 marker at the end of "
1462 "system exclusive byte stream\n");
1467 WARN("Technology not supported (yet) %d !\n",
1468 midiOutDevices
[wDevID
]->wTechnology
);
1469 return MMSYSERR_NOTENABLED
;
1472 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1473 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1474 if (MIDI_NotifyClient(wDevID
, MOM_DONE
, lpMidiHdr
->reserved
, 0L) != MMSYSERR_NOERROR
) {
1475 WARN("can't notify client !\n");
1476 return MMSYSERR_INVALPARAM
;
1478 return MMSYSERR_NOERROR
;
1481 /**************************************************************************
1482 * modPrepare [internal]
1484 static DWORD
modPrepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1486 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1488 if (midiSeqFD
== -1) {
1489 WARN("can't prepare !\n");
1490 return MMSYSERR_NOTENABLED
;
1493 /* MS doc says taht dwFlags must be set to zero, but (kinda funny) MS mciseq drivers
1494 * asks to prepare MIDIHDR which dwFlags != 0.
1495 * So at least check for the inqueue flag
1497 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
1498 lpMidiHdr
->lpData
== 0 || (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) != 0 ||
1499 lpMidiHdr
->dwBufferLength
>= 0x10000ul
) {
1500 WARN("%p %p %08lx %d/%ld\n", lpMidiHdr
, lpMidiHdr
->lpData
,
1501 lpMidiHdr
->dwFlags
, sizeof(MIDIHDR16
), dwSize
);
1502 return MMSYSERR_INVALPARAM
;
1505 lpMidiHdr
->lpNext
= 0;
1506 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
1507 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1508 return MMSYSERR_NOERROR
;
1511 /**************************************************************************
1512 * modUnprepare [internal]
1514 static DWORD
modUnprepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1516 TRACE("(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1518 if (midiSeqFD
== -1) {
1519 WARN("can't unprepare !\n");
1520 return MMSYSERR_NOTENABLED
;
1523 if (dwSize
< sizeof(MIDIHDR16
) || lpMidiHdr
== 0)
1524 return MMSYSERR_INVALPARAM
;
1525 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1526 return MIDIERR_STILLPLAYING
;
1527 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
1528 return MMSYSERR_NOERROR
;
1531 /**************************************************************************
1532 * modReset [internal]
1534 static DWORD
modReset(WORD wDevID
)
1536 TRACE("(%04X);\n", wDevID
);
1537 /* FIXME: this function should :
1538 * turn off every note, remove sustain on all channels
1539 * remove any pending buffers
1541 return MMSYSERR_NOTENABLED
;
1544 #endif /* HAVE_OSS_MIDI */
1546 /*======================================================================*
1547 * MIDI entry points *
1548 *======================================================================*/
1550 /**************************************************************************
1551 * midMessage [sample driver]
1553 DWORD WINAPI
midMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1554 DWORD dwParam1
, DWORD dwParam2
)
1556 TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1557 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1559 #ifdef HAVE_OSS_MIDI
1561 return midOpen(wDevID
,(LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1563 return midClose(wDevID
);
1564 case MIDM_ADDBUFFER
:
1565 return midAddBuffer(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1567 return midPrepare(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1568 case MIDM_UNPREPARE
:
1569 return midUnprepare(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1570 case MIDM_GETDEVCAPS
:
1571 return midGetDevCaps(wDevID
,(LPMIDIINCAPS16
)dwParam1
,dwParam2
);
1572 case MIDM_GETNUMDEVS
:
1573 return MIDM_NUMDEVS
;
1575 return midReset(wDevID
);
1577 return midStart(wDevID
);
1579 return midStop(wDevID
);
1582 TRACE("Unsupported message\n");
1584 return MMSYSERR_NOTSUPPORTED
;
1587 /**************************************************************************
1588 * modMessage [sample driver]
1590 DWORD WINAPI
modMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1591 DWORD dwParam1
, DWORD dwParam2
)
1593 TRACE("(%04X, %04X, %08lX, %08lX, %08lX);\n",
1594 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1597 #ifdef HAVE_OSS_MIDI
1599 return modOpen(wDevID
, (LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1601 return modClose(wDevID
);
1603 return modData(wDevID
, dwParam1
);
1605 return modLongData(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1607 return modPrepare(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1608 case MODM_UNPREPARE
:
1609 return modUnprepare(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1610 case MODM_GETDEVCAPS
:
1611 return modGetDevCaps(wDevID
, (LPMIDIOUTCAPS16
)dwParam1
, dwParam2
);
1612 case MODM_GETNUMDEVS
:
1613 return MODM_NUMDEVS
;
1614 case MODM_GETVOLUME
:
1616 case MODM_SETVOLUME
:
1619 return modReset(wDevID
);
1622 TRACE("Unsupported message\n");
1624 return MMSYSERR_NOTSUPPORTED
;
1627 /**************************************************************************
1628 * MIDI_DriverProc32 [sample driver]
1630 LONG CALLBACK
MIDI_DriverProc(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
1631 DWORD dwParam1
, DWORD dwParam2
)
1634 case DRV_LOAD
: return 1;
1635 case DRV_FREE
: return 1;
1636 case DRV_OPEN
: return 1;
1637 case DRV_CLOSE
: return 1;
1638 case DRV_ENABLE
: return 1;
1639 case DRV_DISABLE
: return 1;
1640 case DRV_QUERYCONFIGURE
: return 1;
1641 case DRV_CONFIGURE
: MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1642 case DRV_INSTALL
: return DRVCNF_RESTART
;
1643 case DRV_REMOVE
: return DRVCNF_RESTART
;
1645 TRACE("Sending msg=%lu to default driver proc\n", wMsg
);
1646 return DefDriverProc16(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1650 /**************************************************************************
1651 * MIDI_DriverProc16 [sample driver]
1653 LONG CALLBACK
MIDI_DriverProc16(DWORD dwDevID
, HDRVR16 hDriv
, WORD wMsg
,
1654 DWORD dwParam1
, DWORD dwParam2
)
1657 case DRV_LOAD
: return 1;
1658 case DRV_FREE
: return 1;
1659 case DRV_OPEN
: return 1;
1660 case DRV_CLOSE
: return 1;
1661 case DRV_ENABLE
: return 1;
1662 case DRV_DISABLE
: return 1;
1663 case DRV_QUERYCONFIGURE
: return 1;
1664 case DRV_CONFIGURE
: MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1665 case DRV_INSTALL
: return DRVCNF_RESTART
;
1666 case DRV_REMOVE
: return DRVCNF_RESTART
;
1668 TRACE("Sending msg=%u to default driver proc\n", wMsg
);
1669 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1673 /*-----------------------------------------------------------------------*/