1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
4 * Sample MIDI Wine Driver for Linux
6 * Copyright 1994 Martin Ayotte
11 * 98/7 changes for making this MIDI driver work on OSS
12 * current support is limited to MIDI ports of OSS systems
13 * 98/9 rewriting MCI code for MIDI
14 * 98/11 splitted in midi.c and mcimidi.c
24 #include <sys/ioctl.h>
25 #include "wine/winuser16.h"
26 #include "multimedia.h"
39 LPMIDIOPENDESC midiDesc
;
41 LPMIDIHDR16 lpQueueHdr
;
44 unsigned char incoming
[3];
45 unsigned char incPrev
;
57 LPMIDIOPENDESC midiDesc
;
59 LPMIDIHDR16 lpQueueHdr
;
62 void* lpExtra
; /* according to port type (MIDI, FM...), extra data when needed */
66 static WINE_MIDIIN MidiInDev
[MAX_MIDIINDRV
];
67 static WINE_MIDIOUT MidiOutDev
[MAX_MIDIOUTDRV
];
69 /* this is the total number of MIDI out devices found */
71 /* this is the number of FM synthetizers (index from 0 to
72 NUMFMSYNTHDEVS - 1) */
73 int MODM_NUMFMSYNTHDEVS
= 0;
74 /* this is the number of Midi ports (index from NUMFMSYNTHDEVS to
75 NUMFMSYNTHDEVS + NUMMIDIDEVS - 1) */
76 int MODM_NUMMIDIDEVS
= 0;
78 /* this is the total number of MIDI out devices found */
82 static int midiSeqFD
= -1;
83 static int numOpenMidiSeq
= 0;
84 static UINT midiInTimerID
= 0;
85 static int numStartedMidiIn
= 0;
88 /* this structure holds pointers with information for each MIDI
91 LPMIDIOUTCAPS16 midiOutDevices
[MAX_MIDIOUTDRV
];
93 /* this structure holds pointers with information for each MIDI
96 LPMIDIINCAPS16 midiInDevices
[MAX_MIDIINDRV
];
99 * FIXME : all tests on device ID for midXXX and modYYY are made against
100 * MAX_MIDIxxDRV (when they are made) but should be done against the actual
101 * number of midi devices found...
102 * check also when HAVE_OSS is defined that midiDesc is not NULL
105 /*======================================================================*
106 * Low level MIDI implemantation *
107 *======================================================================*/
108 #ifdef SNDCTL_MIDI_INFO
109 /**************************************************************************
110 * MIDI_NotifyClient [internal]
112 static DWORD
MIDI_NotifyClient(UINT16 wDevID
, WORD wMsg
,
113 DWORD dwParam1
, DWORD dwParam2
)
120 TRACE(midi
,"wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
121 wDevID
, wMsg
, dwParam1
, dwParam2
);
127 if (wDevID
> MAX_MIDIOUTDRV
)
128 return MCIERR_INTERNAL
;
130 dwCallBack
= MidiOutDev
[wDevID
].midiDesc
->dwCallback
;
131 uFlags
= MidiOutDev
[wDevID
].wFlags
;
132 hDev
= MidiOutDev
[wDevID
].midiDesc
->hMidi
;
133 dwInstance
= MidiOutDev
[wDevID
].midiDesc
->dwInstance
;
140 if (wDevID
> MAX_MIDIINDRV
)
141 return MCIERR_INTERNAL
;
143 dwCallBack
= MidiInDev
[wDevID
].midiDesc
->dwCallback
;
144 uFlags
= MidiInDev
[wDevID
].wFlags
;
145 hDev
= MidiInDev
[wDevID
].midiDesc
->hMidi
;
146 dwInstance
= MidiInDev
[wDevID
].midiDesc
->dwInstance
;
149 WARN(midi
, "Unsupported MSW-MIDI message %u\n", wMsg
);
150 return MCIERR_INTERNAL
;
153 return DriverCallback16(dwCallBack
, uFlags
, hDev
, wMsg
, dwInstance
, dwParam1
, dwParam2
) ?
158 /**************************************************************************
159 * midiOpenSeq [internal]
161 static int midiOpenSeq(void)
163 if (numOpenMidiSeq
== 0) {
164 midiSeqFD
= open(MIDI_SEQ
, O_RDWR
, 0);
165 if (midiSeqFD
== -1) {
166 ERR(midi
, "can't open '%s' ! (%d)\n", MIDI_SEQ
, errno
);
169 if (fcntl(midiSeqFD
, F_SETFL
, O_NONBLOCK
) < 0) {
170 WARN(midi
, "can't set sequencer fd to non blocking (%d)\n", errno
);
175 ioctl(midiSeqFD
, SNDCTL_SEQ_RESET
);
181 /**************************************************************************
182 * midiCloseSeq [internal]
184 static int midiCloseSeq(void)
186 if (--numOpenMidiSeq
== 0) {
193 /* FIXME: this is a bad idea, it's even not static... */
196 /* FIXME: this is not reentrant, not static - because of global variable
198 /**************************************************************************
199 * seqbuf_dump [internal]
201 void seqbuf_dump(void)
204 if (write(midiSeqFD
, _seqbuf
, _seqbufptr
) == -1) {
205 WARN(midi
, "Can't write data to sequencer (%d/%d)!\n",
209 * in any case buffer is lost so that if many errors occur the buffer
215 #endif /* HAVE_OSS */
219 static void midReceiveChar(WORD wDevID
, unsigned char value
, DWORD dwTime
)
223 TRACE(midi
, "Adding %02xh to %d[%d]\n", value
, wDevID
, MidiInDev
[wDevID
].incLen
);
225 if (wDevID
>= MAX_MIDIINDRV
) {
226 WARN(midi
, "bad devID\n");
229 if (MidiInDev
[wDevID
].state
== 0) {
230 TRACE(midi
, "input not started, thrown away\n");
234 if (MidiInDev
[wDevID
].state
& 2) { /* system exclusive */
235 LPMIDIHDR16 ptr
= MidiInDev
[wDevID
].lpQueueHdr
;
239 ((LPSTR
)(ptr
->reserved
))[ptr
->dwBytesRecorded
++] = value
;
240 if (ptr
->dwBytesRecorded
== ptr
->dwBufferLength
) {
244 if (value
== 0xF7) { /* then end */
245 MidiInDev
[wDevID
].state
&= ~2;
248 if (sbfb
&& ptr
!= NULL
) {
249 ptr
= MidiInDev
[wDevID
].lpQueueHdr
;
250 ptr
->dwFlags
&= ~MHDR_INQUEUE
;
251 ptr
->dwFlags
|= MHDR_DONE
;
252 MidiInDev
[wDevID
].lpQueueHdr
= (LPMIDIHDR16
)ptr
->lpNext
;
253 if (MIDI_NotifyClient(wDevID
, MIM_LONGDATA
, (DWORD
)ptr
, dwTime
) != MMSYSERR_NOERROR
) {
254 WARN(midi
, "Couldn't notify client\n");
260 #define IS_CMD(_x) (((_x) & 0x80) == 0x80)
261 #define IS_SYS_CMD(_x) (((_x) & 0xF0) == 0xF0)
263 if (!IS_CMD(value
) && MidiInDev
[wDevID
].incLen
== 0) { /* try to reuse old cmd */
264 if (IS_CMD(MidiInDev
[wDevID
].incPrev
) && !IS_SYS_CMD(MidiInDev
[wDevID
].incPrev
)) {
265 MidiInDev
[wDevID
].incoming
[0] = MidiInDev
[wDevID
].incPrev
;
266 MidiInDev
[wDevID
].incLen
= 1;
267 TRACE(midi
, "Reusing old command %02xh\n", MidiInDev
[wDevID
].incPrev
);
269 FIXME(midi
, "error for midi-in, should generate MIM_ERROR notification:"
270 " prev=%02Xh, incLen=%02Xh\n",
271 MidiInDev
[wDevID
].incPrev
, MidiInDev
[wDevID
].incLen
);
275 MidiInDev
[wDevID
].incoming
[(int)(MidiInDev
[wDevID
].incLen
++)] = value
;
276 if (MidiInDev
[wDevID
].incLen
== 1 && !IS_SYS_CMD(MidiInDev
[wDevID
].incoming
[0])) {
277 /* store new cmd, just in case */
278 MidiInDev
[wDevID
].incPrev
= MidiInDev
[wDevID
].incoming
[0];
282 #undef IS_SYS_CMD(_x)
284 switch (MidiInDev
[wDevID
].incoming
[0] & 0xF0) {
287 case MIDI_KEY_PRESSURE
:
288 case MIDI_CTL_CHANGE
:
289 case MIDI_PITCH_BEND
:
290 if (MidiInDev
[wDevID
].incLen
== 3) {
291 toSend
= (MidiInDev
[wDevID
].incoming
[2] << 16) |
292 (MidiInDev
[wDevID
].incoming
[1] << 8) |
293 (MidiInDev
[wDevID
].incoming
[0] << 0);
296 case MIDI_PGM_CHANGE
:
297 case MIDI_CHN_PRESSURE
:
298 if (MidiInDev
[wDevID
].incLen
== 2) {
299 toSend
= (MidiInDev
[wDevID
].incoming
[1] << 8) |
300 (MidiInDev
[wDevID
].incoming
[0] << 0);
303 case MIDI_SYSTEM_PREFIX
:
304 if (MidiInDev
[wDevID
].incoming
[0] == 0xF0) {
305 MidiInDev
[wDevID
].state
|= 2;
306 MidiInDev
[wDevID
].incLen
= 0;
308 if (MidiInDev
[wDevID
].incLen
== 1) {
309 toSend
= (MidiInDev
[wDevID
].incoming
[0] << 0);
314 WARN(midi
, "This shouldn't happen (%02X)\n", MidiInDev
[wDevID
].incoming
[0]);
317 TRACE(midi
, "Sending event %08lx\n", toSend
);
318 MidiInDev
[wDevID
].incLen
= 0;
319 dwTime
-= MidiInDev
[wDevID
].startTime
;
320 if (MIDI_NotifyClient(wDevID
, MIM_DATA
, toSend
, dwTime
) != MMSYSERR_NOERROR
) {
321 WARN(midi
, "Couldn't notify client\n");
326 static VOID WINAPI
midTimeCallback(HWND hwnd
, UINT msg
, UINT id
, DWORD dwTime
)
328 unsigned char buffer
[256];
331 TRACE(midi
, "(%04X, %d, %d, %lu)\n", hwnd
, msg
, id
, dwTime
);
333 len
= read(midiSeqFD
, buffer
, sizeof(buffer
));
335 if ((len
% 4) != 0) {
336 WARN(midi
, "bad length %d (%d)\n", len
, errno
);
340 for (idx
= 0; idx
< len
; ) {
341 if (buffer
[idx
] & 0x80) {
343 "reading<8> %02x %02x %02x %02x %02x %02x %02x %02x\n",
344 buffer
[idx
+ 0], buffer
[idx
+ 1],
345 buffer
[idx
+ 2], buffer
[idx
+ 3],
346 buffer
[idx
+ 4], buffer
[idx
+ 5],
347 buffer
[idx
+ 6], buffer
[idx
+ 7]);
350 switch (buffer
[idx
+ 0]) {
355 midReceiveChar(buffer
[idx
+ 2], buffer
[idx
+ 1], dwTime
);
358 TRACE(midi
, "Unsupported event %d\n", buffer
[idx
+ 0]);
365 #endif /* HAVE_OSS */
367 /**************************************************************************
368 * midGetDevCaps [internal]
370 static DWORD
midGetDevCaps(WORD wDevID
, LPMIDIINCAPS16 lpCaps
, DWORD dwSize
)
372 LPMIDIINCAPS16 tmplpCaps
;
374 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
376 if (wDevID
>= MIDM_NUMDEVS
) {
377 return MMSYSERR_BADDEVICEID
;
379 if (lpCaps
== NULL
) {
380 return MMSYSERR_INVALPARAM
;
383 tmplpCaps
= midiInDevices
[wDevID
];
384 lpCaps
->wMid
= tmplpCaps
->wMid
;
385 lpCaps
->wPid
= tmplpCaps
->wPid
;
386 lpCaps
->vDriverVersion
= tmplpCaps
->vDriverVersion
;
387 strcpy(lpCaps
->szPname
, tmplpCaps
->szPname
);
388 if (dwSize
== sizeof(MIDIINCAPS16
)) {
389 /* we should run win 95, so make use of dwSupport */
390 lpCaps
->dwSupport
= tmplpCaps
->dwSupport
;
391 } else if (dwSize
!= sizeof(MIDIINCAPS16
) - sizeof(DWORD
)) {
392 TRACE(midi
, "bad size for lpCaps\n");
393 return MMSYSERR_INVALPARAM
;
396 return MMSYSERR_NOERROR
;
399 /**************************************************************************
402 static DWORD
midOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
404 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
406 if (lpDesc
== NULL
) {
407 WARN(midi
, "Invalid Parameter !\n");
408 return MMSYSERR_INVALPARAM
;
411 * how to check that content of lpDesc is correct ?
413 if (wDevID
>= MAX_MIDIINDRV
) {
414 WARN(midi
,"wDevID too large (%u) !\n", wDevID
);
415 return MMSYSERR_BADDEVICEID
;
417 if (MidiInDev
[wDevID
].midiDesc
!= 0) {
418 WARN(midi
, "device already open !\n");
419 return MMSYSERR_ALLOCATED
;
421 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
422 FIXME(midi
, "No support for MIDI_IO_STATUS in dwFlags\n");
423 return MMSYSERR_INVALFLAG
;
427 if (midiOpenSeq() < 0) {
428 return MMSYSERR_ERROR
;
431 if (numStartedMidiIn
++ == 0) {
432 midiInTimerID
= SetTimer(0, 0, 250, midTimeCallback
);
433 if (!midiInTimerID
) {
434 numStartedMidiIn
= 0;
435 WARN(midi
, "Couldn't start timer for midi-in\n");
437 return MMSYSERR_ERROR
;
439 TRACE(midi
, "Starting timer (%u) for midi-in\n", midiInTimerID
);
443 int midi
= open(MIDI_DEV
, O_WRONLY
, 0);
445 MidiInDev
[wDevID
].unixdev
= 0;
447 WARN(midi
,"can't open '%s' (%d)!\n", MIDI_DEV
, errno
);
448 return MMSYSERR_ALLOCATED
;
450 MidiInDev
[wDevID
].unixdev
= midi
;
452 #endif /* HAVE_OSS */
454 MidiInDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
455 switch (MidiInDev
[wDevID
].wFlags
) {
457 TRACE(midi
,"CALLBACK_NULL !\n");
460 TRACE(midi
, "CALLBACK_WINDOW !\n");
463 TRACE(midi
, "CALLBACK_TASK !\n");
466 TRACE(midi
, "CALLBACK_FUNCTION (%08lX)!\n", lpDesc
->dwCallback
);
469 MidiInDev
[wDevID
].lpQueueHdr
= NULL
;
470 MidiInDev
[wDevID
].dwTotalPlayed
= 0;
471 MidiInDev
[wDevID
].bufsize
= 0x3FFF;
472 MidiInDev
[wDevID
].midiDesc
= lpDesc
;
473 MidiInDev
[wDevID
].state
= 0;
475 MidiInDev
[wDevID
].incLen
= 0;
476 MidiInDev
[wDevID
].startTime
= 0;
477 #endif /* HAVE_OSS */
478 if (MIDI_NotifyClient(wDevID
, MIM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
479 WARN(midi
,"can't notify client !\n");
480 return MMSYSERR_INVALPARAM
;
482 return MMSYSERR_NOERROR
;
485 /**************************************************************************
486 * midClose [internal]
488 static DWORD
midClose(WORD wDevID
)
490 int ret
= MMSYSERR_NOERROR
;
492 TRACE(midi
, "(%04X);\n", wDevID
);
494 if (wDevID
>= MAX_MIDIINDRV
) {
495 WARN(midi
,"wDevID too bif (%u) !\n", wDevID
);
496 return MMSYSERR_BADDEVICEID
;
498 if (MidiInDev
[wDevID
].midiDesc
== 0) {
499 WARN(midi
, "device not opened !\n");
500 return MMSYSERR_ERROR
;
502 if (MidiInDev
[wDevID
].lpQueueHdr
!= 0) {
503 return MIDIERR_STILLPLAYING
;
507 if (midiSeqFD
== -1) {
508 WARN(midi
,"ooops !\n");
509 return MMSYSERR_ERROR
;
511 if (--numStartedMidiIn
== 0) {
512 TRACE(midi
, "Stopping timer for midi-in\n");
513 if (!KillTimer(0, midiInTimerID
)) {
514 WARN(midi
, "Couldn't stop timer for midi-in\n");
520 if (MidiInDev
[wDevID
].unixdev
== 0) {
521 WARN(midi
,"ooops !\n");
522 return MMSYSERR_ERROR
;
524 close(MidiInDev
[wDevID
].unixdev
);
525 MidiInDev
[wDevID
].unixdev
= 0;
526 #endif /* HAVE_OSS */
527 MidiInDev
[wDevID
].bufsize
= 0;
528 if (MIDI_NotifyClient(wDevID
, MIM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
529 WARN(midi
,"can't notify client !\n");
530 ret
= MMSYSERR_INVALPARAM
;
532 MidiInDev
[wDevID
].midiDesc
= 0;
536 /**************************************************************************
537 * midAddBuffer [internal]
539 static DWORD
midAddBuffer(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
541 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
543 if (lpMidiHdr
== NULL
) return MMSYSERR_INVALPARAM
;
544 if (sizeof(MIDIHDR16
) != dwSize
) return MMSYSERR_INVALPARAM
;
545 if (lpMidiHdr
->dwBufferLength
== 0) return MMSYSERR_INVALPARAM
;
546 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
547 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
549 if (MidiInDev
[wDevID
].lpQueueHdr
== 0) {
550 MidiInDev
[wDevID
].lpQueueHdr
= lpMidiHdr
;
554 for (ptr
= MidiInDev
[wDevID
].lpQueueHdr
;
556 ptr
= (LPMIDIHDR16
)ptr
->lpNext
);
557 ptr
->lpNext
= (struct midihdr_tag
*)lpMidiHdr
;
559 return MMSYSERR_NOERROR
;
562 /**************************************************************************
563 * midPrepare [internal]
565 static DWORD
midPrepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
567 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
569 if (dwSize
!= sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
570 lpMidiHdr
->lpData
== 0 || lpMidiHdr
->dwFlags
!= 0 ||
571 lpMidiHdr
->dwBufferLength
>= 0x10000ul
)
572 return MMSYSERR_INVALPARAM
;
574 lpMidiHdr
->lpNext
= 0;
575 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
576 lpMidiHdr
->dwBytesRecorded
= 0;
578 return MMSYSERR_NOERROR
;
581 /**************************************************************************
582 * midUnprepare [internal]
584 static DWORD
midUnprepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
586 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
588 if (dwSize
!= sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
589 lpMidiHdr
->lpData
== 0 || lpMidiHdr
->dwBufferLength
>= 0x10000ul
)
590 return MMSYSERR_INVALPARAM
;
592 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
593 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
595 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
597 return MMSYSERR_NOERROR
;
600 /**************************************************************************
601 * midReset [internal]
603 static DWORD
midReset(WORD wDevID
)
605 DWORD dwTime
= GetTickCount();
607 TRACE(midi
, "(%04X);\n", wDevID
);
609 while (MidiInDev
[wDevID
].lpQueueHdr
) {
610 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
&= ~MHDR_INQUEUE
;
611 MidiInDev
[wDevID
].lpQueueHdr
->dwFlags
|= MHDR_DONE
;
612 if (MIDI_NotifyClient(wDevID
, MIM_LONGDATA
,
613 (DWORD
)MidiInDev
[wDevID
].lpQueueHdr
, dwTime
) != MMSYSERR_NOERROR
) {
614 WARN(midi
, "Couldn't notify client\n");
616 MidiInDev
[wDevID
].lpQueueHdr
= (LPMIDIHDR16
)MidiInDev
[wDevID
].lpQueueHdr
->lpNext
;
619 return MMSYSERR_NOERROR
;
623 /**************************************************************************
624 * midStart [internal]
626 static DWORD
midStart(WORD wDevID
)
628 TRACE(midi
, "(%04X);\n", wDevID
);
630 /* FIXME : should test value of wDevID */
633 MidiInDev
[wDevID
].state
= 1;
634 MidiInDev
[wDevID
].startTime
= GetTickCount();
635 return MMSYSERR_NOERROR
;
637 return MMSYSERR_NOTENABLED
;
638 #endif /* HAVE_OSS */
641 /**************************************************************************
644 static DWORD
midStop(WORD wDevID
)
646 TRACE(midi
, "(%04X);\n", wDevID
);
648 /* FIXME : should test value of wDevID */
651 MidiInDev
[wDevID
].state
= 0;
652 return MMSYSERR_NOERROR
;
654 return MMSYSERR_NOTENABLED
;
655 #endif /* HAVE_OSS */
658 /*-----------------------------------------------------------------------*/
662 typedef struct sVoice
{
663 int note
; /* 0 means not used */
665 unsigned cntMark
: 30,
668 #define sVS_PLAYING 1
669 #define sVS_SUSTAINED 2
672 typedef struct sChannel
{
678 int bank
; /* CTL_BANK_SELECT */
679 int volume
; /* CTL_MAIN_VOLUME */
680 int balance
; /* CTL_BALANCE */
681 int expression
; /* CTL_EXPRESSION */
682 int sustain
; /* CTL_SUSTAIN */
684 unsigned char nrgPmtMSB
; /* Non register Parameters */
685 unsigned char nrgPmtLSB
;
686 unsigned char regPmtMSB
; /* Non register Parameters */
687 unsigned char regPmtLSB
;
690 typedef struct sFMextra
{
693 sChannel channel
[16]; /* MIDI has only 16 channels */
694 sVoice voice
[1]; /* dyn allocated according to sound card */
695 /* do not append fields below voice[1] since the size of this structure
696 * depends on the number of available voices on the FM synth...
700 extern unsigned char midiFMInstrumentPatches
[16 * 128];
701 extern unsigned char midiFMDrumsPatches
[16 * 128];
703 /**************************************************************************
704 * modFMLoad [internal]
706 static int modFMLoad(int dev
)
709 struct sbi_instrument sbi
;
714 memset(sbi
.operators
+ 16, 0, 16);
715 for (i
= 0; i
< 128; i
++) {
717 memcpy(sbi
.operators
, midiFMInstrumentPatches
+ i
* 16, 16);
719 if (write(midiSeqFD
, (char*)&sbi
, sizeof(sbi
)) == -1) {
720 WARN(midi
, "Couldn't write patch for instrument %d (%d)!\n", sbi
.channel
, errno
);
724 for (i
= 0; i
< 128; i
++) {
725 sbi
.channel
= 128 + i
;
726 memcpy(sbi
.operators
, midiFMDrumsPatches
+ i
* 16, 16);
728 if (write(midiSeqFD
, (char*)&sbi
, sizeof(sbi
)) == -1) {
729 WARN(midi
, "Couldn't write patch for drum %d (%d)!\n", sbi
.channel
, errno
);
736 /**************************************************************************
737 * modFMReset [internal]
739 static void modFMReset(WORD wDevID
)
741 sFMextra
* extra
= (sFMextra
*)MidiOutDev
[wDevID
].lpExtra
;
742 sVoice
* voice
= extra
->voice
;
743 sChannel
* channel
= extra
->channel
;
746 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
747 if (voice
[i
].status
!= sVS_UNUSED
) {
748 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
750 SEQ_KEY_PRESSURE(wDevID
, i
, 127, 0);
751 SEQ_CONTROL(wDevID
, i
, SEQ_VOLMODE
, VOL_METHOD_LINEAR
);
753 voice
[i
].channel
= -1;
754 voice
[i
].cntMark
= 0;
755 voice
[i
].status
= sVS_UNUSED
;
757 for (i
= 0; i
< 16; i
++) {
758 channel
[i
].program
= 0;
759 channel
[i
].bender
= 8192;
760 channel
[i
].benderRange
= 2;
762 channel
[i
].volume
= 127;
763 channel
[i
].balance
= 64;
764 channel
[i
].expression
= 0;
765 channel
[i
].sustain
= 0;
768 extra
->drumSetMask
= 1 << 9; /* channel 10 is normally drums, sometimes 16 also */
772 #define IS_DRUM_CHANNEL(_xtra, _chn) ((_xtra)->drumSetMask & (1 << (_chn)))
774 #endif /* HAVE_OSS */
776 /**************************************************************************
777 * modGetDevCaps [internal]
779 static DWORD
modGetDevCaps(WORD wDevID
, LPMIDIOUTCAPS16 lpCaps
,
782 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
783 if (wDevID
== (WORD
) MIDI_MAPPER
) {
784 lpCaps
->wMid
= 0x00FF; /* Manufac ID */
785 lpCaps
->wPid
= 0x0001; /* Product ID */
786 lpCaps
->vDriverVersion
= 0x001; /* Product Version */
787 strcpy(lpCaps
->szPname
, "MIDI Mapper (not functional yet)");
788 /* FIXME Does it make any difference ? */
789 lpCaps
->wTechnology
= MOD_FMSYNTH
;
790 lpCaps
->wVoices
= 14; /* FIXME */
791 lpCaps
->wNotes
= 14; /* FIXME */
792 /* FIXME Does it make any difference ? */
793 lpCaps
->dwSupport
= MIDICAPS_VOLUME
|MIDICAPS_LRVOLUME
;
795 LPMIDIOUTCAPS16 tmplpCaps
;
797 if (wDevID
>= MODM_NUMDEVS
) {
798 TRACE(midi
, "MAX_MIDIOUTDRV reached !\n");
799 return MMSYSERR_BADDEVICEID
;
801 /* FIXME There is a way to do it so easily, but I'm too
802 * sleepy to think and I want to test
805 tmplpCaps
= midiOutDevices
[wDevID
];
806 lpCaps
->wMid
= tmplpCaps
->wMid
;
807 lpCaps
->wPid
= tmplpCaps
->wPid
;
808 lpCaps
->vDriverVersion
= tmplpCaps
->vDriverVersion
;
809 strcpy(lpCaps
->szPname
, tmplpCaps
->szPname
);
810 lpCaps
->wTechnology
= tmplpCaps
->wTechnology
;
811 lpCaps
->wVoices
= tmplpCaps
->wVoices
;
812 lpCaps
->wNotes
= tmplpCaps
->wNotes
;
813 lpCaps
->dwSupport
= tmplpCaps
->dwSupport
;
815 return MMSYSERR_NOERROR
;
818 /**************************************************************************
821 static DWORD
modOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
823 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
824 if (lpDesc
== NULL
) {
825 WARN(midi
, "Invalid Parameter !\n");
826 return MMSYSERR_INVALPARAM
;
828 if (wDevID
>= MAX_MIDIOUTDRV
) {
829 TRACE(midi
,"MAX_MIDIOUTDRV reached !\n");
830 return MMSYSERR_BADDEVICEID
;
832 if (MidiOutDev
[wDevID
].midiDesc
!= 0) {
833 WARN(midi
, "device already open !\n");
834 return MMSYSERR_ALLOCATED
;
836 if ((dwFlags
& ~CALLBACK_TYPEMASK
) != 0) {
837 WARN(midi
, "bad dwFlags\n");
838 return MMSYSERR_INVALFLAG
;
840 if (midiOutDevices
[wDevID
] == NULL
) {
841 TRACE(midi
, "un-allocated wDevID\n");
842 return MMSYSERR_BADDEVICEID
;
846 MidiOutDev
[wDevID
].lpExtra
= 0;
848 switch (midiOutDevices
[wDevID
]->wTechnology
) {
851 void* extra
= xmalloc(sizeof(struct sFMextra
) +
852 sizeof(struct sVoice
) *
853 (midiOutDevices
[wDevID
]->wVoices
- 1));
856 WARN(midi
, "can't alloc extra data !\n");
857 return MMSYSERR_NOMEM
;
859 MidiOutDev
[wDevID
].lpExtra
= extra
;
860 if (midiOpenSeq() < 0) {
861 MidiOutDev
[wDevID
].lpExtra
= 0;
863 return MMSYSERR_ERROR
;
865 if (modFMLoad(wDevID
) < 0) {
867 MidiOutDev
[wDevID
].lpExtra
= 0;
869 return MMSYSERR_ERROR
;
875 if (midiOpenSeq() < 0) {
876 return MMSYSERR_ALLOCATED
;
880 WARN(midi
,"Technology not supported (yet) %d !\n",
881 midiOutDevices
[wDevID
]->wTechnology
);
882 return MMSYSERR_NOTENABLED
;
886 int midi
= open (MIDI_DEV
, O_WRONLY
, 0);
887 MidiOutDev
[wDevID
].unixdev
= 0;
889 WARN(midi
, "can't open !\n");
890 return MMSYSERR_ALLOCATED
;
892 MidiOutDev
[wDevID
].unixdev
= midi
;
894 #endif /* HAVE_OSS */
896 MidiOutDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
897 switch (MidiOutDev
[wDevID
].wFlags
) {
899 TRACE(midi
,"CALLBACK_NULL !\n");
902 TRACE(midi
, "CALLBACK_WINDOW !\n");
905 TRACE(midi
, "CALLBACK_TASK !\n");
908 TRACE(midi
, "CALLBACK_FUNCTION !\n");
911 MidiOutDev
[wDevID
].lpQueueHdr
= NULL
;
912 MidiOutDev
[wDevID
].dwTotalPlayed
= 0;
913 MidiOutDev
[wDevID
].bufsize
= 0x3FFF;
914 MidiOutDev
[wDevID
].midiDesc
= lpDesc
;
916 if (MIDI_NotifyClient(wDevID
, MOM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
917 WARN(midi
,"can't notify client !\n");
918 return MMSYSERR_INVALPARAM
;
920 TRACE(midi
, "Succesful !\n");
921 return MMSYSERR_NOERROR
;
925 /**************************************************************************
926 * modClose [internal]
928 static DWORD
modClose(WORD wDevID
)
930 int ret
= MMSYSERR_NOERROR
;
932 TRACE(midi
, "(%04X);\n", wDevID
);
934 if (MidiOutDev
[wDevID
].midiDesc
== 0) {
935 WARN(midi
, "device not opened !\n");
936 return MMSYSERR_ERROR
;
938 /* FIXME: should test that no pending buffer is still in the queue for
942 if (midiSeqFD
== -1) {
943 WARN(midi
,"can't close !\n");
944 return MMSYSERR_ERROR
;
947 switch (midiOutDevices
[wDevID
]->wTechnology
) {
953 WARN(midi
,"Technology not supported (yet) %d !\n",
954 midiOutDevices
[wDevID
]->wTechnology
);
955 return MMSYSERR_NOTENABLED
;
958 if (MidiOutDev
[wDevID
].lpExtra
!= 0) {
959 free(MidiOutDev
[wDevID
].lpExtra
);
960 MidiOutDev
[wDevID
].lpExtra
= 0;
963 if (MidiOutDev
[wDevID
].unixdev
== 0) {
964 WARN(midi
,"can't close !\n");
965 return MMSYSERR_NOTENABLED
;
967 close(MidiOutDev
[wDevID
].unixdev
);
968 MidiOutDev
[wDevID
].unixdev
= 0;
969 #endif /* HAVE_OSS */
971 MidiOutDev
[wDevID
].bufsize
= 0;
972 if (MIDI_NotifyClient(wDevID
, MOM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
973 WARN(midi
,"can't notify client !\n");
974 ret
= MMSYSERR_INVALPARAM
;
976 MidiOutDev
[wDevID
].midiDesc
= 0;
980 /**************************************************************************
983 static DWORD
modData(WORD wDevID
, DWORD dwParam
)
985 WORD evt
= LOBYTE(LOWORD(dwParam
));
986 WORD d1
= HIBYTE(LOWORD(dwParam
));
987 WORD d2
= LOBYTE(HIWORD(dwParam
));
989 TRACE(midi
, "(%04X, %08lX);\n", wDevID
, dwParam
);
992 if (midiSeqFD
== -1) {
993 WARN(midi
,"can't play !\n");
994 return MIDIERR_NODEVICE
;
996 switch (midiOutDevices
[wDevID
]->wTechnology
) {
999 * - chorus depth controller is not used
1002 sFMextra
* extra
= (sFMextra
*)MidiOutDev
[wDevID
].lpExtra
;
1003 sVoice
* voice
= extra
->voice
;
1004 sChannel
* channel
= extra
->channel
;
1005 int chn
= (evt
& 0x0F);
1008 switch (evt
& 0xF0) {
1010 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1011 /* don't stop sustained notes */
1012 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1013 voice
[i
].status
= sVS_UNUSED
;
1014 SEQ_STOP_NOTE(wDevID
, i
, d1
, d2
);
1019 if (d2
== 0) { /* note off if velocity == 0 */
1020 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1021 /* don't stop sustained notes */
1022 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1023 voice
[i
].status
= sVS_UNUSED
;
1024 SEQ_STOP_NOTE(wDevID
, i
, d1
, 64);
1029 /* finding out in this order :
1031 * - if replaying the same note on the same channel
1032 * - the older voice (LRU)
1034 for (i
= nv
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1035 if (voice
[i
].status
== sVS_UNUSED
||
1036 (voice
[i
].note
== d1
&& voice
[i
].channel
== chn
)) {
1040 if (voice
[i
].cntMark
< voice
[0].cntMark
) {
1045 "playing on voice=%d, pgm=%d, pan=0x%02X, vol=0x%02X, "
1046 "bender=0x%02X, note=0x%02X, vel=0x%02X\n",
1047 nv
, channel
[chn
].program
,
1048 channel
[chn
].balance
,
1049 channel
[chn
].volume
,
1050 channel
[chn
].bender
, d1
, d2
);
1052 SEQ_SET_PATCH(wDevID
, nv
, IS_DRUM_CHANNEL(extra
, chn
) ?
1053 (128 + d1
) : channel
[chn
].program
);
1054 SEQ_BENDER_RANGE(wDevID
, nv
, channel
[chn
].benderRange
* 100);
1055 SEQ_BENDER(wDevID
, nv
, channel
[chn
].bender
);
1056 SEQ_CONTROL(wDevID
, nv
, CTL_PAN
, channel
[chn
].balance
);
1057 SEQ_CONTROL(wDevID
, nv
, CTL_EXPRESSION
, channel
[chn
].expression
);
1059 /* FIXME: does not really seem to work on my SB card and
1060 * screws everything up... so lay it down
1062 SEQ_CONTROL(wDevID
, nv
, CTL_MAIN_VOLUME
, channel
[chn
].volume
);
1064 SEQ_START_NOTE(wDevID
, nv
, d1
, d2
);
1065 voice
[nv
].status
= channel
[chn
].sustain
? sVS_SUSTAINED
: sVS_PLAYING
;
1066 voice
[nv
].note
= d1
;
1067 voice
[nv
].channel
= chn
;
1068 voice
[nv
].cntMark
= extra
->counter
++;
1070 case MIDI_KEY_PRESSURE
:
1071 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1072 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
&& voice
[i
].note
== d1
) {
1073 SEQ_KEY_PRESSURE(wDevID
, i
, d1
, d2
);
1077 case MIDI_CTL_CHANGE
:
1079 case CTL_BANK_SELECT
: channel
[chn
].bank
= d2
; break;
1080 case CTL_MAIN_VOLUME
: channel
[chn
].volume
= d2
; break;
1081 case CTL_PAN
: channel
[chn
].balance
= d2
; break;
1082 case CTL_EXPRESSION
: channel
[chn
].expression
= d2
; break;
1083 case CTL_SUSTAIN
: channel
[chn
].sustain
= d2
;
1085 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1086 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1087 voice
[i
].status
= sVS_SUSTAINED
;
1091 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1092 if (voice
[i
].status
== sVS_SUSTAINED
&& voice
[i
].channel
== chn
) {
1093 voice
[i
].status
= sVS_UNUSED
;
1094 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 64);
1099 case CTL_NONREG_PARM_NUM_LSB
: channel
[chn
].nrgPmtLSB
= d2
; break;
1100 case CTL_NONREG_PARM_NUM_MSB
: channel
[chn
].nrgPmtMSB
= d2
; break;
1101 case CTL_REGIST_PARM_NUM_LSB
: channel
[chn
].regPmtLSB
= d2
; break;
1102 case CTL_REGIST_PARM_NUM_MSB
: channel
[chn
].regPmtMSB
= d2
; break;
1104 case CTL_DATA_ENTRY
:
1105 switch ((channel
[chn
].regPmtMSB
<< 8) | channel
[chn
].regPmtLSB
) {
1107 if (channel
[chn
].benderRange
!= d2
) {
1108 channel
[chn
].benderRange
= d2
;
1109 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1110 if (voice
[i
].channel
== chn
) {
1111 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1118 channel
[chn
].benderRange
= 2;
1119 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1120 if (voice
[i
].channel
== chn
) {
1121 SEQ_BENDER_RANGE(wDevID
, i
, channel
[chn
].benderRange
);
1126 TRACE(midi
, "Data entry: regPmt=0x%02x%02x, nrgPmt=0x%02x%02x with %x\n",
1127 channel
[chn
].regPmtMSB
, channel
[chn
].regPmtLSB
,
1128 channel
[chn
].nrgPmtMSB
, channel
[chn
].nrgPmtLSB
,
1134 case 0x78: /* all sounds off */
1135 /* FIXME: I don't know if I have to take care of the channel
1136 * for this control ?
1138 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1139 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1140 voice
[i
].status
= sVS_UNUSED
;
1141 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 0);
1145 case 0x7B: /* all notes off */
1146 /* FIXME: I don't know if I have to take care of the channel
1147 * for this control ?
1149 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1150 if (voice
[i
].status
== sVS_PLAYING
&& voice
[i
].channel
== chn
) {
1151 voice
[i
].status
= sVS_UNUSED
;
1152 SEQ_STOP_NOTE(wDevID
, i
, voice
[i
].note
, 0);
1157 TRACE(midi
, "Dropping MIDI control event 0x%02x(%02x) on channel %d\n",
1162 case MIDI_PGM_CHANGE
:
1163 channel
[chn
].program
= d1
;
1165 case MIDI_CHN_PRESSURE
:
1166 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1167 if (voice
[i
].status
!= sVS_UNUSED
&& voice
[i
].channel
== chn
) {
1168 SEQ_KEY_PRESSURE(wDevID
, i
, voice
[i
].note
, d1
);
1172 case MIDI_PITCH_BEND
:
1173 channel
[chn
].bender
= (d2
<< 7) + d1
;
1174 for (i
= 0; i
< midiOutDevices
[wDevID
]->wVoices
; i
++) {
1175 if (voice
[i
].channel
== chn
) {
1176 SEQ_BENDER(wDevID
, i
, channel
[chn
].bender
);
1180 case MIDI_SYSTEM_PREFIX
:
1181 switch (evt
& 0x0F) {
1182 case 0x0F: /* Reset */
1186 WARN(midi
, "Unsupported (yet) system event %02x\n", evt
& 0x0F);
1190 WARN(midi
, "Internal error, shouldn't happen (event=%08x)\n", evt
& 0xF0);
1191 return MMSYSERR_NOTENABLED
;
1197 int dev
= wDevID
- MODM_NUMFMSYNTHDEVS
;
1199 WARN(midi
, "Internal error on devID (%u) !\n", wDevID
);
1200 return MIDIERR_NODEVICE
;
1203 switch (evt
& 0xF0) {
1206 case MIDI_KEY_PRESSURE
:
1207 case MIDI_CTL_CHANGE
:
1208 case MIDI_PITCH_BEND
:
1209 SEQ_MIDIOUT(dev
, evt
);
1210 SEQ_MIDIOUT(dev
, d1
);
1211 SEQ_MIDIOUT(dev
, d2
);
1213 case MIDI_PGM_CHANGE
:
1214 case MIDI_CHN_PRESSURE
:
1215 SEQ_MIDIOUT(dev
, evt
);
1216 SEQ_MIDIOUT(dev
, d1
);
1218 case MIDI_SYSTEM_PREFIX
:
1219 switch (evt
& 0x0F) {
1220 case 0x00: /* System Exclusive, don't do it on modData,
1221 * should require modLongData*/
1222 case 0x01: /* Undefined */
1223 case 0x04: /* Undefined. */
1224 case 0x05: /* Undefined. */
1225 case 0x07: /* End of Exclusive. */
1226 case 0x09: /* Undefined. */
1227 case 0x0D: /* Undefined. */
1229 case 0x06: /* Tune Request */
1230 case 0x08: /* Timing Clock. */
1231 case 0x0A: /* Start. */
1232 case 0x0B: /* Continue */
1233 case 0x0C: /* Stop */
1234 case 0x0E: /* Active Sensing. */
1235 SEQ_MIDIOUT(dev
, evt
);
1237 case 0x0F: /* Reset */
1238 /* SEQ_MIDIOUT(dev, evt);
1239 this other way may be better */
1240 SEQ_MIDIOUT(dev
, MIDI_SYSTEM_PREFIX
);
1241 SEQ_MIDIOUT(dev
, 0x7e);
1242 SEQ_MIDIOUT(dev
, 0x7f);
1243 SEQ_MIDIOUT(dev
, 0x09);
1244 SEQ_MIDIOUT(dev
, 0x01);
1245 SEQ_MIDIOUT(dev
, 0xf7);
1247 case 0x03: /* Song Select. */
1248 SEQ_MIDIOUT(dev
, evt
);
1249 SEQ_MIDIOUT(dev
, d1
);
1250 case 0x02: /* Song Position Pointer. */
1251 SEQ_MIDIOUT(dev
, evt
);
1252 SEQ_MIDIOUT(dev
, d1
);
1253 SEQ_MIDIOUT(dev
, d2
);
1260 WARN(midi
, "Technology not supported (yet) %d !\n",
1261 midiOutDevices
[wDevID
]->wTechnology
);
1262 return MMSYSERR_NOTENABLED
;
1267 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1268 WARN(midi
,"can't play !\n");
1269 return MIDIERR_NODEVICE
;
1272 WORD event
= LOWORD(dwParam
);
1273 if (write (MidiOutDev
[wDevID
].unixdev
,
1274 &event
, sizeof(event
)) != sizeof(WORD
)) {
1275 WARN(midi
, "error writting unixdev !\n");
1278 #endif /* HAVE_OSS */
1279 return MMSYSERR_NOERROR
;
1282 /**************************************************************************
1283 * modLongData [internal]
1285 static DWORD
modLongData(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1289 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1292 if (midiSeqFD
== -1) {
1293 WARN(midi
,"can't play !\n");
1294 return MIDIERR_NODEVICE
;
1296 #else /* HAVE_OSS */
1297 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1298 WARN(midi
,"can't play !\n");
1299 return MIDIERR_NODEVICE
;
1301 #endif /* HAVE_OSS */
1303 if (lpMidiHdr
->lpData
== NULL
)
1304 return MIDIERR_UNPREPARED
;
1305 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
))
1306 return MIDIERR_UNPREPARED
;
1307 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1308 return MIDIERR_STILLPLAYING
;
1309 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1310 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
1312 TRACE(midi
, "dwBytesRecorded %lu !\n", lpMidiHdr
->dwBytesRecorded
);
1313 TRACE(midi
, " %02X %02X %02X %02X\n",
1314 ((LPBYTE
)(lpMidiHdr
->reserved
))[0],
1315 ((LPBYTE
)(lpMidiHdr
->reserved
))[1],
1316 ((LPBYTE
)(lpMidiHdr
->reserved
))[2],
1317 ((LPBYTE
)(lpMidiHdr
->reserved
))[3]);
1319 switch (midiOutDevices
[wDevID
]->wTechnology
) {
1321 /* FIXME: I don't think there is much to do here */
1324 if (((LPBYTE
)lpMidiHdr
->reserved
)[0] != 0xF0) {
1325 /* Send end of System Exclusive */
1326 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, 0xF0);
1327 TRACE(midi
, "Adding missing 0xF0 marker at the begining of "
1328 "system exclusive byte stream\n");
1330 for (count
= 0; count
< lpMidiHdr
->dwBytesRecorded
; count
++) {
1331 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
,
1332 ((LPBYTE
)lpMidiHdr
->reserved
)[count
]);
1334 if (((LPBYTE
)lpMidiHdr
->reserved
)[count
- 1] != 0xF7) {
1335 /* Send end of System Exclusive */
1336 SEQ_MIDIOUT(wDevID
- MODM_NUMFMSYNTHDEVS
, 0xF7);
1337 TRACE(midi
, "Adding missing 0xF7 marker at the end of "
1338 "system exclusive byte stream\n");
1343 WARN(midi
, "Technology not supported (yet) %d !\n",
1344 midiOutDevices
[wDevID
]->wTechnology
);
1345 return MMSYSERR_NOTENABLED
;
1347 #else /* HAVE_OSS */
1349 LPWORD ptr
= (LPWORD
)lpMidiHdr
->reserved
;
1352 for (count
= 0; count
< lpMidiHdr
->dwBytesRecorded
; count
++) {
1353 if (write(MidiOutDev
[wDevID
].unixdev
,
1354 ptr
, sizeof(WORD
)) != sizeof(WORD
))
1360 TRACE(midi
, "after write count = %d\n",count
);
1361 if (count
!= lpMidiHdr
->dwBytesRecorded
) {
1362 WARN(midi
, "error writting unixdev #%d ! (%d != %ld)\n",
1363 MidiOutDev
[wDevID
].unixdev
, count
,
1364 lpMidiHdr
->dwBytesRecorded
);
1365 TRACE(midi
, "\terrno = %d error = %s\n",en
,strerror(en
));
1366 return MMSYSERR_NOTENABLED
;
1369 #endif /* HAVE_OSS */
1371 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1372 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1373 if (MIDI_NotifyClient(wDevID
, MOM_DONE
, (DWORD
)lpMidiHdr
, 0L) != MMSYSERR_NOERROR
) {
1374 WARN(midi
,"can't notify client !\n");
1375 return MMSYSERR_INVALPARAM
;
1377 return MMSYSERR_NOERROR
;
1380 /**************************************************************************
1381 * modPrepare [internal]
1383 static DWORD
modPrepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1385 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1388 if (midiSeqFD
== -1) {
1389 WARN(midi
,"can't prepare !\n");
1390 return MMSYSERR_NOTENABLED
;
1392 #else /* HAVE_OSS */
1393 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1394 WARN(midi
,"can't prepare !\n");
1395 return MMSYSERR_NOTENABLED
;
1397 #endif /* HAVE_OSS */
1398 if (dwSize
!= sizeof(MIDIHDR16
) || lpMidiHdr
== 0 ||
1399 lpMidiHdr
->lpData
== 0 || lpMidiHdr
->dwFlags
!= 0 ||
1400 lpMidiHdr
->dwBufferLength
>= 0x10000ul
)
1401 return MMSYSERR_INVALPARAM
;
1403 lpMidiHdr
->lpNext
= 0;
1404 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
1405 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1406 return MMSYSERR_NOERROR
;
1409 /**************************************************************************
1410 * modUnprepare [internal]
1412 static DWORD
modUnprepare(WORD wDevID
, LPMIDIHDR16 lpMidiHdr
, DWORD dwSize
)
1414 TRACE(midi
, "(%04X, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1417 if (midiSeqFD
== -1) {
1418 WARN(midi
,"can't unprepare !\n");
1419 return MMSYSERR_NOTENABLED
;
1421 #else /* HAVE_OSS */
1422 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1423 WARN(midi
,"can't unprepare !\n");
1424 return MMSYSERR_NOTENABLED
;
1426 #endif /* HAVE_OSS */
1427 if (dwSize
!= sizeof(MIDIHDR16
) || lpMidiHdr
== 0)
1428 return MMSYSERR_INVALPARAM
;
1429 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1430 return MIDIERR_STILLPLAYING
;
1431 lpMidiHdr
->dwFlags
&= ~MHDR_PREPARED
;
1432 return MMSYSERR_NOERROR
;
1435 /**************************************************************************
1436 * modReset [internal]
1438 static DWORD
modReset(WORD wDevID
)
1440 TRACE(midi
, "(%04X);\n", wDevID
);
1441 /* FIXME: this function should :
1442 * turn off every note, remove sustain on all channels
1443 * remove any pending buffers
1445 return MMSYSERR_NOTENABLED
;
1449 /*======================================================================*
1450 * MIDI entry points *
1451 *======================================================================*/
1453 /**************************************************************************
1454 * midMessage [sample driver]
1456 DWORD WINAPI
midMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1457 DWORD dwParam1
, DWORD dwParam2
)
1459 TRACE(midi
, "(%04X, %04X, %08lX, %08lX, %08lX);\n",
1460 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1462 #ifdef SNDCTL_MIDI_INFO
1464 return midOpen(wDevID
,(LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1466 return midClose(wDevID
);
1467 case MIDM_ADDBUFFER
:
1468 return midAddBuffer(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1470 return midPrepare(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1471 case MIDM_UNPREPARE
:
1472 return midUnprepare(wDevID
,(LPMIDIHDR16
)dwParam1
, dwParam2
);
1473 case MIDM_GETDEVCAPS
:
1474 return midGetDevCaps(wDevID
,(LPMIDIINCAPS16
)dwParam1
,dwParam2
);
1475 case MIDM_GETNUMDEVS
:
1476 return MIDM_NUMDEVS
;
1478 return midReset(wDevID
);
1480 return midStart(wDevID
);
1482 return midStop(wDevID
);
1485 TRACE(midi
, "Unsupported message\n");
1487 return MMSYSERR_NOTSUPPORTED
;
1490 /**************************************************************************
1491 * modMessage [sample driver]
1493 DWORD WINAPI
modMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1494 DWORD dwParam1
, DWORD dwParam2
)
1496 TRACE(midi
, "(%04X, %04X, %08lX, %08lX, %08lX);\n",
1497 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1500 #ifdef SNDCTL_MIDI_INFO
1502 return modOpen(wDevID
, (LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1504 return modClose(wDevID
);
1506 return modData(wDevID
, dwParam1
);
1508 return modLongData(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1510 return modPrepare(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1511 case MODM_UNPREPARE
:
1512 return modUnprepare(wDevID
, (LPMIDIHDR16
)dwParam1
, dwParam2
);
1513 case MODM_GETDEVCAPS
:
1514 return modGetDevCaps(wDevID
,(LPMIDIOUTCAPS16
)dwParam1
,dwParam2
);
1515 case MODM_GETNUMDEVS
:
1516 return MODM_NUMDEVS
;
1517 case MODM_GETVOLUME
:
1519 case MODM_SETVOLUME
:
1522 return modReset(wDevID
);
1525 TRACE(midi
, "Unsupported message\n");
1527 return MMSYSERR_NOTSUPPORTED
;
1530 /**************************************************************************
1531 * MIDI_DriverProc32 [sample driver]
1533 LONG
MIDI_DriverProc(DWORD dwDevID
, HDRVR16 hDriv
, DWORD wMsg
,
1534 DWORD dwParam1
, DWORD dwParam2
)
1537 case DRV_LOAD
: return 1;
1538 case DRV_FREE
: return 1;
1539 case DRV_OPEN
: return 1;
1540 case DRV_CLOSE
: return 1;
1541 case DRV_ENABLE
: return 1;
1542 case DRV_DISABLE
: return 1;
1543 case DRV_QUERYCONFIGURE
: return 1;
1544 case DRV_CONFIGURE
: MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1545 case DRV_INSTALL
: return DRVCNF_RESTART
;
1546 case DRV_REMOVE
: return DRVCNF_RESTART
;
1548 TRACE(midi
, "Sending msg=%lu to default driver proc\n", wMsg
);
1549 return DefDriverProc16(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1553 /**************************************************************************
1554 * MIDI_DriverProc16 [sample driver]
1556 LONG
MIDI_DriverProc16(DWORD dwDevID
, HDRVR16 hDriv
, WORD wMsg
,
1557 DWORD dwParam1
, DWORD dwParam2
)
1560 case DRV_LOAD
: return 1;
1561 case DRV_FREE
: return 1;
1562 case DRV_OPEN
: return 1;
1563 case DRV_CLOSE
: return 1;
1564 case DRV_ENABLE
: return 1;
1565 case DRV_DISABLE
: return 1;
1566 case DRV_QUERYCONFIGURE
: return 1;
1567 case DRV_CONFIGURE
: MessageBoxA(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK
); return 1;
1568 case DRV_INSTALL
: return DRVCNF_RESTART
;
1569 case DRV_REMOVE
: return DRVCNF_RESTART
;
1571 TRACE(midi
, "Sending msg=%u to default driver proc\n", wMsg
);
1572 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
1576 /*-----------------------------------------------------------------------*/