?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 950109
[wine/multimedia.git] / multimedia / midi.c
blob05f271ba32b93e40e8bce871d656c6a8b2c36c48
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 <stdlib.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <sys/ioctl.h>
19 #include "win.h"
20 #include "user.h"
21 #include "driver.h"
22 #include "mmsystem.h"
23
24 #include "stddebug.h"
25 /* #define DEBUG_MIDI */
26 #include "debug.h"
27
28 #ifdef linux
29 #include <linux/soundcard.h>
30 #endif
31
32 #ifdef linux
33 #define MIDI_DEV "/dev/sequencer"
34
35 #ifdef SOUND_VERSION
36 #define IOCTL(a,b,c) ioctl(a,b,&c)
37 #else
38 #define IOCTL(a,b,c) (c = ioctl(a,b,c) )
39 #endif
40
41 #define MAX_MIDIINDRV 2
42 #define MAX_MIDIOUTDRV 2
43 #define MAX_MCIMIDIDRV 2
44
45 typedef struct {
46 int unixdev;
47 int state;
48 DWORD bufsize;
49 MIDIOPENDESC midiDesc;
50 WORD wFlags;
51 LPMIDIHDR lpQueueHdr;
52 DWORD dwTotalPlayed;
53 } LINUX_MIDIIN;
54
55 typedef struct {
56 int unixdev;
57 int state;
58 DWORD bufsize;
59 MIDIOPENDESC midiDesc;
60 WORD wFlags;
61 LPMIDIHDR lpQueueHdr;
62 DWORD dwTotalPlayed;
63 } LINUX_MIDIOUT;
64
65 typedef struct {
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 */
71 DWORD dwBeginData;
72 DWORD dwTotalLen;
73 WORD wFormat;
74 WORD nTracks;
75 WORD nTempo;
76 MCI_OPEN_PARMS openParms;
77 MIDIHDR MidiHdr;
78 WORD dwStatus;
79 } LINUX_MCIMIDI;
80
81 static LINUX_MIDIIN MidiInDev[MAX_MIDIINDRV];
82 static LINUX_MIDIOUT MidiOutDev[MAX_MIDIOUTDRV];
83 static LINUX_MCIMIDI MCIMidiDev[MAX_MCIMIDIDRV];
84 #endif
85
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);
97
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);
105
106 DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags);
107 DWORD midClose(WORD wDevID);
108 DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS lpCaps, DWORD dwSize);
109
110 /**************************************************************************
111 * MIDI_NotifyClient [internal]
112 */
113 DWORD MIDI_NotifyClient(UINT wDevID, WORD wMsg,
114 DWORD dwParam1, DWORD dwParam2)
115 {
116 #ifdef linux
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;
123 }
124 return 0;
125 #else
126 return MMSYSERR_NOTENABLED;
127 #endif
128 }
129
130
131 /**************************************************************************
132 * AUDIO_DriverProc [sample driver]
133 */
134 LRESULT MIDI_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
135 DWORD dwParam1, DWORD dwParam2)
136 {
137 #ifdef linux
138 switch(wMsg) {
139 case DRV_LOAD:
140 return (LRESULT)1L;
141 case DRV_FREE:
142 return (LRESULT)1L;
143 case DRV_OPEN:
144 return (LRESULT)1L;
145 case DRV_CLOSE:
146 return (LRESULT)1L;
147 case DRV_ENABLE:
148 return (LRESULT)1L;
149 case DRV_DISABLE:
150 return (LRESULT)1L;
151 case DRV_QUERYCONFIGURE:
152 return (LRESULT)1L;
153 case DRV_CONFIGURE:
154 MessageBox((HWND)NULL, "Sample Midi Linux Driver !",
155 "MMLinux Driver", MB_OK);
156 return (LRESULT)1L;
157 case DRV_INSTALL:
158 return (LRESULT)DRVCNF_RESTART;
159 case DRV_REMOVE:
160 return (LRESULT)DRVCNF_RESTART;
161 case MCI_OPEN_DRIVER:
162 case MCI_OPEN:
163 return MIDI_mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
164 case MCI_CLOSE_DRIVER:
165 case MCI_CLOSE:
166 return MIDI_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
167 case MCI_PLAY:
168 return MIDI_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
169 case MCI_RECORD:
170 return MIDI_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)dwParam2);
171 case MCI_STOP:
172 return MIDI_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
173 case MCI_SET:
174 return MIDI_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
175 case MCI_PAUSE:
176 return MIDI_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
177 case MCI_RESUME:
178 return MIDI_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
179 case MCI_STATUS:
180 return MIDI_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
181 case MCI_GETDEVCAPS:
182 return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
183 case MCI_INFO:
184 return MIDI_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS)dwParam2);
185 default:
186 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
187 }
188 #else
189 return MMSYSERR_NOTENABLED;
190 #endif
191 }
192
193
194 /**************************************************************************
195 * MIDI_ReadByte [internal]
196 */
197 DWORD MIDI_ReadByte(UINT wDevID, BYTE FAR *lpbyt)
198 {
199 #ifdef linux
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 #else
210 return MMSYSERR_NOTENABLED;
211 #endif
212 }
213
214
215 /**************************************************************************
216 * MIDI_ReadWord [internal]
217 */
218 DWORD MIDI_ReadWord(UINT wDevID, LPWORD lpw)
219 {
220 BYTE hibyte, lobyte;
221 if (lpw != NULL) {
222 if (MIDI_ReadByte(wDevID, &hibyte) == 0) {
223 if (MIDI_ReadByte(wDevID, &lobyte) == 0) {
224 *lpw = ((WORD)hibyte << 8) + lobyte;
225 return 0;
226 }
227 }
228 }
229 printf("MIDI_ReadWord // error reading wDevID=%d \n", wDevID);
230 return MCIERR_INTERNAL;
231 }
232
233
234 /**************************************************************************
235 * MIDI_ReadLong [internal]
236 */
237 DWORD MIDI_ReadLong(UINT wDevID, LPDWORD lpdw)
238 {
239 WORD hiword, loword;
240 if (lpdw != NULL) {
241 if (MIDI_ReadWord(wDevID, &hiword) == 0) {
242 if (MIDI_ReadWord(wDevID, &loword) == 0) {
243 *lpdw = MAKELONG(loword, hiword);
244 return 0;
245 }
246 }
247 }
248 printf("MIDI_ReadLong // error reading wDevID=%d \n", wDevID);
249 return MCIERR_INTERNAL;
250 }
251
252
253 /**************************************************************************
254 * MIDI_ReadVaryLen [internal]
255 */
256 DWORD MIDI_ReadVaryLen(UINT wDevID, LPDWORD lpdw)
257 {
258 BYTE byte;
259 DWORD value;
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;
264 }
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;
270 }
271 value = (value << 7) + (byte & 0x7F);
272 }
273 *lpdw = value;
274 /*
275 printf("MIDI_ReadVaryLen // val=%08lX \n", value);
276 */
277 return 0;
278 }
279
280
281 /**************************************************************************
282 * MIDI_ReadMThd [internal]
283 */
284 DWORD MIDI_ReadMThd(UINT wDevID, DWORD dwOffset)
285 {
286 #ifdef linux
287 DWORD toberead;
288 FOURCC fourcc;
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;
293 }
294 if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc,
295 (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) {
296 return MCIERR_INTERNAL;
297 }
298 if (MIDI_ReadLong(wDevID, &toberead) != 0) {
299 return MCIERR_INTERNAL;
300 }
301 if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].wFormat) != 0) {
302 return MCIERR_INTERNAL;
303 }
304 if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTracks) != 0) {
305 return MCIERR_INTERNAL;
306 }
307 if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTempo) != 0) {
308 return MCIERR_INTERNAL;
309 }
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);
315 /*
316 ntrks = read16bit ();
317 Mf_division = division = read16bit ();
318 */
319 return 0;
320
321 #else
322 return MMSYSERR_NOTENABLED;
323 #endif
324 }
325
326
327 DWORD MIDI_ReadMTrk(UINT wDevID, DWORD dwOffset)
328 {
329 #ifdef linux
330 DWORD toberead;
331 FOURCC fourcc;
332 if (mmioSeek(MCIMidiDev[wDevID].hFile, dwOffset, SEEK_SET) != dwOffset) {
333 printf("MIDI_ReadMTrk // can't seek at %08lX begin of 'MThd' \n", dwOffset);
334 }
335 if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc,
336 (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) {
337 return MCIERR_INTERNAL;
338 }
339 if (MIDI_ReadLong(wDevID, &toberead) != 0) {
340 return MCIERR_INTERNAL;
341 }
342 printf("MIDI_ReadMTrk // toberead=%08lX\n", toberead);
343 toberead -= 3 * sizeof(WORD);
344 MCIMidiDev[wDevID].dwTotalLen = toberead;
345 return 0;
346 #else
347 return MMSYSERR_NOTENABLED;
348 #endif
349 }
350
351
352 /**************************************************************************
353 * MIDI_mciOpen [internal]
354 */
355 DWORD MIDI_mciOpen(DWORD dwFlags, LPMCI_OPEN_PARMS lpParms)
356 {
357 #ifdef linux
358 UINT wDevID;
359 MIDIOPENDESC MidiDesc;
360 DWORD dwRet;
361 DWORD dwOffset;
362 char str[128];
363
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;
373 else
374 return MCIERR_MUST_USE_SHAREABLE;
375 }
376 else {
377 MCIMidiDev[wDevID].nUseCount = 1;
378 MCIMidiDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
379 }
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);
386 AnsiUpper(str);
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;
392 }
393 }
394 else
395 MCIMidiDev[wDevID].hFile = 0;
396 }
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;
403 MidiDesc.hMidi = 0;
404 if (MCIMidiDev[wDevID].hFile != 0) {
405 MMCKINFO ckMainRIFF;
406 if (mmioDescend(MCIMidiDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) {
407 return MCIERR_INTERNAL;
408 }
409 dprintf_midi(stddeb,"MIDI_mciOpen // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
410 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
411 ckMainRIFF.cksize);
412 dwOffset = 0;
413 if (ckMainRIFF.ckid == mmioFOURCC('R', 'M', 'I', 'D')) {
414 printf("MIDI_mciOpen // is a 'RMID' file \n");
415 dwOffset = ckMainRIFF.dwDataOffset;
416 }
417 if (ckMainRIFF.ckid != mmioFOURCC('M', 'T', 'h', 'd')) {
418 printf("MIDI_mciOpen // unknown format !\n");
419 return MCIERR_INTERNAL;
420 }
421 if (MIDI_ReadMThd(wDevID, dwOffset) != 0) {
422 printf("MIDI_mciOpen // can't read 'MThd' header \n");
423 return MCIERR_INTERNAL;
424 }
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;
429 }
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,
434 ckMainRIFF.cksize);
435 }
436 dwRet = modMessage(0, MODM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
437 dwRet = midMessage(0, MIDM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
438 return 0;
439 #else
440 return MMSYSERR_NOTENABLED;
441 #endif
442 }
443
444
445 /**************************************************************************
446 * MIDI_mciClose [internal]
447 */
448 DWORD MIDI_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
449 {
450 #ifdef linux
451 DWORD dwRet;
452 #ifdef DEBUG_MIDI
453 printf("MIDI_mciClose(%u, %08lX, %p);\n", wDevID, dwParam, lpParms);
454 #endif
455 if (MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
456 MIDI_mciStop(wDevID, MCI_WAIT, lpParms);
457 }
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");
465 }
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;
470 }
471 return 0;
472 #else
473 return 0;
474 #endif
475 }
476
477
478 /**************************************************************************
479 * MIDI_mciPlay [internal]
480 */
481 DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
482 {
483 #ifdef linux
484 int count;
485 int start, end;
486 LPMIDIHDR lpMidiHdr;
487 DWORD dwData;
488 LPWORD ptr;
489 DWORD dwRet;
490 #ifdef DEBUG_MIDI
491 printf("MIDI_mciPlay(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
492 #endif
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;
497 }
498 start = 1; end = 99999;
499 if (dwFlags & MCI_FROM) {
500 start = lpParms->dwFrom;
501 printf("MIDI_mciPlay // MCI_FROM=%d \n", start);
502 }
503 if (dwFlags & MCI_TO) {
504 end = lpParms->dwTo;
505 printf("MIDI_mciPlay // MCI_TO=%d \n", end);
506 }
507 /**/
508 if (dwFlags & MCI_NOTIFY) {
509 printf("MIDI_mciPlay // MCI_NOTIFY %08lX !\n", lpParms->dwCallback);
510 switch(fork()) {
511 case -1:
512 printf("MIDI_mciPlay // Can't 'fork' process !\n");
513 break;
514 case 0:
515 printf("MIDI_mciPlay // process started ! play in background ...\n");
516 break;
517 default:
518 printf("MIDI_mciPlay // process started ! return to caller...\n");
519 return 0;
520 }
521 }
522 /**/
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);
539 }
540 /*
541 count = mmioRead(MCIMidiDev[wDevID].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength);
542 */
543 if (count < 1) break;
544 lpMidiHdr->dwBytesRecorded = count;
545 #ifdef DEBUG_MIDI
546 printf("MIDI_mciPlay // before MODM_LONGDATA lpMidiHdr=%p dwBytesRecorded=%lu\n",
547 lpMidiHdr, lpMidiHdr->dwBytesRecorded);
548 #endif
549 dwRet = modMessage(0, MODM_LONGDATA, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
550 }
551 dwRet = modMessage(0, MODM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
552 if (lpMidiHdr->lpData != NULL) {
553 free(lpMidiHdr->lpData);
554 lpMidiHdr->lpData = NULL;
555 }
556 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
557 if (dwFlags & MCI_NOTIFY) {
558 #ifdef DEBUG_MIDI
559 printf("MIDI_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
560 #endif
561 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
562 MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
563 exit(1);
564 }
565 return 0;
566 #else
567 return MMSYSERR_NOTENABLED;
568 #endif
569 }
570
571
572 /**************************************************************************
573 * MIDI_mciRecord [internal]
574 */
575 DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
576 {
577 #ifdef linux
578 int start, end;
579 LPMIDIHDR lpMidiHdr;
580 DWORD dwRet;
581
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;
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=%p dwBytesRecorded=%lu\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 %08lX !\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, %08lX, %p);\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, %08lX, %p);\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, %08lX, %p);\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, %08lX, %p);\n", wDevID, dwFlags, lpParms);
698 #endif
699 if (lpParms == NULL) return MCIERR_INTERNAL;
700 #ifdef DEBUG_MIDI
701 printf("MIDI_mciSet // dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
702 printf("MIDI_mciSet // dwAudio=%08lX\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, %08lX, %p);\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 %08lX !\n", lpParms->dwItem);
836 return MCIERR_UNRECOGNIZED_COMMAND;
837 }
838 }
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);
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, %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;
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, %08lX, %p);\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, %p, %08lX);\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, %p, %08lX);\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, %p, %08lX);\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, %p, %08lX);\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, %p, %08lX);\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, %08lX, %08lX, %08lX);\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, %p, %08lX);\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, %p, %08lX);\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 #ifdef linux
1212 WORD event;
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;
1218 }
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");
1224 }
1225 return MMSYSERR_NOTENABLED;
1226 #else
1227 return MMSYSERR_NOTENABLED;
1228 #endif
1229 }
1230
1231 /**************************************************************************
1232 * modLongData [internal]
1233 */
1234 DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1235 {
1236 #ifdef linux
1237 int count;
1238 LPWORD ptr;
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;
1245 }
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);
1253 /*
1254 count = write (MidiOutDev[wDevID].unixdev,
1255 lpMidiHdr->lpData, lpMidiHdr->dwBytesRecorded);
1256 */
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;
1261 ptr++;
1262 }
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;
1268 }
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;
1274 }
1275 return MMSYSERR_NOERROR;
1276 #else
1277 return MMSYSERR_NOTENABLED;
1278 #endif
1279 }
1280
1281 /**************************************************************************
1282 * modPrepare [internal]
1283 */
1284 DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1285 {
1286 #ifdef linux
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;
1292 }
1293 if (MidiOutDev[wDevID].lpQueueHdr != NULL) {
1294 fprintf(stderr,"Linux 'modPrepare' // already prepare !\n");
1295 return MMSYSERR_NOTENABLED;
1296 }
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;
1303 #else
1304 return MMSYSERR_NOTENABLED;
1305 #endif
1306 }
1307
1308 /**************************************************************************
1309 * modUnprepare [internal]
1310 */
1311 DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1312 {
1313 #ifdef linux
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;
1319 }
1320 return MMSYSERR_NOERROR;
1321 #else
1322 return MMSYSERR_NOTENABLED;
1323 #endif
1324 }
1325
1326 /**************************************************************************
1327 * modReset [internal]
1328 */
1329 DWORD modReset(WORD wDevID)
1330 {
1331 printf("modReset(%u);\n", wDevID);
1332 return MMSYSERR_NOTENABLED;
1333 }
1334
1335
1336 /**************************************************************************
1337 * modGetPosition [internal]
1338 */
1339 DWORD modGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1340 {
1341 printf("modGetposition(%u, %p, %08lX);\n", wDevID, lpTime, uSize);
1342 return MMSYSERR_NOTENABLED;
1343 }
1344
1345
1346 /**************************************************************************
1347 * modMessage [sample driver]
1348 */
1349 DWORD modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1350 DWORD dwParam1, DWORD dwParam2)
1351 {
1352 printf("modMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
1353 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1354 switch(wMsg) {
1355 case MODM_OPEN:
1356 return modOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
1357 case MODM_CLOSE:
1358 return modClose(wDevID);
1359 case MODM_DATA:
1360 return modData(wDevID, dwParam1);
1361 case MODM_LONGDATA:
1362 return modLongData(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1363 case MODM_PREPARE:
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:
1370 return 1L;
1371 case MODM_GETVOLUME:
1372 return 0L;
1373 case MODM_SETVOLUME:
1374 return 0L;
1375 case MODM_RESET:
1376 return modReset(wDevID);
1377 }
1378 return MMSYSERR_NOTSUPPORTED;
1379 }
1380
1381
1382 /*-----------------------------------------------------------------------*/
1383
1384 #endif /* #ifdef BUILTIN_MMSYSTEM */
Maarten's multimedia branch