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