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