?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 941122
[wine/multimedia.git] / multimedia / midi.c
blobd3342907b71bdedbf65da61353ae1151e7cfe25d
1 /*
2 * Sample MIDI Wine Driver for Linux
3 *
4 * Copyright 1994 Martin Ayotte
5 */
6 static char Copyright[] = "Copyright Martin Ayotte, 1994";
7
8 #ifndef WINELIB
9 #define BUILTIN_MMSYSTEM
10 #endif
11
12 #ifdef BUILTIN_MMSYSTEM
13
14 #include "stdio.h"
15 #include "win.h"
16 #include "user.h"
17 #include "driver.h"
18 #include "mmsystem.h"
19 #include <fcntl.h>
20 #include <sys/ioctl.h>
21
22 #include "stddebug.h"
23 /* #define DEBUG_MIDI /* */
24 /* #undef DEBUG_MIDI /* */
25
26 #define DEBUG_MIDI
27 #include "debug.h"
28
29
30 #ifdef linux
31 #include <linux/soundcard.h>
32 #endif
33
34 #ifdef linux
35 #define MIDI_DEV "/dev/sequencer"
36
37 #ifdef SOUND_VERSION
38 #define IOCTL(a,b,c) ioctl(a,b,&c)
39 #else
40 #define IOCTL(a,b,c) (c = ioctl(a,b,c) )
41 #endif
42
43 #define MAX_MIDIINDRV 2
44 #define MAX_MIDIOUTDRV 2
45 #define MAX_MCIMIDIDRV 2
46
47 typedef struct {
48 int unixdev;
49 int state;
50 DWORD bufsize;
51 MIDIOPENDESC midiDesc;
52 WORD wFlags;
53 LPMIDIHDR lpQueueHdr;
54 DWORD dwTotalPlayed;
55 } LINUX_MIDIIN;
56
57 typedef struct {
58 int unixdev;
59 int state;
60 DWORD bufsize;
61 MIDIOPENDESC midiDesc;
62 WORD wFlags;
63 LPMIDIHDR lpQueueHdr;
64 DWORD dwTotalPlayed;
65 } LINUX_MIDIOUT;
66
67 typedef struct {
68 int nUseCount; /* Incremented for each shared open */
69 BOOL fShareable; /* TRUE if first open was shareable */
70 WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
71 HANDLE hCallback; /* Callback handle for pending notification */
72 HMMIO hFile; /* mmio file handle open as Element */
73 DWORD dwBeginData;
74 DWORD dwTotalLen;
75 WORD wFormat;
76 WORD nTracks;
77 WORD nTempo;
78 MCI_OPEN_PARMS openParms;
79 MIDIHDR MidiHdr;
80 WORD dwStatus;
81 } LINUX_MCIMIDI;
82
83 static LINUX_MIDIIN MidiInDev[MAX_MIDIINDRV];
84 static LINUX_MIDIOUT MidiOutDev[MAX_MIDIOUTDRV];
85 static LINUX_MCIMIDI MCIMidiDev[MAX_MCIMIDIDRV];
86 #endif
87
88 DWORD MIDI_mciOpen(DWORD dwFlags, LPMCI_OPEN_PARMS lpParms);
89 DWORD MIDI_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms);
90 DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms);
91 DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms);
92 DWORD MIDI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
93 DWORD MIDI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
94 DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
95 DWORD MIDI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms);
96 DWORD MIDI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms);
97 DWORD MIDI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms);
98 DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms);
99
100 DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags);
101 DWORD modClose(WORD wDevID);
102 DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS lpCaps, DWORD dwSize);
103 DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize);
104 DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize);
105 DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize);
106 DWORD modData(WORD wDevID, DWORD dwParam);
107
108 DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags);
109 DWORD midClose(WORD wDevID);
110 DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS lpCaps, DWORD dwSize);
111
112 /**************************************************************************
113 * MIDI_NotifyClient [internal]
114 */
115 DWORD MIDI_NotifyClient(UINT wDevID, WORD wMsg,
116 DWORD dwParam1, DWORD dwParam2)
117 {
118 #ifdef linux
119 if (MidiInDev[wDevID].wFlags != DCB_NULL && !DriverCallback(
120 MidiInDev[wDevID].midiDesc.dwCallback, MidiInDev[wDevID].wFlags,
121 MidiInDev[wDevID].midiDesc.hMidi, wMsg,
122 MidiInDev[wDevID].midiDesc.dwInstance, dwParam1, dwParam2)) {
123 printf("MIDI_NotifyClient // can't notify client !\n");
124 return MMSYSERR_NOERROR;
125 }
126 #else
127 return MMSYSERR_NOTENABLED;
128 #endif
129 }
130
131
132 /**************************************************************************
133 * AUDIO_DriverProc [sample driver]
134 */
135 LRESULT MIDI_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
136 DWORD dwParam1, DWORD dwParam2)
137 {
138 #ifdef linux
139 switch(wMsg) {
140 case DRV_LOAD:
141 return (LRESULT)1L;
142 case DRV_FREE:
143 return (LRESULT)1L;
144 case DRV_OPEN:
145 return (LRESULT)1L;
146 case DRV_CLOSE:
147 return (LRESULT)1L;
148 case DRV_ENABLE:
149 return (LRESULT)1L;
150 case DRV_DISABLE:
151 return (LRESULT)1L;
152 case DRV_QUERYCONFIGURE:
153 return (LRESULT)1L;
154 case DRV_CONFIGURE:
155 MessageBox((HWND)NULL, "Sample Midi Linux Driver !",
156 "MMLinux Driver", MB_OK);
157 return (LRESULT)1L;
158 case DRV_INSTALL:
159 return (LRESULT)DRVCNF_RESTART;
160 case DRV_REMOVE:
161 return (LRESULT)DRVCNF_RESTART;
162 case MCI_OPEN_DRIVER:
163 case MCI_OPEN:
164 return MIDI_mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
165 case MCI_CLOSE_DRIVER:
166 case MCI_CLOSE:
167 return MIDI_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
168 case MCI_PLAY:
169 return MIDI_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
170 case MCI_RECORD:
171 return MIDI_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)dwParam2);
172 case MCI_STOP:
173 return MIDI_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
174 case MCI_SET:
175 return MIDI_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
176 case MCI_PAUSE:
177 return MIDI_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
178 case MCI_RESUME:
179 return MIDI_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
180 case MCI_STATUS:
181 return MIDI_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
182 case MCI_GETDEVCAPS:
183 return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
184 case MCI_INFO:
185 return MIDI_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS)dwParam2);
186 default:
187 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
188 }
189 #else
190 return MMSYSERR_NOTENABLED;
191 #endif
192 }
193
194
195 /**************************************************************************
196 * MIDI_ReadByte [internal]
197 */
198 DWORD MIDI_ReadByte(UINT wDevID, BYTE FAR *lpbyt)
199 {
200 if (lpbyt != NULL) {
201 if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)lpbyt,
202 (long) sizeof(BYTE)) == (long) sizeof(BYTE)) {
203 return 0;
204 }
205 }
206 printf("MIDI_ReadByte // error reading wDevID=%d \n", wDevID);
207 return MCIERR_INTERNAL;
208 }
209
210
211 /**************************************************************************
212 * MIDI_ReadWord [internal]
213 */
214 DWORD MIDI_ReadWord(UINT wDevID, LPWORD lpw)
215 {
216 BYTE hibyte, lobyte;
217 if (lpw != NULL) {
218 if (MIDI_ReadByte(wDevID, &hibyte) == 0) {
219 if (MIDI_ReadByte(wDevID, &lobyte) == 0) {
220 *lpw = ((WORD)hibyte << 8) + lobyte;
221 return 0;
222 }
223 }
224 }
225 printf("MIDI_ReadWord // error reading wDevID=%d \n", wDevID);
226 return MCIERR_INTERNAL;
227 }
228
229
230 /**************************************************************************
231 * MIDI_ReadLong [internal]
232 */
233 DWORD MIDI_ReadLong(UINT wDevID, LPDWORD lpdw)
234 {
235 WORD hiword, loword;
236 BYTE hibyte, lobyte;
237 if (lpdw != NULL) {
238 if (MIDI_ReadWord(wDevID, &hiword) == 0) {
239 if (MIDI_ReadWord(wDevID, &loword) == 0) {
240 *lpdw = MAKELONG(loword, hiword);
241 return 0;
242 }
243 }
244 }
245 printf("MIDI_ReadLong // error reading wDevID=%d \n", wDevID);
246 return MCIERR_INTERNAL;
247 }
248
249
250 /**************************************************************************
251 * MIDI_ReadVaryLen [internal]
252 */
253 DWORD MIDI_ReadVaryLen(UINT wDevID, LPDWORD lpdw)
254 {
255 BYTE byte;
256 DWORD value;
257 if (lpdw == NULL) return MCIERR_INTERNAL;
258 if (MIDI_ReadByte(wDevID, &byte) != 0) {
259 printf("MIDI_ReadVaryLen // error reading wDevID=%d \n", wDevID);
260 return MCIERR_INTERNAL;
261 }
262 value = (DWORD)(byte & 0x7F);
263 while (byte & 0x80) {
264 if (MIDI_ReadByte(wDevID, &byte) != 0) {
265 printf("MIDI_ReadVaryLen // error reading wDevID=%d \n", wDevID);
266 return MCIERR_INTERNAL;
267 }
268 value = (value << 7) + (byte & 0x7F);
269 }
270 *lpdw = value;
271 /*
272 printf("MIDI_ReadVaryLen // val=%08lX \n", value);
273 */
274 return 0;
275 }
276
277
278 /**************************************************************************
279 * MIDI_ReadMThd [internal]
280 */
281 DWORD MIDI_ReadMThd(UINT wDevID, DWORD dwOffset)
282 {
283 DWORD toberead;
284 FOURCC fourcc;
285 dprintf_midi(stddeb, "MIDI_ReadMThd(%04X, %08X);\n", wDevID, dwOffset);
286 if (mmioSeek(MCIMidiDev[wDevID].hFile, dwOffset, SEEK_SET) != dwOffset) {
287 printf("MIDI_ReadMThd // can't seek at %08X begin of 'MThd' \n", dwOffset);
288 return MCIERR_INTERNAL;
289 }
290 if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc,
291 (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) {
292 return MCIERR_INTERNAL;
293 }
294 if (MIDI_ReadLong(wDevID, &toberead) != 0) {
295 return MCIERR_INTERNAL;
296 }
297 if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].wFormat) != 0) {
298 return MCIERR_INTERNAL;
299 }
300 if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTracks) != 0) {
301 return MCIERR_INTERNAL;
302 }
303 if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTempo) != 0) {
304 return MCIERR_INTERNAL;
305 }
306 printf("MIDI_ReadMThd // toberead=%08X, wFormat=%04X nTracks=%04X nTempo=%04X\n",
307 toberead, MCIMidiDev[wDevID].wFormat,
308 MCIMidiDev[wDevID].nTracks,
309 MCIMidiDev[wDevID].nTempo);
310 toberead -= 3 * sizeof(WORD);
311 /*
312 ntrks = read16bit ();
313 Mf_division = division = read16bit ();
314 */
315 return 0;
316 }
317
318
319 DWORD MIDI_ReadMTrk(UINT wDevID, DWORD dwOffset)
320 {
321 DWORD toberead;
322 FOURCC fourcc;
323 if (mmioSeek(MCIMidiDev[wDevID].hFile, dwOffset, SEEK_SET) != dwOffset) {
324 printf("MIDI_ReadMTrk // can't seek at %08X begin of 'MThd' \n", dwOffset);
325 }
326 if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc,
327 (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) {
328 return MCIERR_INTERNAL;
329 }
330 if (MIDI_ReadLong(wDevID, &toberead) != 0) {
331 return MCIERR_INTERNAL;
332 }
333 printf("MIDI_ReadMTrk // toberead=%08X\n", toberead);
334 toberead -= 3 * sizeof(WORD);
335 MCIMidiDev[wDevID].dwTotalLen = toberead;
336 return 0;
337 }
338
339
340 /**************************************************************************
341 * MIDI_mciOpen [internal]
342 */
343 DWORD MIDI_mciOpen(DWORD dwFlags, LPMCI_OPEN_PARMS lpParms)
344 {
345 #ifdef linux
346 int hFile;
347 UINT wDevID;
348 OFSTRUCT OFstruct;
349 MIDIOPENDESC MidiDesc;
350 DWORD dwRet;
351 DWORD dwOffset;
352 char str[128];
353 LPSTR ptr;
354 DWORD toberead;
355 #ifdef DEBUG_MIDI
356 printf("MIDI_mciOpen(%08X, %08X)\n", dwFlags, lpParms);
357 #endif
358 if (lpParms == NULL) return MCIERR_INTERNAL;
359 wDevID = lpParms->wDeviceID;
360 if (MCIMidiDev[wDevID].nUseCount > 0) {
361 /* The driver already open on this channel */
362 /* If the driver was opened shareable before and this open specifies */
363 /* shareable then increment the use count */
364 if (MCIMidiDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
365 ++MCIMidiDev[wDevID].nUseCount;
366 else
367 return MCIERR_MUST_USE_SHAREABLE;
368 }
369 else {
370 MCIMidiDev[wDevID].nUseCount = 1;
371 MCIMidiDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
372 }
373 if (dwFlags & MCI_OPEN_ELEMENT) {
374 printf("MIDI_mciOpen // MCI_OPEN_ELEMENT '%s' !\n",
375 lpParms->lpstrElementName);
376 /* printf("MIDI_mciOpen // cdw='%s'\n", DOS_GetCurrentDir(DOS_GetDefaultDrive())); */
377 if (strlen(lpParms->lpstrElementName) > 0) {
378 strcpy(str, lpParms->lpstrElementName);
379 AnsiUpper(str);
380 MCIMidiDev[wDevID].hFile = mmioOpen(str, NULL,
381 MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE);
382 if (MCIMidiDev[wDevID].hFile == 0) {
383 printf("MIDI_mciOpen // can't find file='%s' !\n", str);
384 return MCIERR_FILE_NOT_FOUND;
385 }
386 }
387 else
388 MCIMidiDev[wDevID].hFile = 0;
389 }
390 printf("MIDI_mciOpen // hFile=%u\n", MCIMidiDev[wDevID].hFile);
391 memcpy(&MCIMidiDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS));
392 MCIMidiDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
393 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
394 MCIMidiDev[wDevID].dwBeginData = 0;
395 MCIMidiDev[wDevID].dwTotalLen = 0;
396 MidiDesc.hMidi = 0;
397 if (MCIMidiDev[wDevID].hFile != 0) {
398 MMCKINFO mmckInfo;
399 MMCKINFO ckMainRIFF;
400 if (mmioDescend(MCIMidiDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) {
401 return MCIERR_INTERNAL;
402 }
403 #ifdef DEBUG_MIDI
404 printf("MIDI_mciOpen // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
405 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
406 ckMainRIFF.cksize);
407 #endif
408 dwOffset = 0;
409 if (ckMainRIFF.ckid == mmioFOURCC('R', 'M', 'I', 'D')) {
410 printf("MIDI_mciOpen // is a 'RMID' file \n");
411 dwOffset = ckMainRIFF.dwDataOffset;
412 }
413 if (ckMainRIFF.ckid != mmioFOURCC('M', 'T', 'h', 'd')) {
414 printf("MIDI_mciOpen // unknown format !\n");
415 return MCIERR_INTERNAL;
416 }
417 if (MIDI_ReadMThd(wDevID, dwOffset) != 0) {
418 printf("MIDI_mciOpen // can't read 'MThd' header \n");
419 return MCIERR_INTERNAL;
420 }
421 dwOffset = mmioSeek(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR);
422 if (MIDI_ReadMTrk(wDevID, dwOffset) != 0) {
423 printf("MIDI_mciOpen // can't read 'MTrk' header \n");
424 return MCIERR_INTERNAL;
425 }
426 dwOffset = mmioSeek(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR);
427 MCIMidiDev[wDevID].dwBeginData = dwOffset;
428 #ifdef DEBUG_MIDI
429 printf("MIDI_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
430 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType,
431 mmckInfo.cksize);
432 #endif
433 }
434 dwRet = modMessage(0, MODM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
435 dwRet = midMessage(0, MIDM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
436 return 0;
437 #else
438 return MMSYSERR_NOTENABLED;
439 #endif
440 }
441
442
443 /**************************************************************************
444 * MIDI_mciClose [internal]
445 */
446 DWORD MIDI_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
447 {
448 #ifdef linux
449 DWORD dwRet;
450 #ifdef DEBUG_MIDI
451 printf("MIDI_mciClose(%u, %08X, %08X);\n", wDevID, dwParam, lpParms);
452 #endif
453 if (MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
454 MIDI_mciStop(wDevID, MCI_WAIT, lpParms);
455 }
456 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
457 MCIMidiDev[wDevID].nUseCount--;
458 if (MCIMidiDev[wDevID].nUseCount == 0) {
459 if (MCIMidiDev[wDevID].hFile != 0) {
460 mmioClose(MCIMidiDev[wDevID].hFile, 0);
461 MCIMidiDev[wDevID].hFile = 0;
462 printf("MIDI_mciClose // hFile closed !\n");
463 }
464 dwRet = modMessage(0, MODM_CLOSE, 0, 0L, 0L);
465 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
466 dwRet = midMessage(0, MIDM_CLOSE, 0, 0L, 0L);
467 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
468 }
469 return 0;
470 #else
471 return 0;
472 #endif
473 }
474
475
476 /**************************************************************************
477 * MIDI_mciPlay [internal]
478 */
479 DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
480 {
481 #ifdef linux
482 int count;
483 int start, end;
484 LPMIDIHDR lpMidiHdr;
485 DWORD dwData;
486 LPWORD ptr;
487 DWORD dwRet;
488 #ifdef DEBUG_MIDI
489 printf("MIDI_mciPlay(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
490 #endif
491 if (MCIMidiDev[wDevID].hFile == 0) {
492 printf("MIDI_mciPlay // can't find file='%s' !\n",
493 MCIMidiDev[wDevID].openParms.lpstrElementName);
494 return MCIERR_FILE_NOT_FOUND;
495 }
496 start = 1; end = 99999;
497 if (dwFlags & MCI_FROM) {
498 start = lpParms->dwFrom;
499 printf("MIDI_mciPlay // MCI_FROM=%d \n", start);
500 }
501 if (dwFlags & MCI_TO) {
502 end = lpParms->dwTo;
503 printf("MIDI_mciPlay // MCI_TO=%d \n", end);
504 }
505 /**/
506 if (dwFlags & MCI_NOTIFY) {
507 printf("MIDI_mciPlay // MCI_NOTIFY %08X !\n", lpParms->dwCallback);
508 switch(fork()) {
509 case -1:
510 printf("MIDI_mciPlay // Can't 'fork' process !\n");
511 break;
512 case 0:
513 printf("MIDI_mciPlay // process started ! play in background ...\n");
514 break;
515 default:
516 printf("MIDI_mciPlay // process started ! return to caller...\n");
517 return 0;
518 }
519 }
520 /**/
521 lpMidiHdr = &MCIMidiDev[wDevID].MidiHdr;
522 lpMidiHdr->lpData = (LPSTR) malloc(1200);
523 if (lpMidiHdr->lpData == NULL) return MCIERR_INTERNAL;
524 lpMidiHdr->dwBufferLength = 1024;
525 lpMidiHdr->dwUser = 0L;
526 lpMidiHdr->dwFlags = 0L;
527 dwRet = modMessage(0, MODM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
528 /* printf("MIDI_mciPlay // after MODM_PREPARE \n"); */
529 MCIMidiDev[wDevID].dwStatus = MCI_MODE_PLAY;
530 while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
531 printf("MIDI_mciPlay // MCIMidiDev[wDevID].dwStatus=%p %d\n",
532 &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus);
533 ptr = (LPWORD)lpMidiHdr->lpData;
534 for (count = 0; count < lpMidiHdr->dwBufferLength; count++) {
535 if (MIDI_ReadVaryLen(wDevID, &dwData) != 0) break;
536 *ptr = LOWORD(dwData);
537 }
538 /*
539 count = mmioRead(MCIMidiDev[wDevID].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength);
540 */
541 if (count < 1) break;
542 lpMidiHdr->dwBytesRecorded = count;
543 #ifdef DEBUG_MIDI
544 printf("MIDI_mciPlay // before MODM_LONGDATA lpMidiHdr=%08X dwBytesRecorded=%u\n",
545 lpMidiHdr, lpMidiHdr->dwBytesRecorded);
546 #endif
547 dwRet = modMessage(0, MODM_LONGDATA, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
548 }
549 dwRet = modMessage(0, MODM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
550 if (lpMidiHdr->lpData != NULL) {
551 free(lpMidiHdr->lpData);
552 lpMidiHdr->lpData = NULL;
553 }
554 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
555 if (dwFlags & MCI_NOTIFY) {
556 #ifdef DEBUG_MIDI
557 printf("MIDI_mciPlay // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
558 #endif
559 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
560 MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
561 exit(1);
562 }
563 return 0;
564 #else
565 return MMSYSERR_NOTENABLED;
566 #endif
567 }
568
569
570 /**************************************************************************
571 * MIDI_mciRecord [internal]
572 */
573 DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
574 {
575 #ifdef linux
576 int count;
577 int start, end;
578 LPMIDIHDR lpMidiHdr;
579 DWORD dwRet;
580 #ifdef DEBUG_MIDI
581 printf("MIDI_mciRecord(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
582 #endif
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;
587 }
588 start = 1; end = 99999;
589 if (dwFlags & MCI_FROM) {
590 start = lpParms->dwFrom;
591 printf("MIDI_mciRecord // MCI_FROM=%d \n", start);
592 }
593 if (dwFlags & MCI_TO) {
594 end = lpParms->dwTo;
595 printf("MIDI_mciRecord // MCI_TO=%d \n", end);
596 }
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=%08X dwBytesRecorded=%u\n",
611 lpMidiHdr, lpMidiHdr->dwBytesRecorded);
612 if (lpMidiHdr->dwBytesRecorded == 0) break;
613 }
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;
620 }
621 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
622 if (dwFlags & MCI_NOTIFY) {
623 #ifdef DEBUG_MIDI
624 printf("MIDI_mciRecord // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
625 #endif
626 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
627 MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
628 }
629 return 0;
630 #else
631 return MMSYSERR_NOTENABLED;
632 #endif
633 }
634
635
636 /**************************************************************************
637 * MIDI_mciStop [internal]
638 */
639 DWORD MIDI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
640 {
641 #ifdef linux
642 #ifdef DEBUG_MIDI
643 printf("MIDI_mciStop(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
644 #endif
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);
649 return 0;
650 #else
651 return MCIERR_INTERNAL;
652 #endif
653 }
654
655
656 /**************************************************************************
657 * MIDI_mciPause [internal]
658 */
659 DWORD MIDI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
660 {
661 #ifdef linux
662 #ifdef DEBUG_MIDI
663 printf("MIDI_mciPause(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
664 #endif
665 if (lpParms == NULL) return MCIERR_INTERNAL;
666 return 0;
667 #else
668 return MCIERR_INTERNAL;
669 #endif
670 }
671
672
673 /**************************************************************************
674 * MIDI_mciResume [internal]
675 */
676 DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
677 {
678 #ifdef linux
679 #ifdef DEBUG_MIDI
680 printf("MIDI_mciResume(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
681 #endif
682 if (lpParms == NULL) return MCIERR_INTERNAL;
683 return 0;
684 #else
685 return MCIERR_INTERNAL;
686 #endif
687 }
688
689
690 /**************************************************************************
691 * MIDI_mciSet [internal]
692 */
693 DWORD MIDI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
694 {
695 #ifdef linux
696 #ifdef DEBUG_MIDI
697 printf("MIDI_mciSet(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
698 #endif
699 if (lpParms == NULL) return MCIERR_INTERNAL;
700 #ifdef DEBUG_MIDI
701 printf("MIDI_mciSet // dwTimeFormat=%08X\n", lpParms->dwTimeFormat);
702 printf("MIDI_mciSet // dwAudio=%08X\n", lpParms->dwAudio);
703 #endif
704 if (dwFlags & MCI_SET_TIME_FORMAT) {
705 switch (lpParms->dwTimeFormat) {
706 case MCI_FORMAT_MILLISECONDS:
707 printf("MIDI_mciSet // MCI_FORMAT_MILLISECONDS !\n");
708 break;
709 case MCI_FORMAT_BYTES:
710 printf("MIDI_mciSet // MCI_FORMAT_BYTES !\n");
711 break;
712 case MCI_FORMAT_SAMPLES:
713 printf("MIDI_mciSet // MCI_FORMAT_SAMPLES !\n");
714 break;
715 default:
716 printf("MIDI_mciSet // bad time format !\n");
717 return MCIERR_BAD_TIME_FORMAT;
718 }
719 }
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");
725 }
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");
730 }
731 if (dwFlags && MCI_SET_AUDIO_RIGHT) {
732 printf("MIDI_mciSet // MCI_SET_AUDIO_RIGHT !\n");
733 }
734 }
735 if (dwFlags & MCI_SET_OFF) {
736 printf("MIDI_mciSet // MCI_SET_OFF !\n");
737 }
738 if (dwFlags & MCI_SEQ_SET_MASTER) {
739 printf("MIDI_mciSet // MCI_SEQ_SET_MASTER !\n");
740 }
741 if (dwFlags & MCI_SEQ_SET_SLAVE) {
742 printf("MIDI_mciSet // MCI_SEQ_SET_SLAVE !\n");
743 }
744 if (dwFlags & MCI_SEQ_SET_OFFSET) {
745 printf("MIDI_mciSet // MCI_SEQ_SET_OFFSET !\n");
746 }
747 if (dwFlags & MCI_SEQ_SET_PORT) {
748 printf("MIDI_mciSet // MCI_SEQ_SET_PORT !\n");
749 }
750 if (dwFlags & MCI_SEQ_SET_TEMPO) {
751 printf("MIDI_mciSet // MCI_SEQ_SET_TEMPO !\n");
752 }
753 return 0;
754 #else
755 return MCIERR_INTERNAL;
756 #endif
757 }
758
759
760 /**************************************************************************
761 * MIDI_mciStatus [internal]
762 */
763 DWORD MIDI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
764 {
765 #ifdef linux
766 #ifdef DEBUG_MIDI
767 printf("MIDI_mciStatus(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
768 #endif
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;
774 break;
775 case MCI_STATUS_LENGTH:
776 lpParms->dwReturn = 5555;
777 if (dwFlags & MCI_TRACK) {
778 lpParms->dwTrack = 1;
779 lpParms->dwReturn = 2222;
780 }
781 break;
782 case MCI_STATUS_MODE:
783 lpParms->dwReturn = MCI_MODE_STOP;
784 break;
785 case MCI_STATUS_MEDIA_PRESENT:
786 printf("MIDI_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
787 lpParms->dwReturn = TRUE;
788 break;
789 case MCI_STATUS_NUMBER_OF_TRACKS:
790 lpParms->dwReturn = 1;
791 break;
792 case MCI_STATUS_POSITION:
793 lpParms->dwReturn = 3333;
794 if (dwFlags & MCI_STATUS_START) {
795 lpParms->dwItem = 1;
796 }
797 if (dwFlags & MCI_TRACK) {
798 lpParms->dwTrack = 1;
799 lpParms->dwReturn = 777;
800 }
801 break;
802 case MCI_STATUS_READY:
803 printf("MIDI_mciStatus // MCI_STATUS_READY !\n");
804 lpParms->dwReturn = TRUE;
805 break;
806 case MCI_STATUS_TIME_FORMAT:
807 printf("MIDI_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
808 lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
809 break;
810 case MCI_SEQ_STATUS_DIVTYPE:
811 printf("MIDI_mciStatus // MCI_SEQ_STATUS_DIVTYPE !\n");
812 lpParms->dwReturn = 0;
813 break;
814 case MCI_SEQ_STATUS_MASTER:
815 printf("MIDI_mciStatus // MCI_SEQ_STATUS_MASTER !\n");
816 lpParms->dwReturn = 0;
817 break;
818 case MCI_SEQ_STATUS_SLAVE:
819 printf("MIDI_mciStatus // MCI_SEQ_STATUS_SLAVE !\n");
820 lpParms->dwReturn = 0;
821 break;
822 case MCI_SEQ_STATUS_OFFSET:
823 printf("MIDI_mciStatus // MCI_SEQ_STATUS_OFFSET !\n");
824 lpParms->dwReturn = 0;
825 break;
826 case MCI_SEQ_STATUS_PORT:
827 printf("MIDI_mciStatus // MCI_SEQ_STATUS_PORT !\n");
828 lpParms->dwReturn = 0;
829 break;
830 case MCI_SEQ_STATUS_TEMPO:
831 printf("MIDI_mciStatus // MCI_SEQ_STATUS_TEMPO !\n");
832 lpParms->dwReturn = 0;
833 break;
834 default:
835 printf("MIDI_mciStatus // unknowm command %04X !\n", lpParms->dwItem);
836 return MCIERR_UNRECOGNIZED_COMMAND;
837 }
838 }
839 if (dwFlags & MCI_NOTIFY) {
840 printf("MIDI_mciStatus // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
841 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
842 MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
843 }
844 return 0;
845 #else
846 return MCIERR_INTERNAL;
847 #endif
848 }
849
850 /**************************************************************************
851 * MIDI_mciGetDevCaps [internal]
852 */
853 DWORD MIDI_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
854 LPMCI_GETDEVCAPS_PARMS lpParms)
855 {
856 #ifdef linux
857 printf("MIDI_mciGetDevCaps(%u, %08X, %08X);\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;
863 break;
864 case MCI_GETDEVCAPS_HAS_AUDIO:
865 lpParms->dwReturn = TRUE;
866 break;
867 case MCI_GETDEVCAPS_HAS_VIDEO:
868 lpParms->dwReturn = FALSE;
869 break;
870 case MCI_GETDEVCAPS_DEVICE_TYPE:
871 lpParms->dwReturn = MCI_DEVTYPE_SEQUENCER;
872 break;
873 case MCI_GETDEVCAPS_USES_FILES:
874 lpParms->dwReturn = TRUE;
875 break;
876 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
877 lpParms->dwReturn = TRUE;
878 break;
879 case MCI_GETDEVCAPS_CAN_EJECT:
880 lpParms->dwReturn = FALSE;
881 break;
882 case MCI_GETDEVCAPS_CAN_PLAY:
883 lpParms->dwReturn = TRUE;
884 break;
885 case MCI_GETDEVCAPS_CAN_SAVE:
886 lpParms->dwReturn = FALSE;
887 break;
888 default:
889 return MCIERR_UNRECOGNIZED_COMMAND;
890 }
891 }
892 return 0;
893 #else
894 return MCIERR_INTERNAL;
895 #endif
896 }
897
898 /**************************************************************************
899 * MIDI_mciInfo [internal]
900 */
901 DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
902 {
903 #ifdef linux
904 printf("MIDI_mciInfo(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
905 if (lpParms == NULL) return MCIERR_INTERNAL;
906 lpParms->lpstrReturn = NULL;
907 switch(dwFlags) {
908 case MCI_INFO_PRODUCT:
909 lpParms->lpstrReturn = "Linux Sound System 0.5";
910 break;
911 case MCI_INFO_FILE:
912 lpParms->lpstrReturn = "FileName";
913 break;
914 default:
915 return MCIERR_UNRECOGNIZED_COMMAND;
916 }
917 if (lpParms->lpstrReturn != NULL)
918 lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
919 else
920 lpParms->dwRetSize = 0;
921 return 0;
922 #else
923 return MCIERR_INTERNAL;
924 #endif
925 }
926
927
928 /*-----------------------------------------------------------------------*/
929
930
931 /**************************************************************************
932 * midGetDevCaps [internal]
933 */
934 DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS lpCaps, DWORD dwSize)
935 {
936 printf("midGetDevCaps(%u, %08X, %08X);\n", wDevID, lpCaps, dwSize);
937 return MMSYSERR_NOTENABLED;
938 }
939
940 /**************************************************************************
941 * midOpen [internal]
942 */
943 DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
944 {
945 #ifdef linux
946 int midi;
947 dprintf_midi(stddeb,
948 "midOpen(%u, %08X, %08X);\n", wDevID, lpDesc, dwFlags);
949 if (lpDesc == NULL) {
950 fprintf(stderr,"Linux 'midOpen' // Invalid Parameter !\n");
951 return MMSYSERR_INVALPARAM;
952 }
953 if (wDevID >= MAX_MIDIINDRV) {
954 fprintf(stderr,"Linux 'midOpen' // MAX_MIDIINDRV reached !\n");
955 return MMSYSERR_ALLOCATED;
956 }
957 MidiInDev[wDevID].unixdev = 0;
958 midi = open (MIDI_DEV, O_RDONLY, 0);
959 if (midi == -1) {
960 fprintf(stderr,"Linux 'midOpen' // can't open !\n");
961 return MMSYSERR_NOTENABLED;
962 }
963 MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
964 switch(MidiInDev[wDevID].wFlags) {
965 case DCB_NULL:
966 fprintf(stderr,"Linux 'midOpen' // CALLBACK_NULL !\n");
967 break;
968 case DCB_WINDOW:
969 dprintf_midi(stddeb,
970 "Linux 'midOpen' // CALLBACK_WINDOW !\n");
971 break;
972 case DCB_TASK:
973 dprintf_midi(stddeb,
974 "Linux 'midOpen' // CALLBACK_TASK !\n");
975 break;
976 case DCB_FUNCTION:
977 dprintf_midi(stddeb,
978 "Linux 'midOpen' // CALLBACK_FUNCTION !\n");
979 break;
980 }
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;
988 }
989 return MMSYSERR_NOERROR;
990 #else
991 return MMSYSERR_NOTENABLED;
992 #endif
993 }
994
995 /**************************************************************************
996 * midClose [internal]
997 */
998 DWORD midClose(WORD wDevID)
999 {
1000 #ifdef linux
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;
1005 }
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;
1012 }
1013 return MMSYSERR_NOERROR;
1014 #else
1015 return MMSYSERR_NOTENABLED;
1016 #endif
1017 }
1018
1019 /**************************************************************************
1020 * midAddBuffer [internal]
1021 */
1022 DWORD midAddBuffer(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1023 {
1024 printf("midAddBuffer(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
1025 return MMSYSERR_NOTENABLED;
1026 }
1027
1028 /**************************************************************************
1029 * midPrepare [internal]
1030 */
1031 DWORD midPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1032 {
1033 printf("midPrepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
1034 return MMSYSERR_NOTENABLED;
1035 }
1036
1037 /**************************************************************************
1038 * midUnprepare [internal]
1039 */
1040 DWORD midUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1041 {
1042 printf("midUnprepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
1043 return MMSYSERR_NOTENABLED;
1044 }
1045
1046 /**************************************************************************
1047 * midReset [internal]
1048 */
1049 DWORD midReset(WORD wDevID)
1050 {
1051 printf("midReset(%u);\n", wDevID);
1052 return MMSYSERR_NOTENABLED;
1053 }
1054
1055
1056 /**************************************************************************
1057 * midStart [internal]
1058 */
1059 DWORD midStart(WORD wDevID)
1060 {
1061 printf("midStart(%u);\n", wDevID);
1062 return MMSYSERR_NOTENABLED;
1063 }
1064
1065
1066 /**************************************************************************
1067 * midStop [internal]
1068 */
1069 DWORD midStop(WORD wDevID)
1070 {
1071 printf("midStop(%u);\n", wDevID);
1072 return MMSYSERR_NOTENABLED;
1073 }
1074
1075
1076 /**************************************************************************
1077 * midMessage [sample driver]
1078 */
1079 DWORD midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1080 DWORD dwParam1, DWORD dwParam2)
1081 {
1082 printf("midMessage(%u, %04X, %08X, %08X, %08X);\n",
1083 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1084 switch(wMsg) {
1085 case MIDM_OPEN:
1086 return midOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
1087 case MIDM_CLOSE:
1088 return midClose(wDevID);
1089 case MIDM_ADDBUFFER:
1090 return midAddBuffer(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1091 case MIDM_PREPARE:
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:
1098 return 1L;
1099 case MIDM_RESET:
1100 return midReset(wDevID);
1101 case MIDM_START:
1102 return midStart(wDevID);
1103 case MIDM_STOP:
1104 return midStop(wDevID);
1105 }
1106 return MMSYSERR_NOTSUPPORTED;
1107 }
1108
1109
1110
1111 /*-----------------------------------------------------------------------*/
1112
1113
1114 /**************************************************************************
1115 * modGetDevCaps [internal]
1116 */
1117 DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS lpCaps, DWORD dwSize)
1118 {
1119 printf("modGetDevCaps(%u, %08X, %08X);\n", wDevID, lpCaps, dwSize);
1120 return MMSYSERR_NOTENABLED;
1121 }
1122
1123
1124 /**************************************************************************
1125 * modOpen [internal]
1126 */
1127 DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
1128 {
1129 #ifdef linux
1130 int midi;
1131 dprintf_midi(stddeb,
1132 "modOpen(%u, %08X, %08X);\n", wDevID, lpDesc, dwFlags);
1133 if (lpDesc == NULL) {
1134 fprintf(stderr,"Linux 'modOpen' // Invalid Parameter !\n");
1135 return MMSYSERR_INVALPARAM;
1136 }
1137 if (wDevID >= MAX_MIDIOUTDRV) {
1138 fprintf(stderr,"Linux 'modOpen' // MAX_MIDIOUTDRV reached !\n");
1139 return MMSYSERR_ALLOCATED;
1140 }
1141 MidiOutDev[wDevID].unixdev = 0;
1142 midi = open (MIDI_DEV, O_WRONLY, 0);
1143 if (midi == -1) {
1144 fprintf(stderr,"Linux 'modOpen' // can't open !\n");
1145 return MMSYSERR_NOTENABLED;
1146 }
1147 MidiOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1148 switch(MidiOutDev[wDevID].wFlags) {
1149 case DCB_NULL:
1150 fprintf(stderr,"Linux 'modOpen' // CALLBACK_NULL !\n");
1151 break;
1152 case DCB_WINDOW:
1153 dprintf_midi(stddeb,
1154 "Linux 'modOpen' // CALLBACK_WINDOW !\n");
1155 break;
1156 case DCB_TASK:
1157 dprintf_midi(stddeb,
1158 "Linux 'modOpen' // CALLBACK_TASK !\n");
1159 break;
1160 case DCB_FUNCTION:
1161 dprintf_midi(stddeb,
1162 "Linux 'modOpen' // CALLBACK_FUNCTION !\n");
1163 break;
1164 }
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;
1172 }
1173 dprintf_midi(stddeb,
1174 "Linux 'modOpen' // Succesful unixdev=%d !\n", midi);
1175 return MMSYSERR_NOERROR;
1176 #else
1177 return MMSYSERR_NOTENABLED;
1178 #endif
1179 }
1180
1181
1182 /**************************************************************************
1183 * modClose [internal]
1184 */
1185 DWORD modClose(WORD wDevID)
1186 {
1187 #ifdef linux
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;
1192 }
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;
1199 }
1200 return MMSYSERR_NOERROR;
1201 #else
1202 return MMSYSERR_NOTENABLED;
1203 #endif
1204 }
1205
1206 /**************************************************************************
1207 * modData [internal]
1208 */
1209 DWORD modData(WORD wDevID, DWORD dwParam)
1210 {
1211 WORD event;
1212 dprintf_midi(stddeb,
1213 "modData(%u, %08X);\n", wDevID, dwParam);
1214 if (MidiOutDev[wDevID].unixdev == 0) {
1215 fprintf(stderr,"Linux 'modData' // can't play !\n");
1216 return MIDIERR_NODEVICE;
1217 }
1218 event = LOWORD(dwParam);
1219 if (write (MidiOutDev[wDevID].unixdev,
1220 &event, sizeof(WORD)) != sizeof(WORD)) {
1221 dprintf_midi(stddeb,
1222 "modData() // error writting unixdev !\n");
1223 }
1224 return MMSYSERR_NOTENABLED;
1225 }
1226
1227 /**************************************************************************
1228 * modLongData [internal]
1229 */
1230 DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1231 {
1232 #ifdef linux
1233 int count;
1234 LPWORD ptr;
1235 dprintf_midi(stddeb,
1236 "modLongData(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
1237 printf("modLongData(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
1238 if (MidiOutDev[wDevID].unixdev == 0) {
1239 fprintf(stderr,"Linux 'modLongData' // can't play !\n");
1240 return MIDIERR_NODEVICE;
1241 }
1242 if (lpMidiHdr->lpData == NULL) return MIDIERR_UNPREPARED;
1243 if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
1244 if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
1245 lpMidiHdr->dwFlags &= ~MHDR_DONE;
1246 lpMidiHdr->dwFlags |= MHDR_INQUEUE;
1247 dprintf_midi(stddeb,
1248 "modLongData() // dwBytesRecorded %u !\n", lpMidiHdr->dwBytesRecorded);
1249 /*
1250 count = write (MidiOutDev[wDevID].unixdev,
1251 lpMidiHdr->lpData, lpMidiHdr->dwBytesRecorded);
1252 */
1253 ptr = (LPWORD)lpMidiHdr->lpData;
1254 for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) {
1255 if (write (MidiOutDev[wDevID].unixdev, ptr,
1256 sizeof(WORD)) != sizeof(WORD)) break;
1257 ptr++;
1258 }
1259 if (count != lpMidiHdr->dwBytesRecorded) {
1260 dprintf_midi(stddeb,
1261 "modLongData() // error writting unixdev #%d ! (%d != %d)\n",
1262 MidiOutDev[wDevID].unixdev, count, lpMidiHdr->dwBytesRecorded);
1263 return MMSYSERR_NOTENABLED;
1264 }
1265 lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1266 lpMidiHdr->dwFlags |= MHDR_DONE;
1267 if (MIDI_NotifyClient(wDevID, MOM_DONE, 0L, 0L) != MMSYSERR_NOERROR) {
1268 fprintf(stderr,"Linux 'modLongData' // can't notify client !\n");
1269 return MMSYSERR_INVALPARAM;
1270 }
1271 return MMSYSERR_NOERROR;
1272 #else
1273 return MMSYSERR_NOTENABLED;
1274 #endif
1275 }
1276
1277 /**************************************************************************
1278 * modPrepare [internal]
1279 */
1280 DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1281 {
1282 #ifdef linux
1283 dprintf_midi(stddeb,
1284 "modPrepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
1285 if (MidiOutDev[wDevID].unixdev == 0) {
1286 fprintf(stderr,"Linux 'modPrepare' // can't prepare !\n");
1287 return MMSYSERR_NOTENABLED;
1288 }
1289 if (MidiOutDev[wDevID].lpQueueHdr != NULL) {
1290 fprintf(stderr,"Linux 'modPrepare' // already prepare !\n");
1291 return MMSYSERR_NOTENABLED;
1292 }
1293 MidiOutDev[wDevID].dwTotalPlayed = 0;
1294 MidiOutDev[wDevID].lpQueueHdr = lpMidiHdr;
1295 if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
1296 lpMidiHdr->dwFlags |= MHDR_PREPARED;
1297 lpMidiHdr->dwFlags &= ~MHDR_DONE;
1298 return MMSYSERR_NOERROR;
1299 #else
1300 return MMSYSERR_NOTENABLED;
1301 #endif
1302 }
1303
1304 /**************************************************************************
1305 * modUnprepare [internal]
1306 */
1307 DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1308 {
1309 #ifdef linux
1310 dprintf_midi(stddeb,
1311 "modUnprepare(%u, %08X, %08X);\n", wDevID, lpMidiHdr, dwSize);
1312 if (MidiOutDev[wDevID].unixdev == 0) {
1313 fprintf(stderr,"Linux 'modUnprepare' // can't unprepare !\n");
1314 return MMSYSERR_NOTENABLED;
1315 }
1316 return MMSYSERR_NOERROR;
1317 #else
1318 return MMSYSERR_NOTENABLED;
1319 #endif
1320 }
1321
1322 /**************************************************************************
1323 * modReset [internal]
1324 */
1325 DWORD modReset(WORD wDevID)
1326 {
1327 printf("modReset(%u);\n", wDevID);
1328 return MMSYSERR_NOTENABLED;
1329 }
1330
1331
1332 /**************************************************************************
1333 * modGetPosition [internal]
1334 */
1335 DWORD modGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1336 {
1337 printf("modGetposition(%u, %08X, %08X);\n", wDevID, lpTime, uSize);
1338 return MMSYSERR_NOTENABLED;
1339 }
1340
1341
1342 /**************************************************************************
1343 * modMessage [sample driver]
1344 */
1345 DWORD modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1346 DWORD dwParam1, DWORD dwParam2)
1347 {
1348 printf("modMessage(%u, %04X, %08X, %08X, %08X);\n",
1349 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1350 switch(wMsg) {
1351 case MODM_OPEN:
1352 return modOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
1353 case MODM_CLOSE:
1354 return modClose(wDevID);
1355 case MODM_DATA:
1356 return modData(wDevID, dwParam1);
1357 case MODM_LONGDATA:
1358 return modLongData(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1359 case MODM_PREPARE:
1360 return modPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1361 case MODM_UNPREPARE:
1362 return modUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1363 case MODM_GETDEVCAPS:
1364 return modGetDevCaps(wDevID, (LPMIDIOUTCAPS)dwParam1, dwParam2);
1365 case MODM_GETNUMDEVS:
1366 return 1L;
1367 case MODM_GETVOLUME:
1368 return 0L;
1369 case MODM_SETVOLUME:
1370 return 0L;
1371 case MODM_RESET:
1372 return modReset(wDevID);
1373 }
1374 return MMSYSERR_NOTSUPPORTED;
1375 }
1376
1377
1378 /*-----------------------------------------------------------------------*/
1379
1380
1381 #endif /* #ifdef BUILTIN_MMSYSTEM */
Maarten's multimedia branch