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