2 * Sample MIDI Wine Driver for Linux
4 * Copyright 1994 Martin Ayotte
6 static char Copyright[] = "Copyright Martin Ayotte, 1994";
9 #define BUILTIN_MMSYSTEM
12 #ifdef BUILTIN_MMSYSTEM
18 #include <sys/ioctl.h>
25 /* #define DEBUG_MIDI */
29 #include <linux/soundcard.h>
33 #define MIDI_DEV "/dev/sequencer"
36 #define IOCTL(a,b,c) ioctl(a,b,&c)
38 #define IOCTL(a,b,c) (c = ioctl(a,b,c) )
41 #define MAX_MIDIINDRV 2
42 #define MAX_MIDIOUTDRV 2
43 #define MAX_MCIMIDIDRV 2
49 MIDIOPENDESC midiDesc
;
59 MIDIOPENDESC midiDesc
;
66 int nUseCount
; /* Incremented for each shared open */
67 BOOL fShareable
; /* TRUE if first open was shareable */
68 WORD wNotifyDeviceID
; /* MCI device ID with a pending notification */
69 HANDLE hCallback
; /* Callback handle for pending notification */
70 HMMIO hFile
; /* mmio file handle open as Element */
76 MCI_OPEN_PARMS openParms
;
81 static LINUX_MIDIIN MidiInDev
[MAX_MIDIINDRV
];
82 static LINUX_MIDIOUT MidiOutDev
[MAX_MIDIOUTDRV
];
83 static LINUX_MCIMIDI MCIMidiDev
[MAX_MCIMIDIDRV
];
86 DWORD
MIDI_mciOpen(DWORD dwFlags
, LPMCI_OPEN_PARMS lpParms
);
87 DWORD
MIDI_mciClose(UINT wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
);
88 DWORD
MIDI_mciPlay(UINT wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
);
89 DWORD
MIDI_mciRecord(UINT wDevID
, DWORD dwFlags
, LPMCI_RECORD_PARMS lpParms
);
90 DWORD
MIDI_mciStop(UINT wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
);
91 DWORD
MIDI_mciPause(UINT wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
);
92 DWORD
MIDI_mciResume(UINT wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
);
93 DWORD
MIDI_mciSet(UINT wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
);
94 DWORD
MIDI_mciStatus(UINT wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
);
95 DWORD
MIDI_mciGetDevCaps(UINT wDevID
, DWORD dwFlags
, LPMCI_GETDEVCAPS_PARMS lpParms
);
96 DWORD
MIDI_mciInfo(UINT wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS lpParms
);
98 DWORD
modOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
);
99 DWORD
modClose(WORD wDevID
);
100 DWORD
modGetDevCaps(WORD wDevID
, LPMIDIOUTCAPS lpCaps
, DWORD dwSize
);
101 DWORD
modPrepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
);
102 DWORD
modUnprepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
);
103 DWORD
modLongData(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
);
104 DWORD
modData(WORD wDevID
, DWORD dwParam
);
106 DWORD
midOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
);
107 DWORD
midClose(WORD wDevID
);
108 DWORD
midGetDevCaps(WORD wDevID
, LPMIDIINCAPS lpCaps
, DWORD dwSize
);
110 /**************************************************************************
111 * MIDI_NotifyClient [internal]
113 DWORD
MIDI_NotifyClient(UINT wDevID
, WORD wMsg
,
114 DWORD dwParam1
, DWORD dwParam2
)
117 if (MidiInDev
[wDevID
].wFlags
!= DCB_NULL
&& !DriverCallback(
118 MidiInDev
[wDevID
].midiDesc
.dwCallback
, MidiInDev
[wDevID
].wFlags
,
119 MidiInDev
[wDevID
].midiDesc
.hMidi
, wMsg
,
120 MidiInDev
[wDevID
].midiDesc
.dwInstance
, dwParam1
, dwParam2
)) {
121 printf("MIDI_NotifyClient // can't notify client !\n");
122 return MMSYSERR_NOERROR
;
126 return MMSYSERR_NOTENABLED
;
131 /**************************************************************************
132 * AUDIO_DriverProc [sample driver]
134 LRESULT
MIDI_DriverProc(DWORD dwDevID
, HDRVR hDriv
, WORD wMsg
,
135 DWORD dwParam1
, DWORD dwParam2
)
151 case DRV_QUERYCONFIGURE
:
154 MessageBox((HWND
)NULL
, "Sample Midi Linux Driver !",
155 "MMLinux Driver", MB_OK
);
158 return (LRESULT
)DRVCNF_RESTART
;
160 return (LRESULT
)DRVCNF_RESTART
;
161 case MCI_OPEN_DRIVER
:
163 return MIDI_mciOpen(dwParam1
, (LPMCI_OPEN_PARMS
)dwParam2
);
164 case MCI_CLOSE_DRIVER
:
166 return MIDI_mciClose(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
168 return MIDI_mciPlay(dwDevID
, dwParam1
, (LPMCI_PLAY_PARMS
)dwParam2
);
170 return MIDI_mciRecord(dwDevID
, dwParam1
, (LPMCI_RECORD_PARMS
)dwParam2
);
172 return MIDI_mciStop(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
174 return MIDI_mciSet(dwDevID
, dwParam1
, (LPMCI_SET_PARMS
)dwParam2
);
176 return MIDI_mciPause(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
178 return MIDI_mciResume(dwDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
180 return MIDI_mciStatus(dwDevID
, dwParam1
, (LPMCI_STATUS_PARMS
)dwParam2
);
182 return MIDI_mciGetDevCaps(dwDevID
, dwParam1
, (LPMCI_GETDEVCAPS_PARMS
)dwParam2
);
184 return MIDI_mciInfo(dwDevID
, dwParam1
, (LPMCI_INFO_PARMS
)dwParam2
);
186 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
189 return MMSYSERR_NOTENABLED
;
194 /**************************************************************************
195 * MIDI_ReadByte [internal]
197 DWORD
MIDI_ReadByte(UINT wDevID
, BYTE FAR
*lpbyt
)
201 if (mmioRead(MCIMidiDev
[wDevID
].hFile
, (HPSTR
)lpbyt
,
202 (long) sizeof(BYTE
)) == (long) sizeof(BYTE
)) {
206 printf("MIDI_ReadByte // error reading wDevID=%d \n", wDevID
);
207 return MCIERR_INTERNAL
;
210 return MMSYSERR_NOTENABLED
;
215 /**************************************************************************
216 * MIDI_ReadWord [internal]
218 DWORD
MIDI_ReadWord(UINT wDevID
, LPWORD lpw
)
222 if (MIDI_ReadByte(wDevID
, &hibyte
) == 0) {
223 if (MIDI_ReadByte(wDevID
, &lobyte
) == 0) {
224 *lpw
= ((WORD
)hibyte
<< 8) + lobyte
;
229 printf("MIDI_ReadWord // error reading wDevID=%d \n", wDevID
);
230 return MCIERR_INTERNAL
;
234 /**************************************************************************
235 * MIDI_ReadLong [internal]
237 DWORD
MIDI_ReadLong(UINT wDevID
, LPDWORD lpdw
)
241 if (MIDI_ReadWord(wDevID
, &hiword
) == 0) {
242 if (MIDI_ReadWord(wDevID
, &loword
) == 0) {
243 *lpdw
= MAKELONG(loword
, hiword
);
248 printf("MIDI_ReadLong // error reading wDevID=%d \n", wDevID
);
249 return MCIERR_INTERNAL
;
253 /**************************************************************************
254 * MIDI_ReadVaryLen [internal]
256 DWORD
MIDI_ReadVaryLen(UINT wDevID
, LPDWORD lpdw
)
260 if (lpdw
== NULL
) return MCIERR_INTERNAL
;
261 if (MIDI_ReadByte(wDevID
, &byte
) != 0) {
262 printf("MIDI_ReadVaryLen // error reading wDevID=%d \n", wDevID
);
263 return MCIERR_INTERNAL
;
265 value
= (DWORD
)(byte
& 0x7F);
266 while (byte
& 0x80) {
267 if (MIDI_ReadByte(wDevID
, &byte
) != 0) {
268 printf("MIDI_ReadVaryLen // error reading wDevID=%d \n", wDevID
);
269 return MCIERR_INTERNAL
;
271 value
= (value
<< 7) + (byte
& 0x7F);
275 printf("MIDI_ReadVaryLen // val=%08lX \n", value);
281 /**************************************************************************
282 * MIDI_ReadMThd [internal]
284 DWORD
MIDI_ReadMThd(UINT wDevID
, DWORD dwOffset
)
289 dprintf_midi(stddeb
, "MIDI_ReadMThd(%04X, %08lX);\n", wDevID
, dwOffset
);
290 if (mmioSeek(MCIMidiDev
[wDevID
].hFile
, dwOffset
, SEEK_SET
) != dwOffset
) {
291 printf("MIDI_ReadMThd // can't seek at %08lX begin of 'MThd' \n", dwOffset
);
292 return MCIERR_INTERNAL
;
294 if (mmioRead(MCIMidiDev
[wDevID
].hFile
, (HPSTR
)&fourcc
,
295 (long) sizeof(FOURCC
)) != (long) sizeof(FOURCC
)) {
296 return MCIERR_INTERNAL
;
298 if (MIDI_ReadLong(wDevID
, &toberead
) != 0) {
299 return MCIERR_INTERNAL
;
301 if (MIDI_ReadWord(wDevID
, &MCIMidiDev
[wDevID
].wFormat
) != 0) {
302 return MCIERR_INTERNAL
;
304 if (MIDI_ReadWord(wDevID
, &MCIMidiDev
[wDevID
].nTracks
) != 0) {
305 return MCIERR_INTERNAL
;
307 if (MIDI_ReadWord(wDevID
, &MCIMidiDev
[wDevID
].nTempo
) != 0) {
308 return MCIERR_INTERNAL
;
310 printf("MIDI_ReadMThd // toberead=%08lX, wFormat=%04X nTracks=%04X nTempo=%04X\n",
311 toberead
, MCIMidiDev
[wDevID
].wFormat
,
312 MCIMidiDev
[wDevID
].nTracks
,
313 MCIMidiDev
[wDevID
].nTempo
);
314 toberead
-= 3 * sizeof(WORD
);
316 ntrks = read16bit ();
317 Mf_division = division = read16bit ();
322 return MMSYSERR_NOTENABLED
;
327 DWORD
MIDI_ReadMTrk(UINT wDevID
, DWORD dwOffset
)
332 if (mmioSeek(MCIMidiDev
[wDevID
].hFile
, dwOffset
, SEEK_SET
) != dwOffset
) {
333 printf("MIDI_ReadMTrk // can't seek at %08lX begin of 'MThd' \n", dwOffset
);
335 if (mmioRead(MCIMidiDev
[wDevID
].hFile
, (HPSTR
)&fourcc
,
336 (long) sizeof(FOURCC
)) != (long) sizeof(FOURCC
)) {
337 return MCIERR_INTERNAL
;
339 if (MIDI_ReadLong(wDevID
, &toberead
) != 0) {
340 return MCIERR_INTERNAL
;
342 printf("MIDI_ReadMTrk // toberead=%08lX\n", toberead
);
343 toberead
-= 3 * sizeof(WORD
);
344 MCIMidiDev
[wDevID
].dwTotalLen
= toberead
;
347 return MMSYSERR_NOTENABLED
;
352 /**************************************************************************
353 * MIDI_mciOpen [internal]
355 DWORD
MIDI_mciOpen(DWORD dwFlags
, LPMCI_OPEN_PARMS lpParms
)
359 MIDIOPENDESC MidiDesc
;
364 dprintf_midi( stddeb
, "MIDI_mciOpen(%08lX, %p)\n", dwFlags
, lpParms
);
365 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
366 wDevID
= lpParms
->wDeviceID
;
367 if (MCIMidiDev
[wDevID
].nUseCount
> 0) {
368 /* The driver already open on this channel */
369 /* If the driver was opened shareable before and this open specifies */
370 /* shareable then increment the use count */
371 if (MCIMidiDev
[wDevID
].fShareable
&& (dwFlags
& MCI_OPEN_SHAREABLE
))
372 ++MCIMidiDev
[wDevID
].nUseCount
;
374 return MCIERR_MUST_USE_SHAREABLE
;
377 MCIMidiDev
[wDevID
].nUseCount
= 1;
378 MCIMidiDev
[wDevID
].fShareable
= dwFlags
& MCI_OPEN_SHAREABLE
;
380 if (dwFlags
& MCI_OPEN_ELEMENT
) {
381 printf("MIDI_mciOpen // MCI_OPEN_ELEMENT '%s' !\n",
382 lpParms
->lpstrElementName
);
383 /* printf("MIDI_mciOpen // cdw='%s'\n", DOS_GetCurrentDir(DOS_GetDefaultDrive())); */
384 if (strlen(lpParms
->lpstrElementName
) > 0) {
385 strcpy(str
, lpParms
->lpstrElementName
);
387 MCIMidiDev
[wDevID
].hFile
= mmioOpen(str
, NULL
,
388 MMIO_ALLOCBUF
| MMIO_READWRITE
| MMIO_EXCLUSIVE
);
389 if (MCIMidiDev
[wDevID
].hFile
== 0) {
390 printf("MIDI_mciOpen // can't find file='%s' !\n", str
);
391 return MCIERR_FILE_NOT_FOUND
;
395 MCIMidiDev
[wDevID
].hFile
= 0;
397 printf("MIDI_mciOpen // hFile=%u\n", MCIMidiDev
[wDevID
].hFile
);
398 memcpy(&MCIMidiDev
[wDevID
].openParms
, lpParms
, sizeof(MCI_OPEN_PARMS
));
399 MCIMidiDev
[wDevID
].wNotifyDeviceID
= lpParms
->wDeviceID
;
400 MCIMidiDev
[wDevID
].dwStatus
= MCI_MODE_STOP
;
401 MCIMidiDev
[wDevID
].dwBeginData
= 0;
402 MCIMidiDev
[wDevID
].dwTotalLen
= 0;
404 if (MCIMidiDev
[wDevID
].hFile
!= 0) {
406 if (mmioDescend(MCIMidiDev
[wDevID
].hFile
, &ckMainRIFF
, NULL
, 0) != 0) {
407 return MCIERR_INTERNAL
;
409 dprintf_midi(stddeb
,"MIDI_mciOpen // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
410 (LPSTR
)&ckMainRIFF
.ckid
, (LPSTR
)&ckMainRIFF
.fccType
,
413 if (ckMainRIFF
.ckid
== mmioFOURCC('R', 'M', 'I', 'D')) {
414 printf("MIDI_mciOpen // is a 'RMID' file \n");
415 dwOffset
= ckMainRIFF
.dwDataOffset
;
417 if (ckMainRIFF
.ckid
!= mmioFOURCC('M', 'T', 'h', 'd')) {
418 printf("MIDI_mciOpen // unknown format !\n");
419 return MCIERR_INTERNAL
;
421 if (MIDI_ReadMThd(wDevID
, dwOffset
) != 0) {
422 printf("MIDI_mciOpen // can't read 'MThd' header \n");
423 return MCIERR_INTERNAL
;
425 dwOffset
= mmioSeek(MCIMidiDev
[wDevID
].hFile
, 0, SEEK_CUR
);
426 if (MIDI_ReadMTrk(wDevID
, dwOffset
) != 0) {
427 printf("MIDI_mciOpen // can't read 'MTrk' header \n");
428 return MCIERR_INTERNAL
;
430 dwOffset
= mmioSeek(MCIMidiDev
[wDevID
].hFile
, 0, SEEK_CUR
);
431 MCIMidiDev
[wDevID
].dwBeginData
= dwOffset
;
432 dprintf_midi(stddeb
,"MIDI_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
433 (LPSTR
)&ckMainRIFF
.ckid
, (LPSTR
)&ckMainRIFF
.fccType
,
436 dwRet
= modMessage(0, MODM_OPEN
, 0, (DWORD
)&MidiDesc
, CALLBACK_NULL
);
437 dwRet
= midMessage(0, MIDM_OPEN
, 0, (DWORD
)&MidiDesc
, CALLBACK_NULL
);
440 return MMSYSERR_NOTENABLED
;
445 /**************************************************************************
446 * MIDI_mciClose [internal]
448 DWORD
MIDI_mciClose(UINT wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
453 printf("MIDI_mciClose(%u, %08lX, %p);\n", wDevID
, dwParam
, lpParms
);
455 if (MCIMidiDev
[wDevID
].dwStatus
!= MCI_MODE_STOP
) {
456 MIDI_mciStop(wDevID
, MCI_WAIT
, lpParms
);
458 MCIMidiDev
[wDevID
].dwStatus
= MCI_MODE_STOP
;
459 MCIMidiDev
[wDevID
].nUseCount
--;
460 if (MCIMidiDev
[wDevID
].nUseCount
== 0) {
461 if (MCIMidiDev
[wDevID
].hFile
!= 0) {
462 mmioClose(MCIMidiDev
[wDevID
].hFile
, 0);
463 MCIMidiDev
[wDevID
].hFile
= 0;
464 printf("MIDI_mciClose // hFile closed !\n");
466 dwRet
= modMessage(0, MODM_CLOSE
, 0, 0L, 0L);
467 if (dwRet
!= MMSYSERR_NOERROR
) return MCIERR_INTERNAL
;
468 dwRet
= midMessage(0, MIDM_CLOSE
, 0, 0L, 0L);
469 if (dwRet
!= MMSYSERR_NOERROR
) return MCIERR_INTERNAL
;
478 /**************************************************************************
479 * MIDI_mciPlay [internal]
481 DWORD
MIDI_mciPlay(UINT wDevID
, DWORD dwFlags
, LPMCI_PLAY_PARMS lpParms
)
491 printf("MIDI_mciPlay(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
493 if (MCIMidiDev
[wDevID
].hFile
== 0) {
494 printf("MIDI_mciPlay // can't find file='%s' !\n",
495 MCIMidiDev
[wDevID
].openParms
.lpstrElementName
);
496 return MCIERR_FILE_NOT_FOUND
;
498 start
= 1; end
= 99999;
499 if (dwFlags
& MCI_FROM
) {
500 start
= lpParms
->dwFrom
;
501 printf("MIDI_mciPlay // MCI_FROM=%d \n", start
);
503 if (dwFlags
& MCI_TO
) {
505 printf("MIDI_mciPlay // MCI_TO=%d \n", end
);
508 if (dwFlags
& MCI_NOTIFY
) {
509 printf("MIDI_mciPlay // MCI_NOTIFY %08lX !\n", lpParms
->dwCallback
);
512 printf("MIDI_mciPlay // Can't 'fork' process !\n");
515 printf("MIDI_mciPlay // process started ! play in background ...\n");
518 printf("MIDI_mciPlay // process started ! return to caller...\n");
523 lpMidiHdr
= &MCIMidiDev
[wDevID
].MidiHdr
;
524 lpMidiHdr
->lpData
= (LPSTR
) malloc(1200);
525 if (lpMidiHdr
->lpData
== NULL
) return MCIERR_INTERNAL
;
526 lpMidiHdr
->dwBufferLength
= 1024;
527 lpMidiHdr
->dwUser
= 0L;
528 lpMidiHdr
->dwFlags
= 0L;
529 dwRet
= modMessage(0, MODM_PREPARE
, 0, (DWORD
)lpMidiHdr
, sizeof(MIDIHDR
));
530 /* printf("MIDI_mciPlay // after MODM_PREPARE \n"); */
531 MCIMidiDev
[wDevID
].dwStatus
= MCI_MODE_PLAY
;
532 while(MCIMidiDev
[wDevID
].dwStatus
!= MCI_MODE_STOP
) {
533 printf("MIDI_mciPlay // MCIMidiDev[wDevID].dwStatus=%p %d\n",
534 &MCIMidiDev
[wDevID
].dwStatus
, MCIMidiDev
[wDevID
].dwStatus
);
535 ptr
= (LPWORD
)lpMidiHdr
->lpData
;
536 for (count
= 0; count
< lpMidiHdr
->dwBufferLength
; count
++) {
537 if (MIDI_ReadVaryLen(wDevID
, &dwData
) != 0) break;
538 *ptr
= LOWORD(dwData
);
541 count = mmioRead(MCIMidiDev[wDevID].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength);
543 if (count
< 1) break;
544 lpMidiHdr
->dwBytesRecorded
= count
;
546 printf("MIDI_mciPlay // before MODM_LONGDATA lpMidiHdr=%p dwBytesRecorded=%lu\n",
547 lpMidiHdr
, lpMidiHdr
->dwBytesRecorded
);
549 dwRet
= modMessage(0, MODM_LONGDATA
, 0, (DWORD
)lpMidiHdr
, sizeof(MIDIHDR
));
551 dwRet
= modMessage(0, MODM_UNPREPARE
, 0, (DWORD
)lpMidiHdr
, sizeof(MIDIHDR
));
552 if (lpMidiHdr
->lpData
!= NULL
) {
553 free(lpMidiHdr
->lpData
);
554 lpMidiHdr
->lpData
= NULL
;
556 MCIMidiDev
[wDevID
].dwStatus
= MCI_MODE_STOP
;
557 if (dwFlags
& MCI_NOTIFY
) {
559 printf("MIDI_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
561 mciDriverNotify((HWND
)LOWORD(lpParms
->dwCallback
),
562 MCIMidiDev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
567 return MMSYSERR_NOTENABLED
;
572 /**************************************************************************
573 * MIDI_mciRecord [internal]
575 DWORD
MIDI_mciRecord(UINT wDevID
, DWORD dwFlags
, LPMCI_RECORD_PARMS lpParms
)
582 dprintf_midi( stddeb
, "MIDI_mciRecord(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
583 if (MCIMidiDev
[wDevID
].hFile
== 0) {
584 printf("MIDI_mciRecord // can't find file='%s' !\n",
585 MCIMidiDev
[wDevID
].openParms
.lpstrElementName
);
586 return MCIERR_FILE_NOT_FOUND
;
588 start
= 1; end
= 99999;
589 if (dwFlags
& MCI_FROM
) {
590 start
= lpParms
->dwFrom
;
591 printf("MIDI_mciRecord // MCI_FROM=%d \n", start
);
593 if (dwFlags
& MCI_TO
) {
595 printf("MIDI_mciRecord // MCI_TO=%d \n", end
);
597 lpMidiHdr
= &MCIMidiDev
[wDevID
].MidiHdr
;
598 lpMidiHdr
->lpData
= (LPSTR
) malloc(1200);
599 lpMidiHdr
->dwBufferLength
= 1024;
600 lpMidiHdr
->dwUser
= 0L;
601 lpMidiHdr
->dwFlags
= 0L;
602 dwRet
= midMessage(0, MIDM_PREPARE
, 0, (DWORD
)lpMidiHdr
, sizeof(MIDIHDR
));
603 printf("MIDI_mciRecord // after MIDM_PREPARE \n");
604 MCIMidiDev
[wDevID
].dwStatus
= MCI_MODE_RECORD
;
605 while(MCIMidiDev
[wDevID
].dwStatus
!= MCI_MODE_STOP
) {
606 printf("MIDI_mciRecord // MCIMidiDev[wDevID].dwStatus=%p %d\n",
607 &MCIMidiDev
[wDevID
].dwStatus
, MCIMidiDev
[wDevID
].dwStatus
);
608 lpMidiHdr
->dwBytesRecorded
= 0;
609 dwRet
= midMessage(0, MIDM_START
, 0, 0L, 0L);
610 printf("MIDI_mciRecord // after MIDM_START lpMidiHdr=%p dwBytesRecorded=%lu\n",
611 lpMidiHdr
, lpMidiHdr
->dwBytesRecorded
);
612 if (lpMidiHdr
->dwBytesRecorded
== 0) break;
614 printf("MIDI_mciRecord // before MIDM_UNPREPARE \n");
615 dwRet
= midMessage(0, MIDM_UNPREPARE
, 0, (DWORD
)lpMidiHdr
, sizeof(MIDIHDR
));
616 printf("MIDI_mciRecord // after MIDM_UNPREPARE \n");
617 if (lpMidiHdr
->lpData
!= NULL
) {
618 free(lpMidiHdr
->lpData
);
619 lpMidiHdr
->lpData
= NULL
;
621 MCIMidiDev
[wDevID
].dwStatus
= MCI_MODE_STOP
;
622 if (dwFlags
& MCI_NOTIFY
) {
624 printf("MIDI_mciRecord // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
626 mciDriverNotify((HWND
)LOWORD(lpParms
->dwCallback
),
627 MCIMidiDev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
631 return MMSYSERR_NOTENABLED
;
636 /**************************************************************************
637 * MIDI_mciStop [internal]
639 DWORD
MIDI_mciStop(UINT wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
643 printf("MIDI_mciStop(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
645 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
646 MCIMidiDev
[wDevID
].dwStatus
= MCI_MODE_STOP
;
647 printf("MIDI_mciStop // MCIMidiDev[wDevID].dwStatus=%p %d\n",
648 &MCIMidiDev
[wDevID
].dwStatus
, MCIMidiDev
[wDevID
].dwStatus
);
651 return MCIERR_INTERNAL
;
656 /**************************************************************************
657 * MIDI_mciPause [internal]
659 DWORD
MIDI_mciPause(UINT wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
663 printf("MIDI_mciPause(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
665 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
668 return MCIERR_INTERNAL
;
673 /**************************************************************************
674 * MIDI_mciResume [internal]
676 DWORD
MIDI_mciResume(UINT wDevID
, DWORD dwFlags
, LPMCI_GENERIC_PARMS lpParms
)
680 printf("MIDI_mciResume(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
682 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
685 return MCIERR_INTERNAL
;
690 /**************************************************************************
691 * MIDI_mciSet [internal]
693 DWORD
MIDI_mciSet(UINT wDevID
, DWORD dwFlags
, LPMCI_SET_PARMS lpParms
)
697 printf("MIDI_mciSet(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
699 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
701 printf("MIDI_mciSet // dwTimeFormat=%08lX\n", lpParms
->dwTimeFormat
);
702 printf("MIDI_mciSet // dwAudio=%08lX\n", lpParms
->dwAudio
);
704 if (dwFlags
& MCI_SET_TIME_FORMAT
) {
705 switch (lpParms
->dwTimeFormat
) {
706 case MCI_FORMAT_MILLISECONDS
:
707 printf("MIDI_mciSet // MCI_FORMAT_MILLISECONDS !\n");
709 case MCI_FORMAT_BYTES
:
710 printf("MIDI_mciSet // MCI_FORMAT_BYTES !\n");
712 case MCI_FORMAT_SAMPLES
:
713 printf("MIDI_mciSet // MCI_FORMAT_SAMPLES !\n");
716 printf("MIDI_mciSet // bad time format !\n");
717 return MCIERR_BAD_TIME_FORMAT
;
720 if (dwFlags
& MCI_SET_VIDEO
) return MCIERR_UNSUPPORTED_FUNCTION
;
721 if (dwFlags
& MCI_SET_DOOR_OPEN
) return MCIERR_UNSUPPORTED_FUNCTION
;
722 if (dwFlags
& MCI_SET_DOOR_CLOSED
) return MCIERR_UNSUPPORTED_FUNCTION
;
723 if (dwFlags
& MCI_SET_AUDIO
) {
724 printf("MIDI_mciSet // MCI_SET_AUDIO !\n");
726 if (dwFlags
&& MCI_SET_ON
) {
727 printf("MIDI_mciSet // MCI_SET_ON !\n");
728 if (dwFlags
&& MCI_SET_AUDIO_LEFT
) {
729 printf("MIDI_mciSet // MCI_SET_AUDIO_LEFT !\n");
731 if (dwFlags
&& MCI_SET_AUDIO_RIGHT
) {
732 printf("MIDI_mciSet // MCI_SET_AUDIO_RIGHT !\n");
735 if (dwFlags
& MCI_SET_OFF
) {
736 printf("MIDI_mciSet // MCI_SET_OFF !\n");
738 if (dwFlags
& MCI_SEQ_SET_MASTER
) {
739 printf("MIDI_mciSet // MCI_SEQ_SET_MASTER !\n");
741 if (dwFlags
& MCI_SEQ_SET_SLAVE
) {
742 printf("MIDI_mciSet // MCI_SEQ_SET_SLAVE !\n");
744 if (dwFlags
& MCI_SEQ_SET_OFFSET
) {
745 printf("MIDI_mciSet // MCI_SEQ_SET_OFFSET !\n");
747 if (dwFlags
& MCI_SEQ_SET_PORT
) {
748 printf("MIDI_mciSet // MCI_SEQ_SET_PORT !\n");
750 if (dwFlags
& MCI_SEQ_SET_TEMPO
) {
751 printf("MIDI_mciSet // MCI_SEQ_SET_TEMPO !\n");
755 return MCIERR_INTERNAL
;
760 /**************************************************************************
761 * MIDI_mciStatus [internal]
763 DWORD
MIDI_mciStatus(UINT wDevID
, DWORD dwFlags
, LPMCI_STATUS_PARMS lpParms
)
767 printf("MIDI_mciStatus(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
769 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
770 if (dwFlags
& MCI_STATUS_ITEM
) {
771 switch(lpParms
->dwItem
) {
772 case MCI_STATUS_CURRENT_TRACK
:
773 lpParms
->dwReturn
= 1;
775 case MCI_STATUS_LENGTH
:
776 lpParms
->dwReturn
= 5555;
777 if (dwFlags
& MCI_TRACK
) {
778 lpParms
->dwTrack
= 1;
779 lpParms
->dwReturn
= 2222;
782 case MCI_STATUS_MODE
:
783 lpParms
->dwReturn
= MCI_MODE_STOP
;
785 case MCI_STATUS_MEDIA_PRESENT
:
786 printf("MIDI_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
787 lpParms
->dwReturn
= TRUE
;
789 case MCI_STATUS_NUMBER_OF_TRACKS
:
790 lpParms
->dwReturn
= 1;
792 case MCI_STATUS_POSITION
:
793 lpParms
->dwReturn
= 3333;
794 if (dwFlags
& MCI_STATUS_START
) {
797 if (dwFlags
& MCI_TRACK
) {
798 lpParms
->dwTrack
= 1;
799 lpParms
->dwReturn
= 777;
802 case MCI_STATUS_READY
:
803 printf("MIDI_mciStatus // MCI_STATUS_READY !\n");
804 lpParms
->dwReturn
= TRUE
;
806 case MCI_STATUS_TIME_FORMAT
:
807 printf("MIDI_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
808 lpParms
->dwReturn
= MCI_FORMAT_MILLISECONDS
;
810 case MCI_SEQ_STATUS_DIVTYPE
:
811 printf("MIDI_mciStatus // MCI_SEQ_STATUS_DIVTYPE !\n");
812 lpParms
->dwReturn
= 0;
814 case MCI_SEQ_STATUS_MASTER
:
815 printf("MIDI_mciStatus // MCI_SEQ_STATUS_MASTER !\n");
816 lpParms
->dwReturn
= 0;
818 case MCI_SEQ_STATUS_SLAVE
:
819 printf("MIDI_mciStatus // MCI_SEQ_STATUS_SLAVE !\n");
820 lpParms
->dwReturn
= 0;
822 case MCI_SEQ_STATUS_OFFSET
:
823 printf("MIDI_mciStatus // MCI_SEQ_STATUS_OFFSET !\n");
824 lpParms
->dwReturn
= 0;
826 case MCI_SEQ_STATUS_PORT
:
827 printf("MIDI_mciStatus // MCI_SEQ_STATUS_PORT !\n");
828 lpParms
->dwReturn
= 0;
830 case MCI_SEQ_STATUS_TEMPO
:
831 printf("MIDI_mciStatus // MCI_SEQ_STATUS_TEMPO !\n");
832 lpParms
->dwReturn
= 0;
835 printf("MIDI_mciStatus // unknowm command %08lX !\n", lpParms
->dwItem
);
836 return MCIERR_UNRECOGNIZED_COMMAND
;
839 if (dwFlags
& MCI_NOTIFY
) {
840 printf("MIDI_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms
->dwCallback
);
841 mciDriverNotify((HWND
)LOWORD(lpParms
->dwCallback
),
842 MCIMidiDev
[wDevID
].wNotifyDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
846 return MCIERR_INTERNAL
;
850 /**************************************************************************
851 * MIDI_mciGetDevCaps [internal]
853 DWORD
MIDI_mciGetDevCaps(UINT wDevID
, DWORD dwFlags
,
854 LPMCI_GETDEVCAPS_PARMS lpParms
)
857 printf("MIDI_mciGetDevCaps(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
858 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
859 if (dwFlags
& MCI_GETDEVCAPS_ITEM
) {
860 switch(lpParms
->dwItem
) {
861 case MCI_GETDEVCAPS_CAN_RECORD
:
862 lpParms
->dwReturn
= TRUE
;
864 case MCI_GETDEVCAPS_HAS_AUDIO
:
865 lpParms
->dwReturn
= TRUE
;
867 case MCI_GETDEVCAPS_HAS_VIDEO
:
868 lpParms
->dwReturn
= FALSE
;
870 case MCI_GETDEVCAPS_DEVICE_TYPE
:
871 lpParms
->dwReturn
= MCI_DEVTYPE_SEQUENCER
;
873 case MCI_GETDEVCAPS_USES_FILES
:
874 lpParms
->dwReturn
= TRUE
;
876 case MCI_GETDEVCAPS_COMPOUND_DEVICE
:
877 lpParms
->dwReturn
= TRUE
;
879 case MCI_GETDEVCAPS_CAN_EJECT
:
880 lpParms
->dwReturn
= FALSE
;
882 case MCI_GETDEVCAPS_CAN_PLAY
:
883 lpParms
->dwReturn
= TRUE
;
885 case MCI_GETDEVCAPS_CAN_SAVE
:
886 lpParms
->dwReturn
= FALSE
;
889 return MCIERR_UNRECOGNIZED_COMMAND
;
894 return MCIERR_INTERNAL
;
898 /**************************************************************************
899 * MIDI_mciInfo [internal]
901 DWORD
MIDI_mciInfo(UINT wDevID
, DWORD dwFlags
, LPMCI_INFO_PARMS lpParms
)
904 printf("MIDI_mciInfo(%u, %08lX, %p);\n", wDevID
, dwFlags
, lpParms
);
905 if (lpParms
== NULL
) return MCIERR_INTERNAL
;
906 lpParms
->lpstrReturn
= NULL
;
908 case MCI_INFO_PRODUCT
:
909 lpParms
->lpstrReturn
= "Linux Sound System 0.5";
912 lpParms
->lpstrReturn
= "FileName";
915 return MCIERR_UNRECOGNIZED_COMMAND
;
917 if (lpParms
->lpstrReturn
!= NULL
)
918 lpParms
->dwRetSize
= strlen(lpParms
->lpstrReturn
);
920 lpParms
->dwRetSize
= 0;
923 return MCIERR_INTERNAL
;
928 /*-----------------------------------------------------------------------*/
931 /**************************************************************************
932 * midGetDevCaps [internal]
934 DWORD
midGetDevCaps(WORD wDevID
, LPMIDIINCAPS lpCaps
, DWORD dwSize
)
936 printf("midGetDevCaps(%u, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
937 return MMSYSERR_NOTENABLED
;
940 /**************************************************************************
943 DWORD
midOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
948 "midOpen(%u, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
949 if (lpDesc
== NULL
) {
950 fprintf(stderr
,"Linux 'midOpen' // Invalid Parameter !\n");
951 return MMSYSERR_INVALPARAM
;
953 if (wDevID
>= MAX_MIDIINDRV
) {
954 fprintf(stderr
,"Linux 'midOpen' // MAX_MIDIINDRV reached !\n");
955 return MMSYSERR_ALLOCATED
;
957 MidiInDev
[wDevID
].unixdev
= 0;
958 midi
= open (MIDI_DEV
, O_RDONLY
, 0);
960 fprintf(stderr
,"Linux 'midOpen' // can't open !\n");
961 return MMSYSERR_NOTENABLED
;
963 MidiInDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
964 switch(MidiInDev
[wDevID
].wFlags
) {
966 fprintf(stderr
,"Linux 'midOpen' // CALLBACK_NULL !\n");
970 "Linux 'midOpen' // CALLBACK_WINDOW !\n");
974 "Linux 'midOpen' // CALLBACK_TASK !\n");
978 "Linux 'midOpen' // CALLBACK_FUNCTION !\n");
981 MidiInDev
[wDevID
].lpQueueHdr
= NULL
;
982 MidiInDev
[wDevID
].unixdev
= midi
;
983 MidiInDev
[wDevID
].dwTotalPlayed
= 0;
984 MidiInDev
[wDevID
].bufsize
= 0x3FFF;
985 if (MIDI_NotifyClient(wDevID
, MIM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
986 fprintf(stderr
,"Linux 'midOpen' // can't notify client !\n");
987 return MMSYSERR_INVALPARAM
;
989 return MMSYSERR_NOERROR
;
991 return MMSYSERR_NOTENABLED
;
995 /**************************************************************************
996 * midClose [internal]
998 DWORD
midClose(WORD wDevID
)
1001 dprintf_midi(stddeb
,"midClose(%u);\n", wDevID
);
1002 if (MidiInDev
[wDevID
].unixdev
== 0) {
1003 fprintf(stderr
,"Linux 'midClose' // can't close !\n");
1004 return MMSYSERR_NOTENABLED
;
1006 close(MidiInDev
[wDevID
].unixdev
);
1007 MidiInDev
[wDevID
].unixdev
= 0;
1008 MidiInDev
[wDevID
].bufsize
= 0;
1009 if (MIDI_NotifyClient(wDevID
, MIM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
1010 fprintf(stderr
,"Linux 'midClose' // can't notify client !\n");
1011 return MMSYSERR_INVALPARAM
;
1013 return MMSYSERR_NOERROR
;
1015 return MMSYSERR_NOTENABLED
;
1019 /**************************************************************************
1020 * midAddBuffer [internal]
1022 DWORD
midAddBuffer(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1024 printf("midAddBuffer(%u, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1025 return MMSYSERR_NOTENABLED
;
1028 /**************************************************************************
1029 * midPrepare [internal]
1031 DWORD
midPrepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1033 printf("midPrepare(%u, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1034 return MMSYSERR_NOTENABLED
;
1037 /**************************************************************************
1038 * midUnprepare [internal]
1040 DWORD
midUnprepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1042 printf("midUnprepare(%u, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1043 return MMSYSERR_NOTENABLED
;
1046 /**************************************************************************
1047 * midReset [internal]
1049 DWORD
midReset(WORD wDevID
)
1051 printf("midReset(%u);\n", wDevID
);
1052 return MMSYSERR_NOTENABLED
;
1056 /**************************************************************************
1057 * midStart [internal]
1059 DWORD
midStart(WORD wDevID
)
1061 printf("midStart(%u);\n", wDevID
);
1062 return MMSYSERR_NOTENABLED
;
1066 /**************************************************************************
1067 * midStop [internal]
1069 DWORD
midStop(WORD wDevID
)
1071 printf("midStop(%u);\n", wDevID
);
1072 return MMSYSERR_NOTENABLED
;
1076 /**************************************************************************
1077 * midMessage [sample driver]
1079 DWORD
midMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1080 DWORD dwParam1
, DWORD dwParam2
)
1082 printf("midMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
1083 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1086 return midOpen(wDevID
, (LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1088 return midClose(wDevID
);
1089 case MIDM_ADDBUFFER
:
1090 return midAddBuffer(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1092 return midPrepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1093 case MIDM_UNPREPARE
:
1094 return midUnprepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1095 case MIDM_GETDEVCAPS
:
1096 return midGetDevCaps(wDevID
, (LPMIDIINCAPS
)dwParam1
, dwParam2
);
1097 case MIDM_GETNUMDEVS
:
1100 return midReset(wDevID
);
1102 return midStart(wDevID
);
1104 return midStop(wDevID
);
1106 return MMSYSERR_NOTSUPPORTED
;
1111 /*-----------------------------------------------------------------------*/
1114 /**************************************************************************
1115 * modGetDevCaps [internal]
1117 DWORD
modGetDevCaps(WORD wDevID
, LPMIDIOUTCAPS lpCaps
, DWORD dwSize
)
1119 printf("modGetDevCaps(%u, %p, %08lX);\n", wDevID
, lpCaps
, dwSize
);
1120 return MMSYSERR_NOTENABLED
;
1124 /**************************************************************************
1125 * modOpen [internal]
1127 DWORD
modOpen(WORD wDevID
, LPMIDIOPENDESC lpDesc
, DWORD dwFlags
)
1131 dprintf_midi(stddeb
,
1132 "modOpen(%u, %p, %08lX);\n", wDevID
, lpDesc
, dwFlags
);
1133 if (lpDesc
== NULL
) {
1134 fprintf(stderr
,"Linux 'modOpen' // Invalid Parameter !\n");
1135 return MMSYSERR_INVALPARAM
;
1137 if (wDevID
>= MAX_MIDIOUTDRV
) {
1138 fprintf(stderr
,"Linux 'modOpen' // MAX_MIDIOUTDRV reached !\n");
1139 return MMSYSERR_ALLOCATED
;
1141 MidiOutDev
[wDevID
].unixdev
= 0;
1142 midi
= open (MIDI_DEV
, O_WRONLY
, 0);
1144 fprintf(stderr
,"Linux 'modOpen' // can't open !\n");
1145 return MMSYSERR_NOTENABLED
;
1147 MidiOutDev
[wDevID
].wFlags
= HIWORD(dwFlags
& CALLBACK_TYPEMASK
);
1148 switch(MidiOutDev
[wDevID
].wFlags
) {
1150 fprintf(stderr
,"Linux 'modOpen' // CALLBACK_NULL !\n");
1153 dprintf_midi(stddeb
,
1154 "Linux 'modOpen' // CALLBACK_WINDOW !\n");
1157 dprintf_midi(stddeb
,
1158 "Linux 'modOpen' // CALLBACK_TASK !\n");
1161 dprintf_midi(stddeb
,
1162 "Linux 'modOpen' // CALLBACK_FUNCTION !\n");
1165 MidiOutDev
[wDevID
].lpQueueHdr
= NULL
;
1166 MidiOutDev
[wDevID
].unixdev
= midi
;
1167 MidiOutDev
[wDevID
].dwTotalPlayed
= 0;
1168 MidiOutDev
[wDevID
].bufsize
= 0x3FFF;
1169 if (MIDI_NotifyClient(wDevID
, MOM_OPEN
, 0L, 0L) != MMSYSERR_NOERROR
) {
1170 fprintf(stderr
,"Linux 'modOpen' // can't notify client !\n");
1171 return MMSYSERR_INVALPARAM
;
1173 dprintf_midi(stddeb
,
1174 "Linux 'modOpen' // Succesful unixdev=%d !\n", midi
);
1175 return MMSYSERR_NOERROR
;
1177 return MMSYSERR_NOTENABLED
;
1182 /**************************************************************************
1183 * modClose [internal]
1185 DWORD
modClose(WORD wDevID
)
1188 dprintf_midi(stddeb
,"modClose(%u);\n", wDevID
);
1189 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1190 fprintf(stderr
,"Linux 'modClose' // can't close !\n");
1191 return MMSYSERR_NOTENABLED
;
1193 close(MidiOutDev
[wDevID
].unixdev
);
1194 MidiOutDev
[wDevID
].unixdev
= 0;
1195 MidiOutDev
[wDevID
].bufsize
= 0;
1196 if (MIDI_NotifyClient(wDevID
, MOM_CLOSE
, 0L, 0L) != MMSYSERR_NOERROR
) {
1197 fprintf(stderr
,"Linux 'modClose' // can't notify client !\n");
1198 return MMSYSERR_INVALPARAM
;
1200 return MMSYSERR_NOERROR
;
1202 return MMSYSERR_NOTENABLED
;
1206 /**************************************************************************
1207 * modData [internal]
1209 DWORD
modData(WORD wDevID
, DWORD dwParam
)
1213 dprintf_midi(stddeb
,
1214 "modData(%u, %08lX);\n", wDevID
, dwParam
);
1215 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1216 fprintf(stderr
,"Linux 'modData' // can't play !\n");
1217 return MIDIERR_NODEVICE
;
1219 event
= LOWORD(dwParam
);
1220 if (write (MidiOutDev
[wDevID
].unixdev
,
1221 &event
, sizeof(WORD
)) != sizeof(WORD
)) {
1222 dprintf_midi(stddeb
,
1223 "modData() // error writting unixdev !\n");
1225 return MMSYSERR_NOTENABLED
;
1227 return MMSYSERR_NOTENABLED
;
1231 /**************************************************************************
1232 * modLongData [internal]
1234 DWORD
modLongData(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1239 dprintf_midi(stddeb
,
1240 "modLongData(%u, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1241 printf("modLongData(%u, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1242 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1243 fprintf(stderr
,"Linux 'modLongData' // can't play !\n");
1244 return MIDIERR_NODEVICE
;
1246 if (lpMidiHdr
->lpData
== NULL
) return MIDIERR_UNPREPARED
;
1247 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
)) return MIDIERR_UNPREPARED
;
1248 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
1249 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1250 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
1251 dprintf_midi(stddeb
,
1252 "modLongData() // dwBytesRecorded %lu !\n", lpMidiHdr
->dwBytesRecorded
);
1254 count = write (MidiOutDev[wDevID].unixdev,
1255 lpMidiHdr->lpData, lpMidiHdr->dwBytesRecorded);
1257 ptr
= (LPWORD
)lpMidiHdr
->lpData
;
1258 for (count
= 0; count
< lpMidiHdr
->dwBytesRecorded
; count
++) {
1259 if (write (MidiOutDev
[wDevID
].unixdev
, ptr
,
1260 sizeof(WORD
)) != sizeof(WORD
)) break;
1263 if (count
!= lpMidiHdr
->dwBytesRecorded
) {
1264 dprintf_midi(stddeb
,
1265 "modLongData() // error writting unixdev #%d ! (%d != %ld)\n",
1266 MidiOutDev
[wDevID
].unixdev
, count
, lpMidiHdr
->dwBytesRecorded
);
1267 return MMSYSERR_NOTENABLED
;
1269 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1270 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1271 if (MIDI_NotifyClient(wDevID
, MOM_DONE
, 0L, 0L) != MMSYSERR_NOERROR
) {
1272 fprintf(stderr
,"Linux 'modLongData' // can't notify client !\n");
1273 return MMSYSERR_INVALPARAM
;
1275 return MMSYSERR_NOERROR
;
1277 return MMSYSERR_NOTENABLED
;
1281 /**************************************************************************
1282 * modPrepare [internal]
1284 DWORD
modPrepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1287 dprintf_midi(stddeb
,
1288 "modPrepare(%u, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1289 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1290 fprintf(stderr
,"Linux 'modPrepare' // can't prepare !\n");
1291 return MMSYSERR_NOTENABLED
;
1293 if (MidiOutDev
[wDevID
].lpQueueHdr
!= NULL
) {
1294 fprintf(stderr
,"Linux 'modPrepare' // already prepare !\n");
1295 return MMSYSERR_NOTENABLED
;
1297 MidiOutDev
[wDevID
].dwTotalPlayed
= 0;
1298 MidiOutDev
[wDevID
].lpQueueHdr
= lpMidiHdr
;
1299 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
) return MIDIERR_STILLPLAYING
;
1300 lpMidiHdr
->dwFlags
|= MHDR_PREPARED
;
1301 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1302 return MMSYSERR_NOERROR
;
1304 return MMSYSERR_NOTENABLED
;
1308 /**************************************************************************
1309 * modUnprepare [internal]
1311 DWORD
modUnprepare(WORD wDevID
, LPMIDIHDR lpMidiHdr
, DWORD dwSize
)
1314 dprintf_midi(stddeb
,
1315 "modUnprepare(%u, %p, %08lX);\n", wDevID
, lpMidiHdr
, dwSize
);
1316 if (MidiOutDev
[wDevID
].unixdev
== 0) {
1317 fprintf(stderr
,"Linux 'modUnprepare' // can't unprepare !\n");
1318 return MMSYSERR_NOTENABLED
;
1320 return MMSYSERR_NOERROR
;
1322 return MMSYSERR_NOTENABLED
;
1326 /**************************************************************************
1327 * modReset [internal]
1329 DWORD
modReset(WORD wDevID
)
1331 printf("modReset(%u);\n", wDevID
);
1332 return MMSYSERR_NOTENABLED
;
1336 /**************************************************************************
1337 * modGetPosition [internal]
1339 DWORD
modGetPosition(WORD wDevID
, LPMMTIME lpTime
, DWORD uSize
)
1341 printf("modGetposition(%u, %p, %08lX);\n", wDevID
, lpTime
, uSize
);
1342 return MMSYSERR_NOTENABLED
;
1346 /**************************************************************************
1347 * modMessage [sample driver]
1349 DWORD
modMessage(WORD wDevID
, WORD wMsg
, DWORD dwUser
,
1350 DWORD dwParam1
, DWORD dwParam2
)
1352 printf("modMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
1353 wDevID
, wMsg
, dwUser
, dwParam1
, dwParam2
);
1356 return modOpen(wDevID
, (LPMIDIOPENDESC
)dwParam1
, dwParam2
);
1358 return modClose(wDevID
);
1360 return modData(wDevID
, dwParam1
);
1362 return modLongData(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1364 return modPrepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1365 case MODM_UNPREPARE
:
1366 return modUnprepare(wDevID
, (LPMIDIHDR
)dwParam1
, dwParam2
);
1367 case MODM_GETDEVCAPS
:
1368 return modGetDevCaps(wDevID
, (LPMIDIOUTCAPS
)dwParam1
, dwParam2
);
1369 case MODM_GETNUMDEVS
:
1371 case MODM_GETVOLUME
:
1373 case MODM_SETVOLUME
:
1376 return modReset(wDevID
);
1378 return MMSYSERR_NOTSUPPORTED
;
1382 /*-----------------------------------------------------------------------*/
1384 #endif /* #ifdef BUILTIN_MMSYSTEM */