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