?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 950522
[wine.git] / multimedia / midi.c
blobbe270865937a54dce55006e23f9b307b680623e0
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 "windows.h"
20 #include "ldt.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(UINT wDevID, 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(dwDevID, dwParam1, (LPMCI_OPEN_PARMS)PTR_SEG_TO_LIN(dwParam2));
164 case MCI_CLOSE_DRIVER:
165 case MCI_CLOSE:
166 return MIDI_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
167 case MCI_PLAY:
168 return MIDI_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
169 case MCI_RECORD:
170 return MIDI_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)PTR_SEG_TO_LIN(dwParam2));
171 case MCI_STOP:
172 return MIDI_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
173 case MCI_SET:
174 return MIDI_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
175 case MCI_PAUSE:
176 return MIDI_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
177 case MCI_RESUME:
178 return MIDI_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
179 case MCI_STATUS:
180 return MIDI_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
181 case MCI_GETDEVCAPS:
182 return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
183 case MCI_INFO:
184 return MIDI_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS)PTR_SEG_TO_LIN(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(UINT wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms)
356 {
357 #ifdef linux
358 MIDIOPENDESC MidiDesc;
359 DWORD dwRet;
360 DWORD dwOffset;
361 LPSTR lpstrElementName;
362 char str[128];
363
364 dprintf_midi( stddeb, "MIDI_mciOpen(%08lX, %p)\n", dwFlags, lpParms);
365 if (lpParms == NULL) return MCIERR_INTERNAL;
366 if (MCIMidiDev[wDevID].nUseCount > 0) {
367 /* The driver already open on this channel */
368 /* If the driver was opened shareable before and this open specifies */
369 /* shareable then increment the use count */
370 if (MCIMidiDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
371 ++MCIMidiDev[wDevID].nUseCount;
372 else
373 return MCIERR_MUST_USE_SHAREABLE;
374 }
375 else {
376 MCIMidiDev[wDevID].nUseCount = 1;
377 MCIMidiDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
378 }
379 dprintf_midi(stddeb,"MIDI_mciOpen // wDevID=%04X\n", wDevID);
380 lpParms->wDeviceID = wDevID;
381 dprintf_midi(stddeb,"MIDI_mciOpen // lpParms->wDevID=%04X\n", lpParms->wDeviceID);
382 dprintf_midi(stddeb,"MIDI_mciOpen // before OPEN_ELEMENT\n");
383 if (dwFlags & MCI_OPEN_ELEMENT) {
384 lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
385 dprintf_midi( stddeb, "MIDI_mciOpen // MCI_OPEN_ELEMENT '%s' !\n", lpstrElementName);
386 /* printf("MIDI_mciOpen // cdw='%s'\n", DOS_GetCurrentDir(DOS_GetDefaultDrive())); */
387 if (strlen(lpstrElementName) > 0) {
388 strcpy(str, lpstrElementName);
389 AnsiUpper(str);
390 MCIMidiDev[wDevID].hFile = mmioOpen(str, NULL,
391 MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE);
392 if (MCIMidiDev[wDevID].hFile == 0) {
393 printf("MIDI_mciOpen // can't find file='%s' !\n", str);
394 return MCIERR_FILE_NOT_FOUND;
395 }
396 }
397 else
398 MCIMidiDev[wDevID].hFile = 0;
399 }
400 printf("MIDI_mciOpen // hFile=%u\n", MCIMidiDev[wDevID].hFile);
401 memcpy(&MCIMidiDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS));
402 MCIMidiDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
403 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
404 MCIMidiDev[wDevID].dwBeginData = 0;
405 MCIMidiDev[wDevID].dwTotalLen = 0;
406 MidiDesc.hMidi = 0;
407 if (MCIMidiDev[wDevID].hFile != 0) {
408 MMCKINFO ckMainRIFF;
409 if (mmioDescend(MCIMidiDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) {
410 return MCIERR_INTERNAL;
411 }
412 dprintf_midi(stddeb,"MIDI_mciOpen // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
413 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
414 ckMainRIFF.cksize);
415 dwOffset = 0;
416 if (ckMainRIFF.ckid == mmioFOURCC('R', 'M', 'I', 'D')) {
417 printf("MIDI_mciOpen // is a 'RMID' file \n");
418 dwOffset = ckMainRIFF.dwDataOffset;
419 }
420 if (ckMainRIFF.ckid != mmioFOURCC('M', 'T', 'h', 'd')) {
421 printf("MIDI_mciOpen // unknown format !\n");
422 return MCIERR_INTERNAL;
423 }
424 if (MIDI_ReadMThd(wDevID, dwOffset) != 0) {
425 printf("MIDI_mciOpen // can't read 'MThd' header \n");
426 return MCIERR_INTERNAL;
427 }
428 dwOffset = mmioSeek(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR);
429 if (MIDI_ReadMTrk(wDevID, dwOffset) != 0) {
430 printf("MIDI_mciOpen // can't read 'MTrk' header \n");
431 return MCIERR_INTERNAL;
432 }
433 dwOffset = mmioSeek(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR);
434 MCIMidiDev[wDevID].dwBeginData = dwOffset;
435 dprintf_midi(stddeb,"MIDI_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
436 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
437 ckMainRIFF.cksize);
438 }
439 dwRet = modMessage(0, MODM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
440 dwRet = midMessage(0, MIDM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);
441 return 0;
442 #else
443 return MMSYSERR_NOTENABLED;
444 #endif
445 }
446
447
448 /**************************************************************************
449 * MIDI_mciClose [internal]
450 */
451 DWORD MIDI_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
452 {
453 #ifdef linux
454 DWORD dwRet;
455 #ifdef DEBUG_MIDI
456 printf("MIDI_mciClose(%u, %08lX, %p);\n", wDevID, dwParam, lpParms);
457 #endif
458 if (MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
459 MIDI_mciStop(wDevID, MCI_WAIT, lpParms);
460 }
461 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
462 MCIMidiDev[wDevID].nUseCount--;
463 if (MCIMidiDev[wDevID].nUseCount == 0) {
464 if (MCIMidiDev[wDevID].hFile != 0) {
465 mmioClose(MCIMidiDev[wDevID].hFile, 0);
466 MCIMidiDev[wDevID].hFile = 0;
467 printf("MIDI_mciClose // hFile closed !\n");
468 }
469 dwRet = modMessage(0, MODM_CLOSE, 0, 0L, 0L);
470 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
471 dwRet = midMessage(0, MIDM_CLOSE, 0, 0L, 0L);
472 if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
473 }
474 return 0;
475 #else
476 return 0;
477 #endif
478 }
479
480
481 /**************************************************************************
482 * MIDI_mciPlay [internal]
483 */
484 DWORD MIDI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
485 {
486 #ifdef linux
487 int count;
488 int start, end;
489 LPMIDIHDR lpMidiHdr;
490 DWORD dwData;
491 LPWORD ptr;
492 DWORD dwRet;
493 #ifdef DEBUG_MIDI
494 printf("MIDI_mciPlay(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
495 #endif
496 if (MCIMidiDev[wDevID].hFile == 0) {
497 printf("MIDI_mciPlay // can't find file='%s' !\n",
498 MCIMidiDev[wDevID].openParms.lpstrElementName);
499 return MCIERR_FILE_NOT_FOUND;
500 }
501 start = 1; end = 99999;
502 if (dwFlags & MCI_FROM) {
503 start = lpParms->dwFrom;
504 printf("MIDI_mciPlay // MCI_FROM=%d \n", start);
505 }
506 if (dwFlags & MCI_TO) {
507 end = lpParms->dwTo;
508 printf("MIDI_mciPlay // MCI_TO=%d \n", end);
509 }
510 /**/
511 if (dwFlags & MCI_NOTIFY) {
512 printf("MIDI_mciPlay // MCI_NOTIFY %08lX !\n", lpParms->dwCallback);
513 switch(fork()) {
514 case -1:
515 printf("MIDI_mciPlay // Can't 'fork' process !\n");
516 break;
517 case 0:
518 printf("MIDI_mciPlay // process started ! play in background ...\n");
519 break;
520 default:
521 printf("MIDI_mciPlay // process started ! return to caller...\n");
522 return 0;
523 }
524 }
525 /**/
526 lpMidiHdr = &MCIMidiDev[wDevID].MidiHdr;
527 lpMidiHdr->lpData = (LPSTR) malloc(1200);
528 if (lpMidiHdr->lpData == NULL) return MCIERR_INTERNAL;
529 lpMidiHdr->dwBufferLength = 1024;
530 lpMidiHdr->dwUser = 0L;
531 lpMidiHdr->dwFlags = 0L;
532 dwRet = modMessage(0, MODM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
533 /* printf("MIDI_mciPlay // after MODM_PREPARE \n"); */
534 MCIMidiDev[wDevID].dwStatus = MCI_MODE_PLAY;
535 while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
536 printf("MIDI_mciPlay // MCIMidiDev[wDevID].dwStatus=%p %d\n",
537 &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus);
538 ptr = (LPWORD)lpMidiHdr->lpData;
539 for (count = 0; count < lpMidiHdr->dwBufferLength; count++) {
540 if (MIDI_ReadVaryLen(wDevID, &dwData) != 0) break;
541 *ptr = LOWORD(dwData);
542 }
543 /*
544 count = mmioRead(MCIMidiDev[wDevID].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength);
545 */
546 if (count < 1) break;
547 lpMidiHdr->dwBytesRecorded = count;
548 #ifdef DEBUG_MIDI
549 printf("MIDI_mciPlay // before MODM_LONGDATA lpMidiHdr=%p dwBytesRecorded=%lu\n",
550 lpMidiHdr, lpMidiHdr->dwBytesRecorded);
551 #endif
552 dwRet = modMessage(0, MODM_LONGDATA, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
553 }
554 dwRet = modMessage(0, MODM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
555 if (lpMidiHdr->lpData != NULL) {
556 free(lpMidiHdr->lpData);
557 lpMidiHdr->lpData = NULL;
558 }
559 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
560 if (dwFlags & MCI_NOTIFY) {
561 #ifdef DEBUG_MIDI
562 printf("MIDI_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
563 #endif
564 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
565 MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
566 exit(1);
567 }
568 return 0;
569 #else
570 return MMSYSERR_NOTENABLED;
571 #endif
572 }
573
574
575 /**************************************************************************
576 * MIDI_mciRecord [internal]
577 */
578 DWORD MIDI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
579 {
580 #ifdef linux
581 int start, end;
582 LPMIDIHDR lpMidiHdr;
583 DWORD dwRet;
584
585 dprintf_midi( stddeb, "MIDI_mciRecord(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
586 if (MCIMidiDev[wDevID].hFile == 0) {
587 printf("MIDI_mciRecord // can't find file='%s' !\n",
588 MCIMidiDev[wDevID].openParms.lpstrElementName);
589 return MCIERR_FILE_NOT_FOUND;
590 }
591 start = 1; end = 99999;
592 if (dwFlags & MCI_FROM) {
593 start = lpParms->dwFrom;
594 printf("MIDI_mciRecord // MCI_FROM=%d \n", start);
595 }
596 if (dwFlags & MCI_TO) {
597 end = lpParms->dwTo;
598 printf("MIDI_mciRecord // MCI_TO=%d \n", end);
599 }
600 lpMidiHdr = &MCIMidiDev[wDevID].MidiHdr;
601 lpMidiHdr->lpData = (LPSTR) malloc(1200);
602 lpMidiHdr->dwBufferLength = 1024;
603 lpMidiHdr->dwUser = 0L;
604 lpMidiHdr->dwFlags = 0L;
605 dwRet = midMessage(0, MIDM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
606 printf("MIDI_mciRecord // after MIDM_PREPARE \n");
607 MCIMidiDev[wDevID].dwStatus = MCI_MODE_RECORD;
608 while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) {
609 printf("MIDI_mciRecord // MCIMidiDev[wDevID].dwStatus=%p %d\n",
610 &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus);
611 lpMidiHdr->dwBytesRecorded = 0;
612 dwRet = midMessage(0, MIDM_START, 0, 0L, 0L);
613 printf("MIDI_mciRecord // after MIDM_START lpMidiHdr=%p dwBytesRecorded=%lu\n",
614 lpMidiHdr, lpMidiHdr->dwBytesRecorded);
615 if (lpMidiHdr->dwBytesRecorded == 0) break;
616 }
617 printf("MIDI_mciRecord // before MIDM_UNPREPARE \n");
618 dwRet = midMessage(0, MIDM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR));
619 printf("MIDI_mciRecord // after MIDM_UNPREPARE \n");
620 if (lpMidiHdr->lpData != NULL) {
621 free(lpMidiHdr->lpData);
622 lpMidiHdr->lpData = NULL;
623 }
624 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
625 if (dwFlags & MCI_NOTIFY) {
626 #ifdef DEBUG_MIDI
627 printf("MIDI_mciRecord // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
628 #endif
629 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
630 MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
631 }
632 return 0;
633 #else
634 return MMSYSERR_NOTENABLED;
635 #endif
636 }
637
638
639 /**************************************************************************
640 * MIDI_mciStop [internal]
641 */
642 DWORD MIDI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
643 {
644 #ifdef linux
645 #ifdef DEBUG_MIDI
646 printf("MIDI_mciStop(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
647 #endif
648 if (lpParms == NULL) return MCIERR_INTERNAL;
649 MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP;
650 printf("MIDI_mciStop // MCIMidiDev[wDevID].dwStatus=%p %d\n",
651 &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus);
652 return 0;
653 #else
654 return MCIERR_INTERNAL;
655 #endif
656 }
657
658
659 /**************************************************************************
660 * MIDI_mciPause [internal]
661 */
662 DWORD MIDI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
663 {
664 #ifdef linux
665 #ifdef DEBUG_MIDI
666 printf("MIDI_mciPause(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
667 #endif
668 if (lpParms == NULL) return MCIERR_INTERNAL;
669 return 0;
670 #else
671 return MCIERR_INTERNAL;
672 #endif
673 }
674
675
676 /**************************************************************************
677 * MIDI_mciResume [internal]
678 */
679 DWORD MIDI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
680 {
681 #ifdef linux
682 #ifdef DEBUG_MIDI
683 printf("MIDI_mciResume(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
684 #endif
685 if (lpParms == NULL) return MCIERR_INTERNAL;
686 return 0;
687 #else
688 return MCIERR_INTERNAL;
689 #endif
690 }
691
692
693 /**************************************************************************
694 * MIDI_mciSet [internal]
695 */
696 DWORD MIDI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
697 {
698 #ifdef linux
699 #ifdef DEBUG_MIDI
700 printf("MIDI_mciSet(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
701 #endif
702 if (lpParms == NULL) return MCIERR_INTERNAL;
703 #ifdef DEBUG_MIDI
704 printf("MIDI_mciSet // dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
705 printf("MIDI_mciSet // dwAudio=%08lX\n", lpParms->dwAudio);
706 #endif
707 if (dwFlags & MCI_SET_TIME_FORMAT) {
708 switch (lpParms->dwTimeFormat) {
709 case MCI_FORMAT_MILLISECONDS:
710 printf("MIDI_mciSet // MCI_FORMAT_MILLISECONDS !\n");
711 break;
712 case MCI_FORMAT_BYTES:
713 printf("MIDI_mciSet // MCI_FORMAT_BYTES !\n");
714 break;
715 case MCI_FORMAT_SAMPLES:
716 printf("MIDI_mciSet // MCI_FORMAT_SAMPLES !\n");
717 break;
718 default:
719 printf("MIDI_mciSet // bad time format !\n");
720 return MCIERR_BAD_TIME_FORMAT;
721 }
722 }
723 if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
724 if (dwFlags & MCI_SET_DOOR_OPEN) return MCIERR_UNSUPPORTED_FUNCTION;
725 if (dwFlags & MCI_SET_DOOR_CLOSED) return MCIERR_UNSUPPORTED_FUNCTION;
726 if (dwFlags & MCI_SET_AUDIO) {
727 printf("MIDI_mciSet // MCI_SET_AUDIO !\n");
728 }
729 if (dwFlags && MCI_SET_ON) {
730 printf("MIDI_mciSet // MCI_SET_ON !\n");
731 if (dwFlags && MCI_SET_AUDIO_LEFT) {
732 printf("MIDI_mciSet // MCI_SET_AUDIO_LEFT !\n");
733 }
734 if (dwFlags && MCI_SET_AUDIO_RIGHT) {
735 printf("MIDI_mciSet // MCI_SET_AUDIO_RIGHT !\n");
736 }
737 }
738 if (dwFlags & MCI_SET_OFF) {
739 printf("MIDI_mciSet // MCI_SET_OFF !\n");
740 }
741 if (dwFlags & MCI_SEQ_SET_MASTER) {
742 printf("MIDI_mciSet // MCI_SEQ_SET_MASTER !\n");
743 }
744 if (dwFlags & MCI_SEQ_SET_SLAVE) {
745 printf("MIDI_mciSet // MCI_SEQ_SET_SLAVE !\n");
746 }
747 if (dwFlags & MCI_SEQ_SET_OFFSET) {
748 printf("MIDI_mciSet // MCI_SEQ_SET_OFFSET !\n");
749 }
750 if (dwFlags & MCI_SEQ_SET_PORT) {
751 printf("MIDI_mciSet // MCI_SEQ_SET_PORT !\n");
752 }
753 if (dwFlags & MCI_SEQ_SET_TEMPO) {
754 printf("MIDI_mciSet // MCI_SEQ_SET_TEMPO !\n");
755 }
756 return 0;
757 #else
758 return MCIERR_INTERNAL;
759 #endif
760 }
761
762
763 /**************************************************************************
764 * MIDI_mciStatus [internal]
765 */
766 DWORD MIDI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
767 {
768 #ifdef linux
769 #ifdef DEBUG_MIDI
770 printf("MIDI_mciStatus(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
771 #endif
772 if (lpParms == NULL) return MCIERR_INTERNAL;
773 if (dwFlags & MCI_STATUS_ITEM) {
774 switch(lpParms->dwItem) {
775 case MCI_STATUS_CURRENT_TRACK:
776 lpParms->dwReturn = 1;
777 break;
778 case MCI_STATUS_LENGTH:
779 lpParms->dwReturn = 5555;
780 if (dwFlags & MCI_TRACK) {
781 lpParms->dwTrack = 1;
782 lpParms->dwReturn = 2222;
783 }
784 break;
785 case MCI_STATUS_MODE:
786 lpParms->dwReturn = MCI_MODE_STOP;
787 break;
788 case MCI_STATUS_MEDIA_PRESENT:
789 printf("MIDI_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
790 lpParms->dwReturn = TRUE;
791 break;
792 case MCI_STATUS_NUMBER_OF_TRACKS:
793 lpParms->dwReturn = 1;
794 break;
795 case MCI_STATUS_POSITION:
796 lpParms->dwReturn = 3333;
797 if (dwFlags & MCI_STATUS_START) {
798 lpParms->dwItem = 1;
799 }
800 if (dwFlags & MCI_TRACK) {
801 lpParms->dwTrack = 1;
802 lpParms->dwReturn = 777;
803 }
804 break;
805 case MCI_STATUS_READY:
806 printf("MIDI_mciStatus // MCI_STATUS_READY !\n");
807 lpParms->dwReturn = TRUE;
808 break;
809 case MCI_STATUS_TIME_FORMAT:
810 printf("MIDI_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
811 lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
812 break;
813 case MCI_SEQ_STATUS_DIVTYPE:
814 printf("MIDI_mciStatus // MCI_SEQ_STATUS_DIVTYPE !\n");
815 lpParms->dwReturn = 0;
816 break;
817 case MCI_SEQ_STATUS_MASTER:
818 printf("MIDI_mciStatus // MCI_SEQ_STATUS_MASTER !\n");
819 lpParms->dwReturn = 0;
820 break;
821 case MCI_SEQ_STATUS_SLAVE:
822 printf("MIDI_mciStatus // MCI_SEQ_STATUS_SLAVE !\n");
823 lpParms->dwReturn = 0;
824 break;
825 case MCI_SEQ_STATUS_OFFSET:
826 printf("MIDI_mciStatus // MCI_SEQ_STATUS_OFFSET !\n");
827 lpParms->dwReturn = 0;
828 break;
829 case MCI_SEQ_STATUS_PORT:
830 printf("MIDI_mciStatus // MCI_SEQ_STATUS_PORT !\n");
831 lpParms->dwReturn = 0;
832 break;
833 case MCI_SEQ_STATUS_TEMPO:
834 printf("MIDI_mciStatus // MCI_SEQ_STATUS_TEMPO !\n");
835 lpParms->dwReturn = 0;
836 break;
837 default:
838 printf("MIDI_mciStatus // unknowm command %08lX !\n", lpParms->dwItem);
839 return MCIERR_UNRECOGNIZED_COMMAND;
840 }
841 }
842 if (dwFlags & MCI_NOTIFY) {
843 printf("MIDI_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
844 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
845 MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
846 }
847 return 0;
848 #else
849 return MCIERR_INTERNAL;
850 #endif
851 }
852
853 /**************************************************************************
854 * MIDI_mciGetDevCaps [internal]
855 */
856 DWORD MIDI_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
857 LPMCI_GETDEVCAPS_PARMS lpParms)
858 {
859 #ifdef linux
860 printf("MIDI_mciGetDevCaps(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
861 if (lpParms == NULL) return MCIERR_INTERNAL;
862 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
863 switch(lpParms->dwItem) {
864 case MCI_GETDEVCAPS_CAN_RECORD:
865 lpParms->dwReturn = TRUE;
866 break;
867 case MCI_GETDEVCAPS_HAS_AUDIO:
868 lpParms->dwReturn = TRUE;
869 break;
870 case MCI_GETDEVCAPS_HAS_VIDEO:
871 lpParms->dwReturn = FALSE;
872 break;
873 case MCI_GETDEVCAPS_DEVICE_TYPE:
874 lpParms->dwReturn = MCI_DEVTYPE_SEQUENCER;
875 break;
876 case MCI_GETDEVCAPS_USES_FILES:
877 lpParms->dwReturn = TRUE;
878 break;
879 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
880 lpParms->dwReturn = TRUE;
881 break;
882 case MCI_GETDEVCAPS_CAN_EJECT:
883 lpParms->dwReturn = FALSE;
884 break;
885 case MCI_GETDEVCAPS_CAN_PLAY:
886 lpParms->dwReturn = TRUE;
887 break;
888 case MCI_GETDEVCAPS_CAN_SAVE:
889 lpParms->dwReturn = FALSE;
890 break;
891 default:
892 return MCIERR_UNRECOGNIZED_COMMAND;
893 }
894 }
895 return 0;
896 #else
897 return MCIERR_INTERNAL;
898 #endif
899 }
900
901 /**************************************************************************
902 * MIDI_mciInfo [internal]
903 */
904 DWORD MIDI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
905 {
906 #ifdef linux
907 printf("MIDI_mciInfo(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
908 if (lpParms == NULL) return MCIERR_INTERNAL;
909 lpParms->lpstrReturn = NULL;
910 switch(dwFlags) {
911 case MCI_INFO_PRODUCT:
912 lpParms->lpstrReturn = "Linux Sound System 0.5";
913 break;
914 case MCI_INFO_FILE:
915 lpParms->lpstrReturn = "FileName";
916 break;
917 default:
918 return MCIERR_UNRECOGNIZED_COMMAND;
919 }
920 if (lpParms->lpstrReturn != NULL)
921 lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
922 else
923 lpParms->dwRetSize = 0;
924 return 0;
925 #else
926 return MCIERR_INTERNAL;
927 #endif
928 }
929
930
931 /*-----------------------------------------------------------------------*/
932
933
934 /**************************************************************************
935 * midGetDevCaps [internal]
936 */
937 DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS lpCaps, DWORD dwSize)
938 {
939 printf("midGetDevCaps(%u, %p, %08lX);\n", wDevID, lpCaps, dwSize);
940 return MMSYSERR_NOTENABLED;
941 }
942
943 /**************************************************************************
944 * midOpen [internal]
945 */
946 DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
947 {
948 #ifdef linux
949 int midi;
950 dprintf_midi(stddeb,
951 "midOpen(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
952 if (lpDesc == NULL) {
953 fprintf(stderr,"Linux 'midOpen' // Invalid Parameter !\n");
954 return MMSYSERR_INVALPARAM;
955 }
956 if (wDevID >= MAX_MIDIINDRV) {
957 fprintf(stderr,"Linux 'midOpen' // MAX_MIDIINDRV reached !\n");
958 return MMSYSERR_ALLOCATED;
959 }
960 MidiInDev[wDevID].unixdev = 0;
961 midi = open (MIDI_DEV, O_RDONLY, 0);
962 if (midi == -1) {
963 fprintf(stderr,"Linux 'midOpen' // can't open !\n");
964 return MMSYSERR_NOTENABLED;
965 }
966 MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
967 switch(MidiInDev[wDevID].wFlags) {
968 case DCB_NULL:
969 fprintf(stderr,"Linux 'midOpen' // CALLBACK_NULL !\n");
970 break;
971 case DCB_WINDOW:
972 dprintf_midi(stddeb,
973 "Linux 'midOpen' // CALLBACK_WINDOW !\n");
974 break;
975 case DCB_TASK:
976 dprintf_midi(stddeb,
977 "Linux 'midOpen' // CALLBACK_TASK !\n");
978 break;
979 case DCB_FUNCTION:
980 dprintf_midi(stddeb,
981 "Linux 'midOpen' // CALLBACK_FUNCTION !\n");
982 break;
983 }
984 MidiInDev[wDevID].lpQueueHdr = NULL;
985 MidiInDev[wDevID].unixdev = midi;
986 MidiInDev[wDevID].dwTotalPlayed = 0;
987 MidiInDev[wDevID].bufsize = 0x3FFF;
988 if (MIDI_NotifyClient(wDevID, MIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
989 fprintf(stderr,"Linux 'midOpen' // can't notify client !\n");
990 return MMSYSERR_INVALPARAM;
991 }
992 return MMSYSERR_NOERROR;
993 #else
994 return MMSYSERR_NOTENABLED;
995 #endif
996 }
997
998 /**************************************************************************
999 * midClose [internal]
1000 */
1001 DWORD midClose(WORD wDevID)
1002 {
1003 #ifdef linux
1004 dprintf_midi(stddeb,"midClose(%u);\n", wDevID);
1005 if (MidiInDev[wDevID].unixdev == 0) {
1006 fprintf(stderr,"Linux 'midClose' // can't close !\n");
1007 return MMSYSERR_NOTENABLED;
1008 }
1009 close(MidiInDev[wDevID].unixdev);
1010 MidiInDev[wDevID].unixdev = 0;
1011 MidiInDev[wDevID].bufsize = 0;
1012 if (MIDI_NotifyClient(wDevID, MIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
1013 fprintf(stderr,"Linux 'midClose' // can't notify client !\n");
1014 return MMSYSERR_INVALPARAM;
1015 }
1016 return MMSYSERR_NOERROR;
1017 #else
1018 return MMSYSERR_NOTENABLED;
1019 #endif
1020 }
1021
1022 /**************************************************************************
1023 * midAddBuffer [internal]
1024 */
1025 DWORD midAddBuffer(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1026 {
1027 printf("midAddBuffer(%u, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1028 return MMSYSERR_NOTENABLED;
1029 }
1030
1031 /**************************************************************************
1032 * midPrepare [internal]
1033 */
1034 DWORD midPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1035 {
1036 printf("midPrepare(%u, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1037 return MMSYSERR_NOTENABLED;
1038 }
1039
1040 /**************************************************************************
1041 * midUnprepare [internal]
1042 */
1043 DWORD midUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1044 {
1045 printf("midUnprepare(%u, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1046 return MMSYSERR_NOTENABLED;
1047 }
1048
1049 /**************************************************************************
1050 * midReset [internal]
1051 */
1052 DWORD midReset(WORD wDevID)
1053 {
1054 printf("midReset(%u);\n", wDevID);
1055 return MMSYSERR_NOTENABLED;
1056 }
1057
1058
1059 /**************************************************************************
1060 * midStart [internal]
1061 */
1062 DWORD midStart(WORD wDevID)
1063 {
1064 printf("midStart(%u);\n", wDevID);
1065 return MMSYSERR_NOTENABLED;
1066 }
1067
1068
1069 /**************************************************************************
1070 * midStop [internal]
1071 */
1072 DWORD midStop(WORD wDevID)
1073 {
1074 printf("midStop(%u);\n", wDevID);
1075 return MMSYSERR_NOTENABLED;
1076 }
1077
1078
1079 /**************************************************************************
1080 * midMessage [sample driver]
1081 */
1082 DWORD midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1083 DWORD dwParam1, DWORD dwParam2)
1084 {
1085 printf("midMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
1086 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1087 switch(wMsg) {
1088 case MIDM_OPEN:
1089 return midOpen(wDevID, (LPMIDIOPENDESC)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1090 case MIDM_CLOSE:
1091 return midClose(wDevID);
1092 case MIDM_ADDBUFFER:
1093 return midAddBuffer(wDevID, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1094 case MIDM_PREPARE:
1095 return midPrepare(wDevID, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1096 case MIDM_UNPREPARE:
1097 return midUnprepare(wDevID, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1098 case MIDM_GETDEVCAPS:
1099 return midGetDevCaps(wDevID, (LPMIDIINCAPS)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1100 case MIDM_GETNUMDEVS:
1101 return 0L;
1102 case MIDM_RESET:
1103 return midReset(wDevID);
1104 case MIDM_START:
1105 return midStart(wDevID);
1106 case MIDM_STOP:
1107 return midStop(wDevID);
1108 }
1109 return MMSYSERR_NOTSUPPORTED;
1110 }
1111
1112
1113
1114 /*-----------------------------------------------------------------------*/
1115
1116
1117 /**************************************************************************
1118 * modGetDevCaps [internal]
1119 */
1120 DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS lpCaps, DWORD dwSize)
1121 {
1122 printf("modGetDevCaps(%u, %p, %08lX);\n", wDevID, lpCaps, dwSize);
1123 return MMSYSERR_NOTENABLED;
1124 }
1125
1126
1127 /**************************************************************************
1128 * modOpen [internal]
1129 */
1130 DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
1131 {
1132 #ifdef linux
1133 int midi;
1134 dprintf_midi(stddeb,
1135 "modOpen(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
1136 if (lpDesc == NULL) {
1137 fprintf(stderr,"Linux 'modOpen' // Invalid Parameter !\n");
1138 return MMSYSERR_INVALPARAM;
1139 }
1140 if (wDevID >= MAX_MIDIOUTDRV) {
1141 fprintf(stderr,"Linux 'modOpen' // MAX_MIDIOUTDRV reached !\n");
1142 return MMSYSERR_ALLOCATED;
1143 }
1144 MidiOutDev[wDevID].unixdev = 0;
1145 midi = open (MIDI_DEV, O_WRONLY, 0);
1146 if (midi == -1) {
1147 fprintf(stderr,"Linux 'modOpen' // can't open !\n");
1148 return MMSYSERR_NOTENABLED;
1149 }
1150 MidiOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1151 switch(MidiOutDev[wDevID].wFlags) {
1152 case DCB_NULL:
1153 fprintf(stderr,"Linux 'modOpen' // CALLBACK_NULL !\n");
1154 break;
1155 case DCB_WINDOW:
1156 dprintf_midi(stddeb,
1157 "Linux 'modOpen' // CALLBACK_WINDOW !\n");
1158 break;
1159 case DCB_TASK:
1160 dprintf_midi(stddeb,
1161 "Linux 'modOpen' // CALLBACK_TASK !\n");
1162 break;
1163 case DCB_FUNCTION:
1164 dprintf_midi(stddeb,
1165 "Linux 'modOpen' // CALLBACK_FUNCTION !\n");
1166 break;
1167 }
1168 MidiOutDev[wDevID].lpQueueHdr = NULL;
1169 MidiOutDev[wDevID].unixdev = midi;
1170 MidiOutDev[wDevID].dwTotalPlayed = 0;
1171 MidiOutDev[wDevID].bufsize = 0x3FFF;
1172 if (MIDI_NotifyClient(wDevID, MOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
1173 fprintf(stderr,"Linux 'modOpen' // can't notify client !\n");
1174 return MMSYSERR_INVALPARAM;
1175 }
1176 dprintf_midi(stddeb,
1177 "Linux 'modOpen' // Succesful unixdev=%d !\n", midi);
1178 return MMSYSERR_NOERROR;
1179 #else
1180 return MMSYSERR_NOTENABLED;
1181 #endif
1182 }
1183
1184
1185 /**************************************************************************
1186 * modClose [internal]
1187 */
1188 DWORD modClose(WORD wDevID)
1189 {
1190 #ifdef linux
1191 dprintf_midi(stddeb,"modClose(%u);\n", wDevID);
1192 if (MidiOutDev[wDevID].unixdev == 0) {
1193 fprintf(stderr,"Linux 'modClose' // can't close !\n");
1194 return MMSYSERR_NOTENABLED;
1195 }
1196 close(MidiOutDev[wDevID].unixdev);
1197 MidiOutDev[wDevID].unixdev = 0;
1198 MidiOutDev[wDevID].bufsize = 0;
1199 if (MIDI_NotifyClient(wDevID, MOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
1200 fprintf(stderr,"Linux 'modClose' // can't notify client !\n");
1201 return MMSYSERR_INVALPARAM;
1202 }
1203 return MMSYSERR_NOERROR;
1204 #else
1205 return MMSYSERR_NOTENABLED;
1206 #endif
1207 }
1208
1209 /**************************************************************************
1210 * modData [internal]
1211 */
1212 DWORD modData(WORD wDevID, DWORD dwParam)
1213 {
1214 #ifdef linux
1215 WORD event;
1216 dprintf_midi(stddeb,
1217 "modData(%u, %08lX);\n", wDevID, dwParam);
1218 if (MidiOutDev[wDevID].unixdev == 0) {
1219 fprintf(stderr,"Linux 'modData' // can't play !\n");
1220 return MIDIERR_NODEVICE;
1221 }
1222 event = LOWORD(dwParam);
1223 if (write (MidiOutDev[wDevID].unixdev,
1224 &event, sizeof(WORD)) != sizeof(WORD)) {
1225 dprintf_midi(stddeb,
1226 "modData() // error writting unixdev !\n");
1227 }
1228 return MMSYSERR_NOTENABLED;
1229 #else
1230 return MMSYSERR_NOTENABLED;
1231 #endif
1232 }
1233
1234 /**************************************************************************
1235 * modLongData [internal]
1236 */
1237 DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1238 {
1239 #ifdef linux
1240 int count;
1241 LPWORD ptr;
1242 dprintf_midi(stddeb,
1243 "modLongData(%u, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1244 printf("modLongData(%u, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1245 if (MidiOutDev[wDevID].unixdev == 0) {
1246 fprintf(stderr,"Linux 'modLongData' // can't play !\n");
1247 return MIDIERR_NODEVICE;
1248 }
1249 if (lpMidiHdr->lpData == NULL) return MIDIERR_UNPREPARED;
1250 if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
1251 if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
1252 lpMidiHdr->dwFlags &= ~MHDR_DONE;
1253 lpMidiHdr->dwFlags |= MHDR_INQUEUE;
1254 dprintf_midi(stddeb,
1255 "modLongData() // dwBytesRecorded %lu !\n", lpMidiHdr->dwBytesRecorded);
1256 /*
1257 count = write (MidiOutDev[wDevID].unixdev,
1258 lpMidiHdr->lpData, lpMidiHdr->dwBytesRecorded);
1259 */
1260 ptr = (LPWORD)lpMidiHdr->lpData;
1261 for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) {
1262 if (write (MidiOutDev[wDevID].unixdev, ptr,
1263 sizeof(WORD)) != sizeof(WORD)) break;
1264 ptr++;
1265 }
1266 if (count != lpMidiHdr->dwBytesRecorded) {
1267 dprintf_midi(stddeb,
1268 "modLongData() // error writting unixdev #%d ! (%d != %ld)\n",
1269 MidiOutDev[wDevID].unixdev, count, lpMidiHdr->dwBytesRecorded);
1270 return MMSYSERR_NOTENABLED;
1271 }
1272 lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1273 lpMidiHdr->dwFlags |= MHDR_DONE;
1274 if (MIDI_NotifyClient(wDevID, MOM_DONE, 0L, 0L) != MMSYSERR_NOERROR) {
1275 fprintf(stderr,"Linux 'modLongData' // can't notify client !\n");
1276 return MMSYSERR_INVALPARAM;
1277 }
1278 return MMSYSERR_NOERROR;
1279 #else
1280 return MMSYSERR_NOTENABLED;
1281 #endif
1282 }
1283
1284 /**************************************************************************
1285 * modPrepare [internal]
1286 */
1287 DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1288 {
1289 #ifdef linux
1290 dprintf_midi(stddeb,
1291 "modPrepare(%u, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1292 if (MidiOutDev[wDevID].unixdev == 0) {
1293 fprintf(stderr,"Linux 'modPrepare' // can't prepare !\n");
1294 return MMSYSERR_NOTENABLED;
1295 }
1296 if (MidiOutDev[wDevID].lpQueueHdr != NULL) {
1297 fprintf(stderr,"Linux 'modPrepare' // already prepare !\n");
1298 return MMSYSERR_NOTENABLED;
1299 }
1300 MidiOutDev[wDevID].dwTotalPlayed = 0;
1301 MidiOutDev[wDevID].lpQueueHdr = lpMidiHdr;
1302 if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
1303 lpMidiHdr->dwFlags |= MHDR_PREPARED;
1304 lpMidiHdr->dwFlags &= ~MHDR_DONE;
1305 return MMSYSERR_NOERROR;
1306 #else
1307 return MMSYSERR_NOTENABLED;
1308 #endif
1309 }
1310
1311 /**************************************************************************
1312 * modUnprepare [internal]
1313 */
1314 DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1315 {
1316 #ifdef linux
1317 dprintf_midi(stddeb,
1318 "modUnprepare(%u, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1319 if (MidiOutDev[wDevID].unixdev == 0) {
1320 fprintf(stderr,"Linux 'modUnprepare' // can't unprepare !\n");
1321 return MMSYSERR_NOTENABLED;
1322 }
1323 return MMSYSERR_NOERROR;
1324 #else
1325 return MMSYSERR_NOTENABLED;
1326 #endif
1327 }
1328
1329 /**************************************************************************
1330 * modReset [internal]
1331 */
1332 DWORD modReset(WORD wDevID)
1333 {
1334 printf("modReset(%u);\n", wDevID);
1335 return MMSYSERR_NOTENABLED;
1336 }
1337
1338
1339 /**************************************************************************
1340 * modGetPosition [internal]
1341 */
1342 DWORD modGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1343 {
1344 printf("modGetposition(%u, %p, %08lX);\n", wDevID, lpTime, uSize);
1345 return MMSYSERR_NOTENABLED;
1346 }
1347
1348
1349 /**************************************************************************
1350 * modMessage [sample driver]
1351 */
1352 DWORD modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1353 DWORD dwParam1, DWORD dwParam2)
1354 {
1355 printf("modMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
1356 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1357 switch(wMsg) {
1358 case MODM_OPEN:
1359 return modOpen(wDevID, (LPMIDIOPENDESC)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1360 case MODM_CLOSE:
1361 return modClose(wDevID);
1362 case MODM_DATA:
1363 return modData(wDevID, dwParam1);
1364 case MODM_LONGDATA:
1365 return modLongData(wDevID, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1366 case MODM_PREPARE:
1367 return modPrepare(wDevID, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1368 case MODM_UNPREPARE:
1369 return modUnprepare(wDevID, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1370 case MODM_GETDEVCAPS:
1371 return modGetDevCaps(wDevID, (LPMIDIOUTCAPS)PTR_SEG_TO_LIN(dwParam1), dwParam2);
1372 case MODM_GETNUMDEVS:
1373 return 1L;
1374 case MODM_GETVOLUME:
1375 return 0L;
1376 case MODM_SETVOLUME:
1377 return 0L;
1378 case MODM_RESET:
1379 return modReset(wDevID);
1380 }
1381 return MMSYSERR_NOTSUPPORTED;
1382 }
1383
1384
1385 /*-----------------------------------------------------------------------*/
1386
1387 #endif /* #ifdef BUILTIN_MMSYSTEM */
Windows API implementation