?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Made more cross-platform by changing ->_fileno to fileno().
[wine/multimedia.git] / multimedia / midi.c
blob8c8fdf3b4ed99e415cf96e299d5cb6102643d766
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * Sample MIDI Wine Driver for Linux
5 *
6 * Copyright 1994 Martin Ayotte
7 */
8
9 /*
10 * Eric POUECH :
11 * 98/7 changes for making this MIDI driver work on OSS
12 * current support is limited to MIDI ports of OSS systems
13 * 98/9 rewriting MCI code for MIDI
14 * 98/11 splitted in midi.c and mcimidi.c
15 */
16
17 #include <errno.h>
18 #include <string.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <sys/ioctl.h>
24 #include "windows.h"
25 #include "ldt.h"
26 #include "multimedia.h"
27 #include "user.h"
28 #include "driver.h"
29 #include "mmsystem.h"
30 #include "xmalloc.h"
31 #include "debug.h"
32 #include "callback.h"
33 #include "options.h"
34 #include "heap.h"
35
36 typedef struct {
37 #ifndef HAVE_OSS
38 int unixdev;
39 #endif
40 int state;
41 DWORD bufsize;
42 LPMIDIOPENDESC midiDesc;
43 WORD wFlags;
44 LPMIDIHDR lpQueueHdr;
45 DWORD dwTotalPlayed;
46 #ifdef HAVE_OSS
47 unsigned char incoming[3];
48 unsigned char incPrev;
49 char incLen;
50 DWORD startTime;
51 #endif
52 } WINE_MIDIIN;
53
54 typedef struct {
55 #ifndef HAVE_OSS
56 int unixdev;
57 #endif
58 int state;
59 DWORD bufsize;
60 LPMIDIOPENDESC midiDesc;
61 WORD wFlags;
62 LPMIDIHDR lpQueueHdr;
63 DWORD dwTotalPlayed;
64 #ifdef HAVE_OSS
65 void* lpExtra; /* according to port type (MIDI, FM...), extra data when needed */
66 #endif
67 } WINE_MIDIOUT;
68
69 static WINE_MIDIIN MidiInDev [MAX_MIDIINDRV ];
70 static WINE_MIDIOUT MidiOutDev[MAX_MIDIOUTDRV];
71
72 /* this is the total number of MIDI out devices found */
73 int MODM_NUMDEVS = 0;
74 /* this is the number of FM synthetizers (index from 0 to
75 NUMFMSYNTHDEVS - 1) */
76 int MODM_NUMFMSYNTHDEVS = 0;
77 /* this is the number of Midi ports (index from NUMFMSYNTHDEVS to
78 NUMFMSYNTHDEVS + NUMMIDIDEVS - 1) */
79 int MODM_NUMMIDIDEVS = 0;
80
81 /* this is the total number of MIDI out devices found */
82 int MIDM_NUMDEVS = 0;
83
84 #ifdef HAVE_OSS
85 static int midiSeqFD = -1;
86 static int numOpenMidiSeq = 0;
87 static UINT32 midiInTimerID = 0;
88 static int numStartedMidiIn = 0;
89 #endif /* HAVE_OSS */
90
91 /* this structure holds pointers with information for each MIDI
92 * out device found.
93 */
94 LPMIDIOUTCAPS16 midiOutDevices[MAX_MIDIOUTDRV];
95
96 /* this structure holds pointers with information for each MIDI
97 * in device found.
98 */
99 LPMIDIINCAPS16 midiInDevices [MAX_MIDIINDRV];
100
101 /*
102 * FIXME : all tests on device ID for midXXX and modYYY are made against
103 * MAX_MIDIxxDRV (when they are made) but should be done against the actual
104 * number of midi devices found...
105 * check also when HAVE_OSS is defined that midiDesc is not NULL
106 */
107
108 /*======================================================================*
109 * Low level MIDI implemantation *
110 *======================================================================*/
111
112 /**************************************************************************
113 * MIDI_NotifyClient [internal]
114 */
115 static DWORD MIDI_NotifyClient(UINT16 wDevID, WORD wMsg,
116 DWORD dwParam1, DWORD dwParam2)
117 {
118 DWORD dwCallBack;
119 UINT16 uFlags;
120 HANDLE16 hDev;
121 DWORD dwInstance;
122
123 TRACE(midi,"wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",
124 wDevID, wMsg, dwParam1, dwParam2);
125
126 switch (wMsg) {
127 case MOM_OPEN:
128 case MOM_CLOSE:
129 case MOM_DONE:
130 if (wDevID > MAX_MIDIOUTDRV)
131 return MCIERR_INTERNAL;
132
133 dwCallBack = MidiOutDev[wDevID].midiDesc->dwCallback;
134 uFlags = MidiOutDev[wDevID].wFlags;
135 hDev = MidiOutDev[wDevID].midiDesc->hMidi;
136 dwInstance = MidiOutDev[wDevID].midiDesc->dwInstance;
137 break;
138
139 case MIM_OPEN:
140 case MIM_CLOSE:
141 case MIM_DATA:
142 case MIM_ERROR:
143 if (wDevID > MAX_MIDIINDRV)
144 return MCIERR_INTERNAL;
145
146 dwCallBack = MidiInDev[wDevID].midiDesc->dwCallback;
147 uFlags = MidiInDev[wDevID].wFlags;
148 hDev = MidiInDev[wDevID].midiDesc->hMidi;
149 dwInstance = MidiInDev[wDevID].midiDesc->dwInstance;
150 break;
151 default:
152 WARN(midi, "Unsupported MSW-MIDI message %u\n", wMsg);
153 return MCIERR_INTERNAL;
154 }
155
156 return DriverCallback(dwCallBack, uFlags, hDev, wMsg, dwInstance, dwParam1, dwParam2) ?
157 0 : MCIERR_INTERNAL;
158 }
159
160 #ifdef HAVE_OSS
161 /**************************************************************************
162 * midiOpenSeq [internal]
163 */
164 static int midiOpenSeq(void)
165 {
166 if (numOpenMidiSeq == 0) {
167 midiSeqFD = open(MIDI_SEQ, O_RDWR, 0);
168 if (midiSeqFD == -1) {
169 ERR(midi, "can't open '%s' ! (%d)\n", MIDI_SEQ, errno);
170 return -1;
171 }
172 if (fcntl(midiSeqFD, F_SETFL, O_NONBLOCK) < 0) {
173 WARN(midi, "can't set sequencer fd to non blocking (%d)\n", errno);
174 close(midiSeqFD);
175 midiSeqFD = -1;
176 return -1;
177 }
178 ioctl(midiSeqFD, SNDCTL_SEQ_RESET);
179 }
180 numOpenMidiSeq++;
181 return 0;
182 }
183
184 /**************************************************************************
185 * midiCloseSeq [internal]
186 */
187 static int midiCloseSeq(void)
188 {
189 if (--numOpenMidiSeq == 0) {
190 close(midiSeqFD);
191 midiSeqFD = -1;
192 }
193 return 0;
194 }
195
196 /* FIXME: this is a bad idea, it's even not static... */
197 SEQ_DEFINEBUF(1024);
198
199 /* FIXME: this is not reentrant, not static - because of global variable
200 * _seqbuf and al. */
201 /**************************************************************************
202 * seqbuf_dump [internal]
203 */
204 void seqbuf_dump(void)
205 {
206 if (_seqbufptr) {
207 if (write(midiSeqFD, _seqbuf, _seqbufptr) == -1) {
208 WARN(midi, "Can't write data to sequencer (%d/%d)!\n",
209 midiSeqFD, errno);
210 }
211 /* FIXME:
212 * in any case buffer is lost so that if many errors occur the buffer
213 * will not overrun
214 */
215 _seqbufptr = 0;
216 }
217 }
218 #endif /* HAVE_OSS */
219
220 #ifdef HAVE_OSS
221
222 static void midReceiveChar(WORD wDevID, unsigned char value, DWORD dwTime)
223 {
224 DWORD toSend = 0;
225
226 TRACE(midi, "Adding %02xh to %d[%d]\n", value, wDevID, MidiInDev[wDevID].incLen);
227
228 if (wDevID >= MAX_MIDIINDRV) {
229 WARN(midi, "bad devID\n");
230 return;
231 }
232 if (MidiInDev[wDevID].state == 0) {
233 TRACE(midi, "input not started, thrown away\n");
234 return;
235 }
236
237 if (MidiInDev[wDevID].state & 2) { /* system exclusive */
238 LPMIDIHDR ptr = MidiInDev[wDevID].lpQueueHdr;
239 WORD sbfb = FALSE;
240
241 if (ptr) {
242 ((LPSTR)(ptr->reserved))[ptr->dwBytesRecorded++] = value;
243 if (ptr->dwBytesRecorded == ptr->dwBufferLength) {
244 sbfb = TRUE;
245 }
246 }
247 if (value == 0xF7) { /* then end */
248 MidiInDev[wDevID].state &= ~2;
249 sbfb = TRUE;
250 }
251 if (sbfb && ptr != NULL) {
252 ptr = MidiInDev[wDevID].lpQueueHdr;
253 ptr->dwFlags &= ~MHDR_INQUEUE;
254 ptr->dwFlags |= MHDR_DONE;
255 MidiInDev[wDevID].lpQueueHdr = (LPMIDIHDR)ptr->lpNext;
256 if (MIDI_NotifyClient(wDevID, MIM_LONGDATA, (DWORD)ptr, dwTime) != MMSYSERR_NOERROR) {
257 WARN(midi, "Couldn't notify client\n");
258 }
259 }
260 return;
261 }
262
263 #define IS_CMD(_x) (((_x) & 0x80) == 0x80)
264 #define IS_SYS_CMD(_x) (((_x) & 0xF0) == 0xF0)
265
266 if (!IS_CMD(value) && MidiInDev[wDevID].incLen == 0) { /* try to reuse old cmd */
267 if (IS_CMD(MidiInDev[wDevID].incPrev) && !IS_SYS_CMD(MidiInDev[wDevID].incPrev)) {
268 MidiInDev[wDevID].incoming[0] = MidiInDev[wDevID].incPrev;
269 MidiInDev[wDevID].incLen = 1;
270 TRACE(midi, "Reusing old command %02xh\n", MidiInDev[wDevID].incPrev);
271 } else {
272 FIXME(midi, "error for midi-in, should generate MIM_ERROR notification:"
273 " prev=%02Xh, incLen=%02Xh\n",
274 MidiInDev[wDevID].incPrev, MidiInDev[wDevID].incLen);
275 return;
276 }
277 }
278 MidiInDev[wDevID].incoming[(int)(MidiInDev[wDevID].incLen++)] = value;
279 if (MidiInDev[wDevID].incLen == 1 && !IS_SYS_CMD(MidiInDev[wDevID].incoming[0])) {
280 /* store new cmd, just in case */
281 MidiInDev[wDevID].incPrev = MidiInDev[wDevID].incoming[0];
282 }
283
284 #undef IS_CMD(_x)
285 #undef IS_SYS_CMD(_x)
286
287 switch (MidiInDev[wDevID].incoming[0] & 0xF0) {
288 case MIDI_NOTEOFF:
289 case MIDI_NOTEON:
290 case MIDI_KEY_PRESSURE:
291 case MIDI_CTL_CHANGE:
292 case MIDI_PITCH_BEND:
293 if (MidiInDev[wDevID].incLen == 3) {
294 toSend = (MidiInDev[wDevID].incoming[2] << 16) |
295 (MidiInDev[wDevID].incoming[1] << 8) |
296 (MidiInDev[wDevID].incoming[0] << 0);
297 }
298 break;
299 case MIDI_PGM_CHANGE:
300 case MIDI_CHN_PRESSURE:
301 if (MidiInDev[wDevID].incLen == 2) {
302 toSend = (MidiInDev[wDevID].incoming[1] << 8) |
303 (MidiInDev[wDevID].incoming[0] << 0);
304 }
305 break;
306 case MIDI_SYSTEM_PREFIX:
307 if (MidiInDev[wDevID].incoming[0] == 0xF0) {
308 MidiInDev[wDevID].state |= 2;
309 MidiInDev[wDevID].incLen = 0;
310 } else {
311 if (MidiInDev[wDevID].incLen == 1) {
312 toSend = (MidiInDev[wDevID].incoming[0] << 0);
313 }
314 }
315 break;
316 default:
317 WARN(midi, "This shouldn't happen (%02X)\n", MidiInDev[wDevID].incoming[0]);
318 }
319 if (toSend != 0) {
320 TRACE(midi, "Sending event %08lx\n", toSend);
321 MidiInDev[wDevID].incLen = 0;
322 dwTime -= MidiInDev[wDevID].startTime;
323 if (MIDI_NotifyClient(wDevID, MIM_DATA, toSend, dwTime) != MMSYSERR_NOERROR) {
324 WARN(midi, "Couldn't notify client\n");
325 }
326 }
327 }
328
329 static VOID WINAPI midTimeCallback(HWND32 hwnd, UINT32 msg, UINT32 id, DWORD dwTime)
330 {
331 unsigned char buffer[256];
332 int len, idx;
333
334 TRACE(midi, "(%04X, %d, %d, %lu)\n", hwnd, msg, id, dwTime);
335
336 len = read(midiSeqFD, buffer, sizeof(buffer));
337
338 if ((len % 4) != 0) {
339 WARN(midi, "bad length %d (%d)\n", len, errno);
340 return;
341 }
342
343 for (idx = 0; idx < len; ) {
344 if (buffer[idx] & 0x80) {
345 TRACE(midi,
346 "reading<8> %02x %02x %02x %02x %02x %02x %02x %02x\n",
347 buffer[idx + 0], buffer[idx + 1],
348 buffer[idx + 2], buffer[idx + 3],
349 buffer[idx + 4], buffer[idx + 5],
350 buffer[idx + 6], buffer[idx + 7]);
351 idx += 8;
352 } else {
353 switch (buffer[idx + 0]) {
354 case SEQ_WAIT:
355 case SEQ_ECHO:
356 break;
357 case SEQ_MIDIPUTC:
358 midReceiveChar(buffer[idx + 2], buffer[idx + 1], dwTime);
359 break;
360 default:
361 TRACE(midi, "Unsupported event %d\n", buffer[idx + 0]);
362 break;
363 }
364 idx += 4;
365 }
366 }
367 }
368 #endif /* HAVE_OSS */
369
370 /**************************************************************************
371 * midGetDevCaps [internal]
372 */
373 static DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS16 lpCaps, DWORD dwSize)
374 {
375 LPMIDIINCAPS16 tmplpCaps;
376
377 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpCaps, dwSize);
378
379 if (wDevID >= MIDM_NUMDEVS) {
380 return MMSYSERR_BADDEVICEID;
381 }
382 if (lpCaps == NULL) {
383 return MMSYSERR_INVALPARAM;
384 }
385
386 tmplpCaps = midiInDevices[wDevID];
387 lpCaps->wMid = tmplpCaps->wMid;
388 lpCaps->wPid = tmplpCaps->wPid;
389 lpCaps->vDriverVersion = tmplpCaps->vDriverVersion;
390 strcpy(lpCaps->szPname, tmplpCaps->szPname);
391 if (dwSize == sizeof(MIDIINCAPS16)) {
392 /* we should run win 95, so make use of dwSupport */
393 lpCaps->dwSupport = tmplpCaps->dwSupport;
394 } else if (dwSize != sizeof(MIDIINCAPS16) - sizeof(DWORD)) {
395 TRACE(midi, "bad size for lpCaps\n");
396 return MMSYSERR_INVALPARAM;
397 }
398
399 return MMSYSERR_NOERROR;
400 }
401
402 /**************************************************************************
403 * midOpen [internal]
404 */
405 static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
406 {
407 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
408
409 if (lpDesc == NULL) {
410 WARN(midi, "Invalid Parameter !\n");
411 return MMSYSERR_INVALPARAM;
412 }
413 /* FIXME :
414 * how to check that content of lpDesc is correct ?
415 */
416 if (wDevID >= MAX_MIDIINDRV) {
417 WARN(midi,"wDevID too large (%u) !\n", wDevID);
418 return MMSYSERR_BADDEVICEID;
419 }
420 if (MidiInDev[wDevID].midiDesc != 0) {
421 WARN(midi, "device already open !\n");
422 return MMSYSERR_ALLOCATED;
423 }
424 if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) {
425 FIXME(midi, "No support for MIDI_IO_STATUS in dwFlags\n");
426 return MMSYSERR_INVALFLAG;
427 }
428
429 #ifdef HAVE_OSS
430 if (midiOpenSeq() < 0) {
431 return MMSYSERR_ERROR;
432 }
433
434 if (numStartedMidiIn++ == 0) {
435 midiInTimerID = SetTimer32(0, 0, 250, midTimeCallback);
436 if (!midiInTimerID) {
437 numStartedMidiIn = 0;
438 WARN(midi, "Couldn't start timer for midi-in\n");
439 midiCloseSeq();
440 return MMSYSERR_ERROR;
441 }
442 TRACE(midi, "Starting timer (%u) for midi-in\n", midiInTimerID);
443 }
444 #else /* HAVE_OSS */
445 {
446 int midi = open(MIDI_DEV, O_WRONLY, 0);
447
448 MidiInDev[wDevID].unixdev = 0;
449 if (midi == -1) {
450 WARN(midi,"can't open '%s' (%d)!\n", MIDI_DEV, errno);
451 return MMSYSERR_ALLOCATED;
452 }
453 MidiInDev[wDevID].unixdev = midi;
454 }
455 #endif /* HAVE_OSS */
456
457 MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
458 switch (MidiInDev[wDevID].wFlags) {
459 case DCB_NULL:
460 TRACE(midi,"CALLBACK_NULL !\n");
461 break;
462 case DCB_WINDOW:
463 TRACE(midi, "CALLBACK_WINDOW !\n");
464 break;
465 case DCB_TASK:
466 TRACE(midi, "CALLBACK_TASK !\n");
467 break;
468 case DCB_FUNCTION:
469 TRACE(midi, "CALLBACK_FUNCTION (%08lX)!\n", lpDesc->dwCallback);
470 break;
471 }
472 MidiInDev[wDevID].lpQueueHdr = NULL;
473 MidiInDev[wDevID].dwTotalPlayed = 0;
474 MidiInDev[wDevID].bufsize = 0x3FFF;
475 MidiInDev[wDevID].midiDesc = lpDesc;
476 MidiInDev[wDevID].state = 0;
477 #ifdef HAVE_OSS
478 MidiInDev[wDevID].incLen = 0;
479 MidiInDev[wDevID].startTime = 0;
480 #endif /* HAVE_OSS */
481 if (MIDI_NotifyClient(wDevID, MIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
482 WARN(midi,"can't notify client !\n");
483 return MMSYSERR_INVALPARAM;
484 }
485 return MMSYSERR_NOERROR;
486 }
487
488 /**************************************************************************
489 * midClose [internal]
490 */
491 static DWORD midClose(WORD wDevID)
492 {
493 int ret = MMSYSERR_NOERROR;
494
495 TRACE(midi, "(%04X);\n", wDevID);
496
497 if (wDevID >= MAX_MIDIINDRV) {
498 WARN(midi,"wDevID too bif (%u) !\n", wDevID);
499 return MMSYSERR_BADDEVICEID;
500 }
501 if (MidiInDev[wDevID].midiDesc == 0) {
502 WARN(midi, "device not opened !\n");
503 return MMSYSERR_ERROR;
504 }
505 if (MidiInDev[wDevID].lpQueueHdr != 0) {
506 return MIDIERR_STILLPLAYING;
507 }
508
509 #ifdef HAVE_OSS
510 if (midiSeqFD == -1) {
511 WARN(midi,"ooops !\n");
512 return MMSYSERR_ERROR;
513 }
514 if (--numStartedMidiIn == 0) {
515 TRACE(midi, "Stopping timer for midi-in\n");
516 if (!KillTimer32(0, midiInTimerID)) {
517 WARN(midi, "Couldn't stop timer for midi-in\n");
518 }
519 midiInTimerID = 0;
520 }
521 midiCloseSeq();
522 #else /* HAVE_OSS */
523 if (MidiInDev[wDevID].unixdev == 0) {
524 WARN(midi,"ooops !\n");
525 return MMSYSERR_ERROR;
526 }
527 close(MidiInDev[wDevID].unixdev);
528 MidiInDev[wDevID].unixdev = 0;
529 #endif /* HAVE_OSS */
530 MidiInDev[wDevID].bufsize = 0;
531 if (MIDI_NotifyClient(wDevID, MIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
532 WARN(midi,"can't notify client !\n");
533 ret = MMSYSERR_INVALPARAM;
534 }
535 MidiInDev[wDevID].midiDesc = 0;
536 return ret;
537 }
538
539 /**************************************************************************
540 * midAddBuffer [internal]
541 */
542 static DWORD midAddBuffer(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
543 {
544 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
545
546 if (lpMidiHdr == NULL) return MMSYSERR_INVALPARAM;
547 if (sizeof(MIDIHDR) != dwSize) return MMSYSERR_INVALPARAM;
548 if (lpMidiHdr->dwBufferLength == 0) return MMSYSERR_INVALPARAM;
549 if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
550 if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
551
552 if (MidiInDev[wDevID].lpQueueHdr == 0) {
553 MidiInDev[wDevID].lpQueueHdr = lpMidiHdr;
554 } else {
555 LPMIDIHDR ptr;
556
557 for (ptr = MidiInDev[wDevID].lpQueueHdr;
558 ptr->lpNext != 0;
559 ptr = (LPMIDIHDR)ptr->lpNext);
560 ptr->lpNext = (struct midihdr_tag*)lpMidiHdr;
561 }
562 return MMSYSERR_NOERROR;
563 }
564
565 /**************************************************************************
566 * midPrepare [internal]
567 */
568 static DWORD midPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
569 {
570 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
571
572 if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0 ||
573 lpMidiHdr->lpData == 0 || lpMidiHdr->dwFlags != 0 ||
574 lpMidiHdr->dwBufferLength >= 0x10000ul)
575 return MMSYSERR_INVALPARAM;
576
577 lpMidiHdr->lpNext = 0;
578 lpMidiHdr->dwFlags |= MHDR_PREPARED;
579 lpMidiHdr->dwBytesRecorded = 0;
580
581 return MMSYSERR_NOERROR;
582 }
583
584 /**************************************************************************
585 * midUnprepare [internal]
586 */
587 static DWORD midUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
588 {
589 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
590
591 if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0 ||
592 lpMidiHdr->lpData == 0 || lpMidiHdr->dwBufferLength >= 0x10000ul)
593 return MMSYSERR_INVALPARAM;
594
595 if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
596 if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
597
598 lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
599
600 return MMSYSERR_NOERROR;
601 }
602
603 /**************************************************************************
604 * midReset [internal]
605 */
606 static DWORD midReset(WORD wDevID)
607 {
608 DWORD dwTime = GetTickCount();
609
610 TRACE(midi, "(%04X);\n", wDevID);
611
612 while (MidiInDev[wDevID].lpQueueHdr) {
613 MidiInDev[wDevID].lpQueueHdr->dwFlags &= ~MHDR_INQUEUE;
614 MidiInDev[wDevID].lpQueueHdr->dwFlags |= MHDR_DONE;
615 if (MIDI_NotifyClient(wDevID, MIM_LONGDATA,
616 (DWORD)MidiInDev[wDevID].lpQueueHdr, dwTime) != MMSYSERR_NOERROR) {
617 WARN(midi, "Couldn't notify client\n");
618 }
619 MidiInDev[wDevID].lpQueueHdr = (LPMIDIHDR)MidiInDev[wDevID].lpQueueHdr->lpNext;
620 }
621
622 return MMSYSERR_NOERROR;
623 }
624
625
626 /**************************************************************************
627 * midStart [internal]
628 */
629 static DWORD midStart(WORD wDevID)
630 {
631 TRACE(midi, "(%04X);\n", wDevID);
632
633 /* FIXME : should test value of wDevID */
634
635 #ifdef HAVE_OSS
636 MidiInDev[wDevID].state = 1;
637 MidiInDev[wDevID].startTime = GetTickCount();
638 return MMSYSERR_NOERROR;
639 #else
640 return MMSYSERR_NOTENABLED;
641 #endif /* HAVE_OSS */
642 }
643
644 /**************************************************************************
645 * midStop [internal]
646 */
647 static DWORD midStop(WORD wDevID)
648 {
649 TRACE(midi, "(%04X);\n", wDevID);
650
651 /* FIXME : should test value of wDevID */
652
653 #ifdef HAVE_OSS
654 MidiInDev[wDevID].state = 0;
655 return MMSYSERR_NOERROR;
656 #else /* HAVE_OSS */
657 return MMSYSERR_NOTENABLED;
658 #endif /* HAVE_OSS */
659 }
660
661 /**************************************************************************
662 * midMessage [sample driver]
663 */
664 DWORD WINAPI midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
665 DWORD dwParam1, DWORD dwParam2)
666 {
667 TRACE(midi, "(%04X, %04X, %08lX, %08lX, %08lX);\n",
668 wDevID, wMsg, dwUser, dwParam1, dwParam2);
669 switch (wMsg) {
670 case MIDM_OPEN:
671 return midOpen(wDevID,(LPMIDIOPENDESC)dwParam1, dwParam2);
672 case MIDM_CLOSE:
673 return midClose(wDevID);
674 case MIDM_ADDBUFFER:
675 return midAddBuffer(wDevID,(LPMIDIHDR)dwParam1, dwParam2);
676 case MIDM_PREPARE:
677 return midPrepare(wDevID,(LPMIDIHDR)dwParam1, dwParam2);
678 case MIDM_UNPREPARE:
679 return midUnprepare(wDevID,(LPMIDIHDR)dwParam1, dwParam2);
680 case MIDM_GETDEVCAPS:
681 return midGetDevCaps(wDevID,(LPMIDIINCAPS16)dwParam1,dwParam2);
682 case MIDM_GETNUMDEVS:
683 return MIDM_NUMDEVS;
684 case MIDM_RESET:
685 return midReset(wDevID);
686 case MIDM_START:
687 return midStart(wDevID);
688 case MIDM_STOP:
689 return midStop(wDevID);
690 default:
691 TRACE(midi, "Unsupported message\n");
692 }
693 return MMSYSERR_NOTSUPPORTED;
694 }
695
696 /*-----------------------------------------------------------------------*/
697
698 #ifdef HAVE_OSS
699
700 typedef struct sVoice {
701 int note; /* 0 means not used */
702 int channel;
703 unsigned cntMark : 30,
704 status : 2;
705 #define sVS_UNUSED 0
706 #define sVS_PLAYING 1
707 #define sVS_SUSTAINED 2
708 } sVoice;
709
710 typedef struct sChannel {
711 int program;
712
713 int bender;
714 int benderRange;
715 /* controlers */
716 int bank; /* CTL_BANK_SELECT */
717 int volume; /* CTL_MAIN_VOLUME */
718 int balance; /* CTL_BALANCE */
719 int expression; /* CTL_EXPRESSION */
720 int sustain; /* CTL_SUSTAIN */
721
722 unsigned char nrgPmtMSB; /* Non register Parameters */
723 unsigned char nrgPmtLSB;
724 unsigned char regPmtMSB; /* Non register Parameters */
725 unsigned char regPmtLSB;
726 } sChannel;
727
728 typedef struct sFMextra {
729 unsigned counter;
730 int drumSetMask;
731 sChannel channel[16]; /* MIDI has only 16 channels */
732 sVoice voice[1]; /* dyn allocated according to sound card */
733 /* do not append fields below voice[1] since the size of this structure
734 * depends on the number of available voices on the FM synth...
735 */
736 } sFMextra;
737
738 extern unsigned char midiFMInstrumentPatches[16 * 128];
739 extern unsigned char midiFMDrumsPatches [16 * 128];
740
741 /**************************************************************************
742 * modFMLoad [internal]
743 */
744 static int modFMLoad(int dev)
745 {
746 int i;
747 struct sbi_instrument sbi;
748
749 sbi.device = dev;
750 sbi.key = FM_PATCH;
751
752 memset(sbi.operators + 16, 0, 16);
753 for (i = 0; i < 128; i++) {
754 sbi.channel = i;
755 memcpy(sbi.operators, midiFMInstrumentPatches + i * 16, 16);
756
757 if (write(midiSeqFD, (char*)&sbi, sizeof(sbi)) == -1) {
758 WARN(midi, "Couldn't write patch for instrument %d (%d)!\n", sbi.channel, errno);
759 return -1;
760 }
761 }
762 for (i = 0; i < 128; i++) {
763 sbi.channel = 128 + i;
764 memcpy(sbi.operators, midiFMDrumsPatches + i * 16, 16);
765
766 if (write(midiSeqFD, (char*)&sbi, sizeof(sbi)) == -1) {
767 WARN(midi, "Couldn't write patch for drum %d (%d)!\n", sbi.channel, errno);
768 return -1;
769 }
770 }
771 return 0;
772 }
773
774 /**************************************************************************
775 * modFMReset [internal]
776 */
777 static void modFMReset(WORD wDevID)
778 {
779 sFMextra* extra = (sFMextra*)MidiOutDev[wDevID].lpExtra;
780 sVoice* voice = extra->voice;
781 sChannel* channel = extra->channel;
782 int i;
783
784 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
785 if (voice[i].status != sVS_UNUSED) {
786 SEQ_STOP_NOTE(wDevID, i, voice[i].note, 64);
787 }
788 SEQ_KEY_PRESSURE(wDevID, i, 127, 0);
789 SEQ_CONTROL(wDevID, i, SEQ_VOLMODE, VOL_METHOD_LINEAR);
790 voice[i].note = 0;
791 voice[i].channel = -1;
792 voice[i].cntMark = 0;
793 voice[i].status = sVS_UNUSED;
794 }
795 for (i = 0; i < 16; i++) {
796 channel[i].program = 0;
797 channel[i].bender = 8192;
798 channel[i].benderRange = 2;
799 channel[i].bank = 0;
800 channel[i].volume = 127;
801 channel[i].balance = 64;
802 channel[i].expression = 0;
803 channel[i].sustain = 0;
804 }
805 extra->counter = 0;
806 extra->drumSetMask = 1 << 9; /* channel 10 is normally drums, sometimes 16 also */
807 SEQ_DUMPBUF();
808 }
809
810 #define IS_DRUM_CHANNEL(_xtra, _chn) ((_xtra)->drumSetMask & (1 << (_chn)))
811
812 #endif /* HAVE_OSS */
813
814 /**************************************************************************
815 * modGetDevCaps [internal]
816 */
817 static DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS16 lpCaps,
818 DWORD dwSize)
819 {
820 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpCaps, dwSize);
821 if (wDevID == (WORD) MIDI_MAPPER) {
822 lpCaps->wMid = 0x00FF; /* Manufac ID */
823 lpCaps->wPid = 0x0001; /* Product ID */
824 lpCaps->vDriverVersion = 0x001; /* Product Version */
825 strcpy(lpCaps->szPname, "MIDI Mapper (not functional yet)");
826 /* FIXME Does it make any difference ? */
827 lpCaps->wTechnology = MOD_FMSYNTH;
828 lpCaps->wVoices = 14; /* FIXME */
829 lpCaps->wNotes = 14; /* FIXME */
830 /* FIXME Does it make any difference ? */
831 lpCaps->dwSupport = MIDICAPS_VOLUME|MIDICAPS_LRVOLUME;
832 } else {
833 LPMIDIOUTCAPS16 tmplpCaps;
834
835 if (wDevID >= MODM_NUMDEVS) {
836 TRACE(midi, "MAX_MIDIOUTDRV reached !\n");
837 return MMSYSERR_BADDEVICEID;
838 }
839 /* FIXME There is a way to do it so easily, but I'm too
840 * sleepy to think and I want to test
841 */
842
843 tmplpCaps = midiOutDevices[wDevID];
844 lpCaps->wMid = tmplpCaps->wMid;
845 lpCaps->wPid = tmplpCaps->wPid;
846 lpCaps->vDriverVersion = tmplpCaps->vDriverVersion;
847 strcpy(lpCaps->szPname, tmplpCaps->szPname);
848 lpCaps->wTechnology = tmplpCaps->wTechnology;
849 lpCaps->wVoices = tmplpCaps->wVoices;
850 lpCaps->wNotes = tmplpCaps->wNotes;
851 lpCaps->dwSupport = tmplpCaps->dwSupport;
852 }
853 return MMSYSERR_NOERROR;
854 }
855
856 /**************************************************************************
857 * modOpen [internal]
858 */
859 static DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
860 {
861 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
862 if (lpDesc == NULL) {
863 WARN(midi, "Invalid Parameter !\n");
864 return MMSYSERR_INVALPARAM;
865 }
866 if (wDevID >= MAX_MIDIOUTDRV) {
867 TRACE(midi,"MAX_MIDIOUTDRV reached !\n");
868 return MMSYSERR_BADDEVICEID;
869 }
870 if (MidiOutDev[wDevID].midiDesc != 0) {
871 WARN(midi, "device already open !\n");
872 return MMSYSERR_ALLOCATED;
873 }
874 if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) {
875 WARN(midi, "bad dwFlags\n");
876 return MMSYSERR_INVALFLAG;
877 }
878 if (midiOutDevices[wDevID] == NULL) {
879 TRACE(midi, "un-allocated wDevID\n");
880 return MMSYSERR_BADDEVICEID;
881 }
882
883 #ifdef HAVE_OSS
884 MidiOutDev[wDevID].lpExtra = 0;
885
886 switch (midiOutDevices[wDevID]->wTechnology) {
887 case MOD_FMSYNTH:
888 {
889 void* extra = xmalloc(sizeof(struct sFMextra) +
890 sizeof(struct sVoice) *
891 (midiOutDevices[wDevID]->wVoices - 1));
892
893 if (extra == 0) {
894 WARN(midi, "can't alloc extra data !\n");
895 return MMSYSERR_NOMEM;
896 }
897 MidiOutDev[wDevID].lpExtra = extra;
898 if (midiOpenSeq() < 0) {
899 MidiOutDev[wDevID].lpExtra = 0;
900 free(extra);
901 return MMSYSERR_ERROR;
902 }
903 if (modFMLoad(wDevID) < 0) {
904 midiCloseSeq();
905 MidiOutDev[wDevID].lpExtra = 0;
906 free(extra);
907 return MMSYSERR_ERROR;
908 }
909 modFMReset(wDevID);
910 }
911 break;
912 case MOD_MIDIPORT:
913 if (midiOpenSeq() < 0) {
914 return MMSYSERR_ALLOCATED;
915 }
916 break;
917 default:
918 WARN(midi,"Technology not supported (yet) %d !\n",
919 midiOutDevices[wDevID]->wTechnology);
920 return MMSYSERR_NOTENABLED;
921 }
922 #else /* HAVE_OSS */
923 {
924 int midi = open (MIDI_DEV, O_WRONLY, 0);
925 MidiOutDev[wDevID].unixdev = 0;
926 if (midi == -1) {
927 WARN(midi, "can't open !\n");
928 return MMSYSERR_ALLOCATED;
929 }
930 MidiOutDev[wDevID].unixdev = midi;
931 }
932 #endif /* HAVE_OSS */
933
934 MidiOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
935 switch (MidiOutDev[wDevID].wFlags) {
936 case DCB_NULL:
937 TRACE(midi,"CALLBACK_NULL !\n");
938 break;
939 case DCB_WINDOW:
940 TRACE(midi, "CALLBACK_WINDOW !\n");
941 break;
942 case DCB_TASK:
943 TRACE(midi, "CALLBACK_TASK !\n");
944 break;
945 case DCB_FUNCTION:
946 TRACE(midi, "CALLBACK_FUNCTION !\n");
947 break;
948 }
949 MidiOutDev[wDevID].lpQueueHdr = NULL;
950 MidiOutDev[wDevID].dwTotalPlayed = 0;
951 MidiOutDev[wDevID].bufsize = 0x3FFF;
952 MidiOutDev[wDevID].midiDesc = lpDesc;
953
954 if (MIDI_NotifyClient(wDevID, MOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
955 WARN(midi,"can't notify client !\n");
956 return MMSYSERR_INVALPARAM;
957 }
958 TRACE(midi, "Succesful !\n");
959 return MMSYSERR_NOERROR;
960 }
961
962
963 /**************************************************************************
964 * modClose [internal]
965 */
966 static DWORD modClose(WORD wDevID)
967 {
968 int ret = MMSYSERR_NOERROR;
969
970 TRACE(midi, "(%04X);\n", wDevID);
971
972 if (MidiOutDev[wDevID].midiDesc == 0) {
973 WARN(midi, "device not opened !\n");
974 return MMSYSERR_ERROR;
975 }
976 /* FIXME: should test that no pending buffer is still in the queue for
977 * playing */
978
979 #ifdef HAVE_OSS
980 if (midiSeqFD == -1) {
981 WARN(midi,"can't close !\n");
982 return MMSYSERR_ERROR;
983 }
984
985 switch (midiOutDevices[wDevID]->wTechnology) {
986 case MOD_FMSYNTH:
987 case MOD_MIDIPORT:
988 midiCloseSeq();
989 break;
990 default:
991 WARN(midi,"Technology not supported (yet) %d !\n",
992 midiOutDevices[wDevID]->wTechnology);
993 return MMSYSERR_NOTENABLED;
994 }
995
996 if (MidiOutDev[wDevID].lpExtra != 0) {
997 free(MidiOutDev[wDevID].lpExtra);
998 MidiOutDev[wDevID].lpExtra = 0;
999 }
1000 #else
1001 if (MidiOutDev[wDevID].unixdev == 0) {
1002 WARN(midi,"can't close !\n");
1003 return MMSYSERR_NOTENABLED;
1004 }
1005 close(MidiOutDev[wDevID].unixdev);
1006 MidiOutDev[wDevID].unixdev = 0;
1007 #endif /* HAVE_OSS */
1008
1009 MidiOutDev[wDevID].bufsize = 0;
1010 if (MIDI_NotifyClient(wDevID, MOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
1011 WARN(midi,"can't notify client !\n");
1012 ret = MMSYSERR_INVALPARAM;
1013 }
1014 MidiOutDev[wDevID].midiDesc = 0;
1015 return ret;
1016 }
1017
1018 /**************************************************************************
1019 * modData [internal]
1020 */
1021 static DWORD modData(WORD wDevID, DWORD dwParam)
1022 {
1023 WORD evt = LOBYTE(LOWORD(dwParam));
1024 WORD d1 = HIBYTE(LOWORD(dwParam));
1025 WORD d2 = LOBYTE(HIWORD(dwParam));
1026
1027 TRACE(midi, "(%04X, %08lX);\n", wDevID, dwParam);
1028
1029 #ifdef HAVE_OSS
1030 if (midiSeqFD == -1) {
1031 WARN(midi,"can't play !\n");
1032 return MIDIERR_NODEVICE;
1033 }
1034 switch (midiOutDevices[wDevID]->wTechnology) {
1035 case MOD_FMSYNTH:
1036 /* FIXME:
1037 * - chorus depth controller is not used
1038 */
1039 {
1040 sFMextra* extra = (sFMextra*)MidiOutDev[wDevID].lpExtra;
1041 sVoice* voice = extra->voice;
1042 sChannel* channel = extra->channel;
1043 int chn = (evt & 0x0F);
1044 int i, nv;
1045
1046 switch (evt & 0xF0) {
1047 case MIDI_NOTEOFF:
1048 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1049 /* don't stop sustained notes */
1050 if (voice[i].status == sVS_PLAYING && voice[i].channel == chn && voice[i].note == d1) {
1051 voice[i].status = sVS_UNUSED;
1052 SEQ_STOP_NOTE(wDevID, i, d1, d2);
1053 }
1054 }
1055 break;
1056 case MIDI_NOTEON:
1057 if (d2 == 0) { /* note off if velocity == 0 */
1058 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1059 /* don't stop sustained notes */
1060 if (voice[i].status == sVS_PLAYING && voice[i].channel == chn && voice[i].note == d1) {
1061 voice[i].status = sVS_UNUSED;
1062 SEQ_STOP_NOTE(wDevID, i, d1, 64);
1063 }
1064 }
1065 break;
1066 }
1067 /* finding out in this order :
1068 * - an empty voice
1069 * - if replaying the same note on the same channel
1070 * - the older voice (LRU)
1071 */
1072 for (i = nv = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1073 if (voice[i].status == sVS_UNUSED ||
1074 (voice[i].note == d1 && voice[i].channel == chn)) {
1075 nv = i;
1076 break;
1077 }
1078 if (voice[i].cntMark < voice[0].cntMark) {
1079 nv = i;
1080 }
1081 }
1082 TRACE(midi,
1083 "playing on voice=%d, pgm=%d, pan=0x%02X, vol=0x%02X, "
1084 "bender=0x%02X, note=0x%02X, vel=0x%02X\n",
1085 nv, channel[chn].program,
1086 channel[chn].balance,
1087 channel[chn].volume,
1088 channel[chn].bender, d1, d2);
1089
1090 SEQ_SET_PATCH(wDevID, nv, IS_DRUM_CHANNEL(extra, chn) ?
1091 (128 + d1) : channel[chn].program);
1092 SEQ_BENDER_RANGE(wDevID, nv, channel[chn].benderRange * 100);
1093 SEQ_BENDER(wDevID, nv, channel[chn].bender);
1094 SEQ_CONTROL(wDevID, nv, CTL_PAN, channel[chn].balance);
1095 SEQ_CONTROL(wDevID, nv, CTL_EXPRESSION, channel[chn].expression);
1096 #if 0
1097 /* FIXME: does not really seem to work on my SB card and
1098 * screws everything up... so lay it down
1099 */
1100 SEQ_CONTROL(wDevID, nv, CTL_MAIN_VOLUME, channel[chn].volume);
1101 #endif
1102 SEQ_START_NOTE(wDevID, nv, d1, d2);
1103 voice[nv].status = channel[chn].sustain ? sVS_SUSTAINED : sVS_PLAYING;
1104 voice[nv].note = d1;
1105 voice[nv].channel = chn;
1106 voice[nv].cntMark = extra->counter++;
1107 break;
1108 case MIDI_KEY_PRESSURE:
1109 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1110 if (voice[i].status != sVS_UNUSED && voice[i].channel == chn && voice[i].note == d1) {
1111 SEQ_KEY_PRESSURE(wDevID, i, d1, d2);
1112 }
1113 }
1114 break;
1115 case MIDI_CTL_CHANGE:
1116 switch (d1) {
1117 case CTL_BANK_SELECT: channel[chn].bank = d2; break;
1118 case CTL_MAIN_VOLUME: channel[chn].volume = d2; break;
1119 case CTL_PAN: channel[chn].balance = d2; break;
1120 case CTL_EXPRESSION: channel[chn].expression = d2; break;
1121 case CTL_SUSTAIN: channel[chn].sustain = d2;
1122 if (d2) {
1123 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1124 if (voice[i].status == sVS_PLAYING && voice[i].channel == chn) {
1125 voice[i].status = sVS_SUSTAINED;
1126 }
1127 }
1128 } else {
1129 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1130 if (voice[i].status == sVS_SUSTAINED && voice[i].channel == chn) {
1131 voice[i].status = sVS_UNUSED;
1132 SEQ_STOP_NOTE(wDevID, i, voice[i].note, 64);
1133 }
1134 }
1135 }
1136 break;
1137 case CTL_NONREG_PARM_NUM_LSB: channel[chn].nrgPmtLSB = d2; break;
1138 case CTL_NONREG_PARM_NUM_MSB: channel[chn].nrgPmtMSB = d2; break;
1139 case CTL_REGIST_PARM_NUM_LSB: channel[chn].regPmtLSB = d2; break;
1140 case CTL_REGIST_PARM_NUM_MSB: channel[chn].regPmtMSB = d2; break;
1141
1142 case CTL_DATA_ENTRY:
1143 switch ((channel[chn].regPmtMSB << 8) | channel[chn].regPmtLSB) {
1144 case 0x0000:
1145 if (channel[chn].benderRange != d2) {
1146 channel[chn].benderRange = d2;
1147 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1148 if (voice[i].channel == chn) {
1149 SEQ_BENDER_RANGE(wDevID, i, channel[chn].benderRange);
1150 }
1151 }
1152 }
1153 break;
1154
1155 case 0x7F7F:
1156 channel[chn].benderRange = 2;
1157 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1158 if (voice[i].channel == chn) {
1159 SEQ_BENDER_RANGE(wDevID, i, channel[chn].benderRange);
1160 }
1161 }
1162 break;
1163 default:
1164 TRACE(midi, "Data entry: regPmt=0x%02x%02x, nrgPmt=0x%02x%02x with %x\n",
1165 channel[chn].regPmtMSB, channel[chn].regPmtLSB,
1166 channel[chn].nrgPmtMSB, channel[chn].nrgPmtLSB,
1167 d2);
1168 break;
1169 }
1170 break;
1171
1172 case 0x78: /* all sounds off */
1173 /* FIXME: I don't know if I have to take care of the channel
1174 * for this control ?
1175 */
1176 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1177 if (voice[i].status != sVS_UNUSED && voice[i].channel == chn) {
1178 voice[i].status = sVS_UNUSED;
1179 SEQ_STOP_NOTE(wDevID, i, voice[i].note, 0);
1180 }
1181 }
1182 break;
1183 case 0x7B: /* all notes off */
1184 /* FIXME: I don't know if I have to take care of the channel
1185 * for this control ?
1186 */
1187 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1188 if (voice[i].status == sVS_PLAYING && voice[i].channel == chn) {
1189 voice[i].status = sVS_UNUSED;
1190 SEQ_STOP_NOTE(wDevID, i, voice[i].note, 0);
1191 }
1192 }
1193 break;
1194 default:
1195 TRACE(midi, "Dropping MIDI control event 0x%02x(%02x) on channel %d\n",
1196 d1, d2, chn);
1197 break;
1198 }
1199 break;
1200 case MIDI_PGM_CHANGE:
1201 channel[chn].program = d1;
1202 break;
1203 case MIDI_CHN_PRESSURE:
1204 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1205 if (voice[i].status != sVS_UNUSED && voice[i].channel == chn) {
1206 SEQ_KEY_PRESSURE(wDevID, i, voice[i].note, d1);
1207 }
1208 }
1209 break;
1210 case MIDI_PITCH_BEND:
1211 channel[chn].bender = (d2 << 7) + d1;
1212 for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) {
1213 if (voice[i].channel == chn) {
1214 SEQ_BENDER(wDevID, i, channel[chn].bender);
1215 }
1216 }
1217 break;
1218 case MIDI_SYSTEM_PREFIX:
1219 switch (evt & 0x0F) {
1220 case 0x0F: /* Reset */
1221 modFMReset(wDevID);
1222 break;
1223 default:
1224 WARN(midi, "Unsupported (yet) system event %02x\n", evt & 0x0F);
1225 }
1226 break;
1227 default:
1228 WARN(midi, "Internal error, shouldn't happen (event=%08x)\n", evt & 0xF0);
1229 return MMSYSERR_NOTENABLED;
1230 }
1231 }
1232 break;
1233 case MOD_MIDIPORT:
1234 {
1235 int dev = wDevID - MODM_NUMFMSYNTHDEVS;
1236 if (dev < 0) {
1237 WARN(midi, "Internal error on devID (%u) !\n", wDevID);
1238 return MIDIERR_NODEVICE;
1239 }
1240
1241 switch (evt & 0xF0) {
1242 case MIDI_NOTEOFF:
1243 case MIDI_NOTEON:
1244 case MIDI_KEY_PRESSURE:
1245 case MIDI_CTL_CHANGE:
1246 case MIDI_PITCH_BEND:
1247 SEQ_MIDIOUT(dev, evt);
1248 SEQ_MIDIOUT(dev, d1);
1249 SEQ_MIDIOUT(dev, d2);
1250 break;
1251 case MIDI_PGM_CHANGE:
1252 case MIDI_CHN_PRESSURE:
1253 SEQ_MIDIOUT(dev, evt);
1254 SEQ_MIDIOUT(dev, d1);
1255 break;
1256 case MIDI_SYSTEM_PREFIX:
1257 switch (evt & 0x0F) {
1258 case 0x00: /* System Exclusive, don't do it on modData,
1259 * should require modLongData*/
1260 case 0x01: /* Undefined */
1261 case 0x04: /* Undefined. */
1262 case 0x05: /* Undefined. */
1263 case 0x07: /* End of Exclusive. */
1264 case 0x09: /* Undefined. */
1265 case 0x0D: /* Undefined. */
1266 break;
1267 case 0x06: /* Tune Request */
1268 case 0x08: /* Timing Clock. */
1269 case 0x0A: /* Start. */
1270 case 0x0B: /* Continue */
1271 case 0x0C: /* Stop */
1272 case 0x0E: /* Active Sensing. */
1273 SEQ_MIDIOUT(dev, evt);
1274 break;
1275 case 0x0F: /* Reset */
1276 /* SEQ_MIDIOUT(dev, evt);
1277 this other way may be better */
1278 SEQ_MIDIOUT(dev, MIDI_SYSTEM_PREFIX);
1279 SEQ_MIDIOUT(dev, 0x7e);
1280 SEQ_MIDIOUT(dev, 0x7f);
1281 SEQ_MIDIOUT(dev, 0x09);
1282 SEQ_MIDIOUT(dev, 0x01);
1283 SEQ_MIDIOUT(dev, 0xf7);
1284 break;
1285 case 0x03: /* Song Select. */
1286 SEQ_MIDIOUT(dev, evt);
1287 SEQ_MIDIOUT(dev, d1);
1288 case 0x02: /* Song Position Pointer. */
1289 SEQ_MIDIOUT(dev, evt);
1290 SEQ_MIDIOUT(dev, d1);
1291 SEQ_MIDIOUT(dev, d2);
1292 }
1293 break;
1294 }
1295 }
1296 break;
1297 default:
1298 WARN(midi, "Technology not supported (yet) %d !\n",
1299 midiOutDevices[wDevID]->wTechnology);
1300 return MMSYSERR_NOTENABLED;
1301 }
1302
1303 SEQ_DUMPBUF();
1304 #else
1305 if (MidiOutDev[wDevID].unixdev == 0) {
1306 WARN(midi,"can't play !\n");
1307 return MIDIERR_NODEVICE;
1308 }
1309 {
1310 WORD event = LOWORD(dwParam);
1311 if (write (MidiOutDev[wDevID].unixdev,
1312 &event, sizeof(event)) != sizeof(WORD)) {
1313 WARN(midi, "error writting unixdev !\n");
1314 }
1315 }
1316 #endif /* HAVE_OSS */
1317 return MMSYSERR_NOERROR;
1318 }
1319
1320 /**************************************************************************
1321 * modLongData [internal]
1322 */
1323 static DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1324 {
1325 int count;
1326
1327 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1328
1329 #ifdef HAVE_OSS
1330 if (midiSeqFD == -1) {
1331 WARN(midi,"can't play !\n");
1332 return MIDIERR_NODEVICE;
1333 }
1334 #else /* HAVE_OSS */
1335 if (MidiOutDev[wDevID].unixdev == 0) {
1336 WARN(midi,"can't play !\n");
1337 return MIDIERR_NODEVICE;
1338 }
1339 #endif /* HAVE_OSS */
1340
1341 if (lpMidiHdr->lpData == NULL)
1342 return MIDIERR_UNPREPARED;
1343 if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
1344 return MIDIERR_UNPREPARED;
1345 if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
1346 return MIDIERR_STILLPLAYING;
1347 lpMidiHdr->dwFlags &= ~MHDR_DONE;
1348 lpMidiHdr->dwFlags |= MHDR_INQUEUE;
1349
1350 TRACE(midi, "dwBytesRecorded %lu !\n", lpMidiHdr->dwBytesRecorded);
1351 TRACE(midi, " %02X %02X %02X %02X\n",
1352 ((LPBYTE)(lpMidiHdr->reserved))[0],
1353 ((LPBYTE)(lpMidiHdr->reserved))[1],
1354 ((LPBYTE)(lpMidiHdr->reserved))[2],
1355 ((LPBYTE)(lpMidiHdr->reserved))[3]);
1356 #ifdef HAVE_OSS
1357 switch (midiOutDevices[wDevID]->wTechnology) {
1358 case MOD_FMSYNTH:
1359 /* FIXME: I don't think there is much to do here */
1360 break;
1361 case MOD_MIDIPORT:
1362 if (((LPBYTE)lpMidiHdr->reserved)[0] != 0xF0) {
1363 /* Send end of System Exclusive */
1364 SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS, 0xF0);
1365 TRACE(midi, "Adding missing 0xF0 marker at the begining of "
1366 "system exclusive byte stream\n");
1367 }
1368 for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) {
1369 SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS,
1370 ((LPBYTE)lpMidiHdr->reserved)[count]);
1371 }
1372 if (((LPBYTE)lpMidiHdr->reserved)[count - 1] != 0xF7) {
1373 /* Send end of System Exclusive */
1374 SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS, 0xF7);
1375 TRACE(midi, "Adding missing 0xF7 marker at the end of "
1376 "system exclusive byte stream\n");
1377 }
1378 SEQ_DUMPBUF();
1379 break;
1380 default:
1381 WARN(midi, "Technology not supported (yet) %d !\n",
1382 midiOutDevices[wDevID]->wTechnology);
1383 return MMSYSERR_NOTENABLED;
1384 }
1385 #else /* HAVE_OSS */
1386 {
1387 LPWORD ptr = (LPWORD)lpMidiHdr->reserved;
1388 int en;
1389
1390 for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) {
1391 if (write(MidiOutDev[wDevID].unixdev,
1392 ptr, sizeof(WORD)) != sizeof(WORD))
1393 break;
1394 ptr++;
1395 }
1396
1397 en = errno;
1398 TRACE(midi, "after write count = %d\n",count);
1399 if (count != lpMidiHdr->dwBytesRecorded) {
1400 WARN(midi, "error writting unixdev #%d ! (%d != %ld)\n",
1401 MidiOutDev[wDevID].unixdev, count,
1402 lpMidiHdr->dwBytesRecorded);
1403 TRACE(midi, "\terrno = %d error = %s\n",en,strerror(en));
1404 return MMSYSERR_NOTENABLED;
1405 }
1406 }
1407 #endif /* HAVE_OSS */
1408
1409 lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1410 lpMidiHdr->dwFlags |= MHDR_DONE;
1411 if (MIDI_NotifyClient(wDevID, MOM_DONE, (DWORD)lpMidiHdr, 0L) != MMSYSERR_NOERROR) {
1412 WARN(midi,"can't notify client !\n");
1413 return MMSYSERR_INVALPARAM;
1414 }
1415 return MMSYSERR_NOERROR;
1416 }
1417
1418 /**************************************************************************
1419 * modPrepare [internal]
1420 */
1421 static DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1422 {
1423 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1424
1425 #ifdef HAVE_OSS
1426 if (midiSeqFD == -1) {
1427 WARN(midi,"can't prepare !\n");
1428 return MMSYSERR_NOTENABLED;
1429 }
1430 #else /* HAVE_OSS */
1431 if (MidiOutDev[wDevID].unixdev == 0) {
1432 WARN(midi,"can't prepare !\n");
1433 return MMSYSERR_NOTENABLED;
1434 }
1435 #endif /* HAVE_OSS */
1436 if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0 ||
1437 lpMidiHdr->lpData == 0 || lpMidiHdr->dwFlags != 0 ||
1438 lpMidiHdr->dwBufferLength >= 0x10000ul)
1439 return MMSYSERR_INVALPARAM;
1440
1441 lpMidiHdr->lpNext = 0;
1442 lpMidiHdr->dwFlags |= MHDR_PREPARED;
1443 lpMidiHdr->dwFlags &= ~MHDR_DONE;
1444 return MMSYSERR_NOERROR;
1445 }
1446
1447 /**************************************************************************
1448 * modUnprepare [internal]
1449 */
1450 static DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize)
1451 {
1452 TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize);
1453
1454 #ifdef HAVE_OSS
1455 if (midiSeqFD == -1) {
1456 WARN(midi,"can't unprepare !\n");
1457 return MMSYSERR_NOTENABLED;
1458 }
1459 #else /* HAVE_OSS */
1460 if (MidiOutDev[wDevID].unixdev == 0) {
1461 WARN(midi,"can't unprepare !\n");
1462 return MMSYSERR_NOTENABLED;
1463 }
1464 #endif /* HAVE_OSS */
1465 if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0)
1466 return MMSYSERR_INVALPARAM;
1467 if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
1468 return MIDIERR_STILLPLAYING;
1469 lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
1470 return MMSYSERR_NOERROR;
1471 }
1472
1473 /**************************************************************************
1474 * modReset [internal]
1475 */
1476 static DWORD modReset(WORD wDevID)
1477 {
1478 TRACE(midi, "(%04X);\n", wDevID);
1479 /* FIXME: this function should :
1480 * turn off every note, remove sustain on all channels
1481 * remove any pending buffers
1482 */
1483 return MMSYSERR_NOTENABLED;
1484 }
1485
1486 /*======================================================================*
1487 * MIDI entry points *
1488 *======================================================================*/
1489
1490 /**************************************************************************
1491 * modMessage [sample driver]
1492 */
1493 DWORD WINAPI modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
1494 DWORD dwParam1, DWORD dwParam2)
1495 {
1496 TRACE(midi, "(%04X, %04X, %08lX, %08lX, %08lX);\n",
1497 wDevID, wMsg, dwUser, dwParam1, dwParam2);
1498
1499 switch (wMsg) {
1500 case MODM_OPEN:
1501 return modOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2);
1502 case MODM_CLOSE:
1503 return modClose(wDevID);
1504 case MODM_DATA:
1505 return modData(wDevID, dwParam1);
1506 case MODM_LONGDATA:
1507 return modLongData(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1508 case MODM_PREPARE:
1509 return modPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1510 case MODM_UNPREPARE:
1511 return modUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2);
1512 case MODM_GETDEVCAPS:
1513 return modGetDevCaps(wDevID,(LPMIDIOUTCAPS16)dwParam1,dwParam2);
1514 case MODM_GETNUMDEVS:
1515 return MODM_NUMDEVS;
1516 case MODM_GETVOLUME:
1517 return 0;
1518 case MODM_SETVOLUME:
1519 return 0;
1520 case MODM_RESET:
1521 return modReset(wDevID);
1522 default:
1523 TRACE(midi, "Unsupported message\n");
1524 }
1525 return MMSYSERR_NOTSUPPORTED;
1526 }
1527
1528 /**************************************************************************
1529 * MIDI_DriverProc32 [sample driver]
1530 */
1531 LONG MIDI_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
1532 DWORD dwParam1, DWORD dwParam2)
1533 {
1534 switch (wMsg) {
1535 case DRV_LOAD: return 1;
1536 case DRV_FREE: return 1;
1537 case DRV_OPEN: return 1;
1538 case DRV_CLOSE: return 1;
1539 case DRV_ENABLE: return 1;
1540 case DRV_DISABLE: return 1;
1541 case DRV_QUERYCONFIGURE: return 1;
1542 case DRV_CONFIGURE: MessageBox16(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK); return 1;
1543 case DRV_INSTALL: return DRVCNF_RESTART;
1544 case DRV_REMOVE: return DRVCNF_RESTART;
1545 default:
1546 TRACE(midi, "Sending msg=%lu to default driver proc\n", wMsg);
1547 return DefDriverProc32(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1548 }
1549 }
1550
1551 /**************************************************************************
1552 * MIDI_DriverProc16 [sample driver]
1553 */
1554 LONG MIDI_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
1555 DWORD dwParam1, DWORD dwParam2)
1556 {
1557 switch (wMsg) {
1558 case DRV_LOAD: return 1;
1559 case DRV_FREE: return 1;
1560 case DRV_OPEN: return 1;
1561 case DRV_CLOSE: return 1;
1562 case DRV_ENABLE: return 1;
1563 case DRV_DISABLE: return 1;
1564 case DRV_QUERYCONFIGURE: return 1;
1565 case DRV_CONFIGURE: MessageBox16(0, "Sample Midi Linux Driver !", "MMLinux Driver", MB_OK); return 1;
1566 case DRV_INSTALL: return DRVCNF_RESTART;
1567 case DRV_REMOVE: return DRVCNF_RESTART;
1568 default:
1569 TRACE(midi, "Sending msg=%u to default driver proc\n", wMsg);
1570 return DefDriverProc32(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1571 }
1572 }
1573
1574 /*-----------------------------------------------------------------------*/
Maarten's multimedia branch