?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 970804
[wine/multimedia.git] / multimedia / mmsystem.c
blobb4f6cf962ad2e26a6f8a3f0679c58281e1f1680a
1 /*
2 * MMSYTEM functions
3 *
4 * Copyright 1993 Martin Ayotte
5 */
6 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
7 * and long term pointers to 16 bit space in here
8 */
9
10 #include <unistd.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <fcntl.h>
15 #include <errno.h>
16 #include <sys/ioctl.h>
17 #include "windows.h"
18 #include "win.h"
19 #include "heap.h"
20 #include "ldt.h"
21 #include "user.h"
22 #include "driver.h"
23 #include "file.h"
24 #include "mmsystem.h"
25 #include "stddebug.h"
26 #include "debug.h"
27 #include "xmalloc.h"
28 #include "callback.h"
29
30 static int InstalledCount;
31 static int InstalledListLen;
32 static LPSTR lpInstallNames = NULL;
33
34 MCI_OPEN_DRIVER_PARMS mciDrv[MAXMCIDRIVERS];
35 /* struct below is to remember alias/devicenames for mcistring.c
36 * FIXME: should use some internal struct ...
37 */
38 MCI_OPEN_PARMS mciOpenDrv[MAXMCIDRIVERS];
39
40 UINT16 midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
41 UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
42 LONG DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
43 DWORD dwParam1, DWORD dwParam2);
44
45 LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
46 DWORD dwParam1, DWORD dwParam2);
47 LONG MIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
48 DWORD dwParam1, DWORD dwParam2);
49 LONG CDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
50 DWORD dwParam1, DWORD dwParam2);
51 LONG ANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
52 DWORD dwParam1, DWORD dwParam2);
53
54
55 #define GetDrv(wDevID) (&mciDrv[MMSYSTEM_DevIDToIndex(wDevID)])
56 #define GetOpenDrv(wDevID) (&mciOpenDrv[MMSYSTEM_DevIDToIndex(wDevID)])
57
58 /* The wDevID's returned by wine were originally in the range
59 * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices.
60 * Unfortunately, ms-windows uses wDevID of zero to indicate
61 * errors. Now, multimedia drivers must pass the wDevID through
62 * MMSYSTEM_DevIDToIndex to get an index in that range. An
63 * aribtrary value, MMSYSTEM_MAGIC is added to the wDevID seen
64 * by the windows programs.
65 */
66
67 #define MMSYSTEM_MAGIC 0x0F00
68
69 /**************************************************************************
70 * MMSYSTEM_DevIDToIndex [internal]
71 */
72 int MMSYSTEM_DevIDToIndex(UINT16 wDevID) {
73 return wDevID - MMSYSTEM_MAGIC;
74 }
75
76 /**************************************************************************
77 * MMSYSTEM_FirstDevId [internal]
78 */
79 UINT16 MMSYSTEM_FirstDevID(void)
80 {
81 return MMSYSTEM_MAGIC;
82 }
83
84 /**************************************************************************
85 * MMSYSTEM_NextDevId [internal]
86 */
87 UINT16 MMSYSTEM_NextDevID(UINT16 wDevID) {
88 return wDevID + 1;
89 }
90
91 /**************************************************************************
92 * MMSYSTEM_DevIdValid [internal]
93 */
94 BOOL32 MMSYSTEM_DevIDValid(UINT16 wDevID) {
95 return wDevID >= 0x0F00 && wDevID < (0x0F00 + MAXMCIDRIVERS);
96 }
97
98 /**************************************************************************
99 * MMSYSTEM_WEP [MMSYSTEM.1]
100 */
101 int MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
102 WORD cbHeapSize, LPSTR lpCmdLine)
103 {
104 fprintf(stderr, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance);
105 return(TRUE);
106 }
107
108 /**************************************************************************
109 * sndPlaySound [MMSYSTEM.2]
110 */
111 BOOL16 sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags)
112 {
113 BOOL16 bRet = FALSE;
114 HMMIO16 hmmio;
115 MMCKINFO ckMainRIFF;
116 char str[128];
117 LPSTR ptr;
118
119 dprintf_mmsys(stddeb, "sndPlaySound // SoundName='%s' uFlags=%04X !\n",
120 lpszSoundName, uFlags);
121 if (lpszSoundName == NULL) {
122 dprintf_mmsys(stddeb, "sndPlaySound // Stop !\n");
123 return FALSE;
124 }
125 hmmio = mmioOpen((LPSTR)lpszSoundName, NULL,
126 MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
127
128 if (uFlags & SND_MEMORY) {
129 dprintf_mmsys(stddeb, "sndPlaySound // SND_MEMORY flag not implemented!\n");
130 return FALSE;
131 }
132
133 if (hmmio == 0)
134 {
135 dprintf_mmsys(stddeb, "sndPlaySound // searching in SystemSound List !\n");
136 GetProfileString32A("Sounds", (LPSTR)lpszSoundName, "", str, sizeof(str));
137 if (strlen(str) == 0) return FALSE;
138 if ( (ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0';
139 hmmio = mmioOpen(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
140 if (hmmio == 0)
141 {
142 dprintf_mmsys(stddeb, "sndPlaySound // can't find SystemSound='%s' !\n", str);
143 return FALSE;
144 }
145 }
146
147 if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0)
148 {
149 dprintf_mmsys(stddeb, "sndPlaySound // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
150 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
151
152 if ((ckMainRIFF.ckid == FOURCC_RIFF) &&
153 (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E')))
154 {
155 MMCKINFO mmckInfo;
156
157 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
158
159 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0)
160 {
161 PCMWAVEFORMAT pcmWaveFormat;
162
163 dprintf_mmsys(stddeb, "sndPlaySound // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
164 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
165
166 if (mmioRead(hmmio, (HPSTR) &pcmWaveFormat,
167 (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT))
168 {
169
170 dprintf_mmsys(stddeb, "sndPlaySound // wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag);
171 dprintf_mmsys(stddeb, "sndPlaySound // nChannels=%d \n", pcmWaveFormat.wf.nChannels);
172 dprintf_mmsys(stddeb, "sndPlaySound // nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec);
173 dprintf_mmsys(stddeb, "sndPlaySound // nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec);
174 dprintf_mmsys(stddeb, "sndPlaySound // nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign);
175 dprintf_mmsys(stddeb, "sndPlaySound // wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample);
176
177 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
178 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0)
179 {
180 LPWAVEFORMAT lpFormat = (LPWAVEFORMAT) SEGPTR_ALLOC(sizeof(PCMWAVEFORMAT));
181 LPWAVEOPENDESC lpWaveDesc = (LPWAVEOPENDESC) SEGPTR_ALLOC(sizeof(WAVEOPENDESC));
182 DWORD dwRet;
183
184 dprintf_mmsys(stddeb, "sndPlaySound // Chunk Found \
185 ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
186
187 pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec *
188 pcmWaveFormat.wf.nBlockAlign;
189 memcpy(lpFormat, &pcmWaveFormat, sizeof(PCMWAVEFORMAT));
190
191 lpWaveDesc->hWave = 0;
192 lpWaveDesc->lpFormat = (LPWAVEFORMAT) SEGPTR_GET(lpFormat);
193
194 dwRet = wodMessage( 0,
195 WODM_OPEN, 0, (DWORD)SEGPTR_GET(lpWaveDesc), CALLBACK_NULL);
196 SEGPTR_FREE(lpFormat);
197 SEGPTR_FREE(lpWaveDesc);
198
199 if (dwRet == MMSYSERR_NOERROR)
200 {
201 LPWAVEHDR lpWaveHdr = (LPWAVEHDR) SEGPTR_ALLOC(sizeof(WAVEHDR));
202 SEGPTR spWaveHdr = SEGPTR_GET(lpWaveHdr);
203 HGLOBAL16 hData;
204 INT32 count, bufsize;
205
206 bufsize = 64000;
207 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
208 lpWaveHdr->lpData = (LPSTR) WIN16_GlobalLock16(hData);
209 lpWaveHdr->dwBufferLength = bufsize;
210 lpWaveHdr->dwUser = 0L;
211 lpWaveHdr->dwFlags = 0L;
212 lpWaveHdr->dwLoops = 0L;
213
214 dwRet = wodMessage( 0,
215 WODM_PREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR));
216 if (dwRet == MMSYSERR_NOERROR)
217 {
218 while( TRUE )
219 {
220 count = mmioRead(hmmio, PTR_SEG_TO_LIN(lpWaveHdr->lpData), bufsize);
221 if (count < 1) break;
222 lpWaveHdr->dwBufferLength = count;
223 /* lpWaveHdr->dwBytesRecorded = count; */
224 wodMessage( 0, WODM_WRITE,
225 0, (DWORD)spWaveHdr, sizeof(WAVEHDR));
226 }
227 wodMessage( 0,
228 WODM_UNPREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR));
229 wodMessage( 0,
230 WODM_CLOSE, 0, 0L, 0L);
231
232 bRet = TRUE;
233 }
234 else dprintf_mmsys(stddeb, "sndPlaySound // can't prepare WaveOut device !\n");
235
236 GlobalUnlock16(hData);
237 GlobalFree16(hData);
238
239 SEGPTR_FREE(lpWaveHdr);
240 }
241 }
242 }
243 }
244 }
245 }
246
247 if (hmmio != 0) mmioClose(hmmio, 0);
248 return bRet;
249 }
250
251 /**************************************************************************
252 * mmsystemGetVersion [MMSYSTEM.5]
253 */
254 WORD mmsystemGetVersion()
255 {
256 dprintf_mmsys(stddeb, "mmsystemGetVersion // 0.4.0 ...?... :-) !\n");
257 return 0x0040;
258 }
259
260 /**************************************************************************
261 * DriverProc [MMSYSTEM.6]
262 */
263 LRESULT DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
264 DWORD dwParam1, DWORD dwParam2)
265 {
266 return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
267 }
268
269 /**************************************************************************
270 * DriverCallback [MMSYSTEM.31]
271 */
272 BOOL16 DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
273 WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
274 {
275 LPWAVEOPENDESC lpDesc;
276
277 dprintf_mmsys(stddeb, "DriverCallback(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
278 dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
279 switch(uFlags & DCB_TYPEMASK) {
280 case DCB_NULL:
281 dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_NULL !\n");
282 break;
283 case DCB_WINDOW:
284 dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_WINDOW = %04lX handle = %04X!\n",dwCallBack,hDev);
285 if (!IsWindow32(dwCallBack)) return FALSE;
286 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hDev);
287 if (lpDesc == NULL) return FALSE;
288
289 PostMessage16((HWND16)dwCallBack, wMsg, hDev, dwParam1);
290 break;
291 case DCB_TASK:
292 dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_TASK !\n");
293 return FALSE;
294 case DCB_FUNCTION:
295 dprintf_mmsys(stddeb, "DriverCallback() // CALLBACK_FUNCTION !\n");
296 CallDriverCallback( (FARPROC16)dwCallBack, hDev, wMsg,
297 dwUser, dwParam1, dwParam2 );
298 break;
299 }
300 return TRUE;
301 }
302
303 /**************************************************************************
304 * auxGetNumDevs [MMSYSTEM.350]
305 */
306 UINT16 auxGetNumDevs()
307 {
308 UINT16 count = 0;
309 dprintf_mmsys(stddeb, "auxGetNumDevs !\n");
310 count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
311 dprintf_mmsys(stddeb, "auxGetNumDevs return %u \n", count);
312 return count;
313 }
314
315 /**************************************************************************
316 * auxGetDevCaps [MMSYSTEM.351]
317 */
318 UINT16 auxGetDevCaps(UINT16 uDeviceID, AUXCAPS * lpCaps, UINT16 uSize)
319 {
320 dprintf_mmsys(stddeb, "auxGetDevCaps(%04X, %p, %d) !\n",
321 uDeviceID, lpCaps, uSize);
322 return auxMessage(uDeviceID, AUXDM_GETDEVCAPS,
323 0L, (DWORD)lpCaps, (DWORD)uSize);
324 }
325
326 /**************************************************************************
327 * auxGetVolume [MMSYSTEM.352]
328 */
329 UINT16 auxGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume)
330 {
331 dprintf_mmsys(stddeb, "auxGetVolume(%04X, %p) !\n", uDeviceID, lpdwVolume);
332 return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
333 }
334
335 /**************************************************************************
336 * auxSetVolume [MMSYSTEM.353]
337 */
338 UINT16 auxSetVolume(UINT16 uDeviceID, DWORD dwVolume)
339 {
340 dprintf_mmsys(stddeb, "auxSetVolume(%04X, %08lX) !\n", uDeviceID, dwVolume);
341 return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L);
342 }
343
344 /**************************************************************************
345 * auxOutMessage [MMSYSTEM.354]
346 */
347 DWORD auxOutMessage(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
348 {
349 dprintf_mmsys(stddeb, "auxOutMessage(%04X, %04X, %08lX, %08lX)\n",
350 uDeviceID, uMessage, dw1, dw2);
351 return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2);
352 }
353
354 /**************************************************************************
355 * mciGetErrorString [MMSYSTEM.706]
356 */
357 BOOL16 mciGetErrorString (DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
358 {
359 LPSTR msgptr;
360 dprintf_mmsys(stddeb, "mciGetErrorString(%08lX, %p, %d);\n", wError, lpstrBuffer, uLength);
361 if ((lpstrBuffer == NULL) || (uLength < 1)) return(FALSE);
362 lpstrBuffer[0] = '\0';
363 switch(wError) {
364 case MCIERR_INVALID_DEVICE_ID:
365 msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device.";
366 break;
367 case MCIERR_UNRECOGNIZED_KEYWORD:
368 msgptr = "The driver cannot recognize the specified command parameter.";
369 break;
370 case MCIERR_UNRECOGNIZED_COMMAND:
371 msgptr = "The driver cannot recognize the specified command.";
372 break;
373 case MCIERR_HARDWARE:
374 msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer.";
375 break;
376 case MCIERR_INVALID_DEVICE_NAME:
377 msgptr = "The specified device is not open or is not recognized by MCI.";
378 break;
379 case MCIERR_OUT_OF_MEMORY:
380 msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again.";
381 break;
382 case MCIERR_DEVICE_OPEN:
383 msgptr = "The device name is already being used as an alias by this application. Use a unique alias.";
384 break;
385 case MCIERR_CANNOT_LOAD_DRIVER:
386 msgptr = "There is an undetectable problem in loading the specified device driver.";
387 break;
388 case MCIERR_MISSING_COMMAND_STRING:
389 msgptr = "No command was specified.";
390 break;
391 case MCIERR_PARAM_OVERFLOW:
392 msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer.";
393 break;
394 case MCIERR_MISSING_STRING_ARGUMENT:
395 msgptr = "The specified command requires a character-string parameter. Please provide one.";
396 break;
397 case MCIERR_BAD_INTEGER:
398 msgptr = "The specified integer is invalid for this command.";
399 break;
400 case MCIERR_PARSER_INTERNAL:
401 msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver.";
402 break;
403 case MCIERR_DRIVER_INTERNAL:
404 msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver.";
405 break;
406 case MCIERR_MISSING_PARAMETER:
407 msgptr = "The specified command requires a parameter. Please supply one.";
408 break;
409 case MCIERR_UNSUPPORTED_FUNCTION:
410 msgptr = "The MCI device you are using does not support the specified command.";
411 break;
412 case MCIERR_FILE_NOT_FOUND:
413 msgptr = "Cannot find the specified file. Make sure the path and filename are correct.";
414 break;
415 case MCIERR_DEVICE_NOT_READY:
416 msgptr = "The device driver is not ready.";
417 break;
418 case MCIERR_INTERNAL:
419 msgptr = "A problem occurred in initializing MCI. Try restarting Windows.";
420 break;
421 case MCIERR_DRIVER:
422 msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error.";
423 break;
424 case MCIERR_CANNOT_USE_ALL:
425 msgptr = "Cannot use 'all' as the device name with the specified command.";
426 break;
427 case MCIERR_MULTIPLE:
428 msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error";
429 break;
430 case MCIERR_EXTENSION_NOT_FOUND:
431 msgptr = "Cannot determine the device type from the given filename extension.";
432 break;
433 case MCIERR_OUTOFRANGE:
434 msgptr = "The specified parameter is out of range for the specified command.";
435 break;
436 case MCIERR_FLAGS_NOT_COMPATIBLE:
437 msgptr = "The specified parameters cannot be used together.";
438 break;
439 case MCIERR_FILE_NOT_SAVED:
440 msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network.";
441 break;
442 case MCIERR_DEVICE_TYPE_REQUIRED:
443 msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly.";
444 break;
445 case MCIERR_DEVICE_LOCKED:
446 msgptr = "The specified device is now being closed. Wait a few seconds, and then try again.";
447 break;
448 case MCIERR_DUPLICATE_ALIAS:
449 msgptr = "The specified alias is already being used in this application. Use a unique alias.";
450 break;
451 case MCIERR_BAD_CONSTANT:
452 msgptr = "The specified parameter is invalid for this command.";
453 break;
454 case MCIERR_MUST_USE_SHAREABLE:
455 msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command.";
456 break;
457 case MCIERR_MISSING_DEVICE_NAME:
458 msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one.";
459 break;
460 case MCIERR_BAD_TIME_FORMAT:
461 msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats.";
462 break;
463 case MCIERR_NO_CLOSING_QUOTE:
464 msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one.";
465 break;
466 case MCIERR_DUPLICATE_FLAGS:
467 msgptr = "A parameter or value was specified twice. Only specify it once.";
468 break;
469 case MCIERR_INVALID_FILE:
470 msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format.";
471 break;
472 case MCIERR_NULL_PARAMETER_BLOCK:
473 msgptr = "A null parameter block was passed to MCI.";
474 break;
475 case MCIERR_UNNAMED_RESOURCE:
476 msgptr = "Cannot save an unnamed file. Supply a filename.";
477 break;
478 case MCIERR_NEW_REQUIRES_ALIAS:
479 msgptr = "You must specify an alias when using the 'new' parameter.";
480 break;
481 case MCIERR_NOTIFY_ON_AUTO_OPEN:
482 msgptr = "Cannot use the 'notify' flag with auto-opened devices.";
483 break;
484 case MCIERR_NO_ELEMENT_ALLOWED:
485 msgptr = "Cannot use a filename with the specified device.";
486 break;
487 case MCIERR_NONAPPLICABLE_FUNCTION:
488 msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again.";
489 break;
490 case MCIERR_ILLEGAL_FOR_AUTO_OPEN:
491 msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again.";
492 break;
493 case MCIERR_FILENAME_REQUIRED:
494 msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension.";
495 break;
496 case MCIERR_EXTRA_CHARACTERS:
497 msgptr = "Cannot specify extra characters after a string enclosed in quotation marks.";
498 break;
499 case MCIERR_DEVICE_NOT_INSTALLED:
500 msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device.";
501 break;
502 case MCIERR_GET_CD:
503 msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer.";
504 break;
505 case MCIERR_SET_CD:
506 msgptr = "Cannot access the specified file or MCI device because the application cannot change directories.";
507 break;
508 case MCIERR_SET_DRIVE:
509 msgptr = "Cannot access specified file or MCI device because the application cannot change drives.";
510 break;
511 case MCIERR_DEVICE_LENGTH:
512 msgptr = "Specify a device or driver name that is less than 79 characters.";
513 break;
514 case MCIERR_DEVICE_ORD_LENGTH:
515 msgptr = "Specify a device or driver name that is less than 69 characters.";
516 break;
517 case MCIERR_NO_INTEGER:
518 msgptr = "The specified command requires an integer parameter. Please provide one.";
519 break;
520 case MCIERR_WAVE_OUTPUTSINUSE:
521 msgptr = "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again.";
522 break;
523 case MCIERR_WAVE_SETOUTPUTINUSE:
524 msgptr = "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again.";
525 break;
526 case MCIERR_WAVE_INPUTSINUSE:
527 msgptr = "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again.";
528 break;
529 case MCIERR_WAVE_SETINPUTINUSE:
530 msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again.";
531 break;
532 case MCIERR_WAVE_OUTPUTUNSPECIFIED:
533 msgptr = "Any compatible waveform playback device may be used.";
534 break;
535 case MCIERR_WAVE_INPUTUNSPECIFIED:
536 msgptr = "Any compatible waveform recording device may be used.";
537 break;
538 case MCIERR_WAVE_OUTPUTSUNSUITABLE:
539 msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device.";
540 break;
541 case MCIERR_WAVE_SETOUTPUTUNSUITABLE:
542 msgptr = "The device you are trying to play to cannot recognize the current file format.";
543 break;
544 case MCIERR_WAVE_INPUTSUNSUITABLE:
545 msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device.";
546 break;
547 case MCIERR_WAVE_SETINPUTUNSUITABLE:
548 msgptr = "The device you are trying to record from cannot recognize the current file format.";
549 break;
550 case MCIERR_NO_WINDOW:
551 msgptr = "There is no display window.";
552 break;
553 case MCIERR_CREATEWINDOW:
554 msgptr = "Could not create or use window.";
555 break;
556 case MCIERR_FILE_READ:
557 msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection.";
558 break;
559 case MCIERR_FILE_WRITE:
560 msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network.";
561 break;
562 case MCIERR_SEQ_DIV_INCOMPATIBLE:
563 msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together.";
564 break;
565 case MCIERR_SEQ_NOMIDIPRESENT:
566 msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver.";
567 break;
568 case MCIERR_SEQ_PORT_INUSE:
569 msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again.";
570 break;
571 case MCIERR_SEQ_PORT_MAPNODEVICE:
572 msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup.";
573 break;
574 case MCIERR_SEQ_PORT_MISCERROR:
575 msgptr = "An error occurred with the specified port.";
576 break;
577 case MCIERR_SEQ_PORT_NONEXISTENT:
578 msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device.";
579 break;
580 case MCIERR_SEQ_PORTUNSPECIFIED:
581 msgptr = "The system doesnot have a current MIDI port specified.";
582 break;
583 case MCIERR_SEQ_TIMER:
584 msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again.";
585 break;
586
587 /*
588 msg# 513 : vcr
589 msg# 514 : videodisc
590 msg# 515 : overlay
591 msg# 516 : cdaudio
592 msg# 517 : dat
593 msg# 518 : scanner
594 msg# 519 : animation
595 msg# 520 : digitalvideo
596 msg# 521 : other
597 msg# 522 : waveaudio
598 msg# 523 : sequencer
599 msg# 524 : not ready
600 msg# 525 : stopped
601 msg# 526 : playing
602 msg# 527 : recording
603 msg# 528 : seeking
604 msg# 529 : paused
605 msg# 530 : open
606 msg# 531 : false
607 msg# 532 : true
608 msg# 533 : milliseconds
609 msg# 534 : hms
610 msg# 535 : msf
611 msg# 536 : frames
612 msg# 537 : smpte 24
613 msg# 538 : smpte 25
614 msg# 539 : smpte 30
615 msg# 540 : smpte 30 drop
616 msg# 541 : bytes
617 msg# 542 : samples
618 msg# 543 : tmsf
619 */
620 default:
621 msgptr = "Unknown MCI Error !\n";
622 break;
623 }
624 lstrcpyn32A(lpstrBuffer, msgptr, uLength);
625 dprintf_mmsys(stddeb, "mciGetErrorString // msg = %s;\n", msgptr);
626 return TRUE;
627 }
628
629
630 /**************************************************************************
631 * mciDriverNotify [MMSYSTEM.711]
632 */
633 BOOL16 mciDriverNotify(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
634 {
635 dprintf_mmsys(stddeb, "mciDriverNotify(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
636 if (!IsWindow32(hWndCallBack)) return FALSE;
637 dprintf_mmsys(stddeb, "mciDriverNotify // before PostMessage\n");
638 PostMessage16( hWndCallBack, MM_MCINOTIFY, wStatus,
639 MAKELONG(wDevID, 0));
640 return TRUE;
641 }
642
643 /**************************************************************************
644 * mciOpen [internal]
645 */
646
647 DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lp16Parms)
648 {
649 char str[128];
650 LPMCI_OPEN_PARMS lpParms;
651 UINT16 uDevTyp = 0;
652 UINT16 wDevID = MMSYSTEM_FirstDevID();
653 DWORD dwret;
654
655 lpParms = PTR_SEG_TO_LIN(lp16Parms);
656 dprintf_mmsys(stddeb, "mciOpen(%08lX, %p (%p))\n", dwParam, lp16Parms, lpParms);
657 if (lp16Parms == NULL) return MCIERR_INTERNAL;
658
659 while(GetDrv(wDevID)->wType != 0) {
660 wDevID = MMSYSTEM_NextDevID(wDevID);
661 if (!MMSYSTEM_DevIDValid(wDevID)) {
662 dprintf_mmsys(stddeb, "MCI_OPEN // MAXMCIDRIVERS reached !\n");
663 return MCIERR_INTERNAL;
664 }
665 }
666 dprintf_mmsys(stddeb, "mciOpen // wDevID=%04X \n", wDevID);
667 memcpy(GetOpenDrv(wDevID),lpParms,sizeof(*lpParms));
668
669 if (dwParam & MCI_OPEN_ELEMENT) {
670 char *s,*t;
671
672 dprintf_mmsys(stddeb,"mciOpen // lpstrElementName='%s'\n",
673 (char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName)
674 );
675 s=(char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
676 t=strrchr(s,'.');
677 if (t) {
678 GetProfileString32A("mci extensions",t+1,"*",str,sizeof(str));
679 CharUpper32A(str);
680 dprintf_mmsys(stddeb, "mciOpen // str = %s \n", str);
681 if (strcmp(str, "CDAUDIO") == 0) {
682 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
683 } else
684 if (strcmp(str, "WAVEAUDIO") == 0) {
685 uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
686 } else
687 if (strcmp(str, "SEQUENCER") == 0) {
688 uDevTyp = MCI_DEVTYPE_SEQUENCER;
689 } else
690 if (strcmp(str, "ANIMATION1") == 0) {
691 uDevTyp = MCI_DEVTYPE_ANIMATION;
692 } else
693 if (strcmp(str, "AVIVIDEO") == 0) {
694 uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
695 } else
696 if (strcmp(str,"*") == 0) {
697 dprintf_mmsys(stddeb,"No [mci extensions] entry for %s found.\n",t);
698 return MCIERR_EXTENSION_NOT_FOUND;
699 } else {
700 dprintf_mmsys(stddeb,"[mci extensions] entry %s for %s not supported.\n",str,t);
701 }
702 } else
703 return MCIERR_EXTENSION_NOT_FOUND;
704 }
705
706 if (dwParam & MCI_OPEN_ALIAS) {
707 dprintf_mmsys(stddeb, "MCI_OPEN // Alias='%s' !\n",
708 (char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias));
709 GetOpenDrv(wDevID)->lpstrAlias = SEGPTR_GET(
710 SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias)));
711 /* mplayer does allocate alias to CDAUDIO */
712 }
713 if (dwParam & MCI_OPEN_TYPE) {
714 if (dwParam & MCI_OPEN_TYPE_ID) {
715 dprintf_mmsys(stddeb, "MCI_OPEN // Dev=%08lx !\n", lpParms->lpstrDeviceType);
716 uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType);
717 GetOpenDrv(wDevID)->lpstrDeviceType=lpParms->lpstrDeviceType;
718 } else {
719 if (lpParms->lpstrDeviceType == (SEGPTR)NULL) return MCIERR_INTERNAL;
720 dprintf_mmsys(stddeb, "MCI_OPEN // Dev='%s' !\n",
721 (char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType));
722 GetOpenDrv(wDevID)->lpstrDeviceType = SEGPTR_GET(
723 SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType)));
724 strcpy(str, PTR_SEG_TO_LIN(lpParms->lpstrDeviceType));
725 CharUpper32A(str);
726 if (strcmp(str, "CDAUDIO") == 0) {
727 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
728 } else
729 if (strcmp(str, "WAVEAUDIO") == 0) {
730 uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
731 } else
732 if (strcmp(str, "SEQUENCER") == 0) {
733 uDevTyp = MCI_DEVTYPE_SEQUENCER;
734 } else
735 if (strcmp(str, "ANIMATION1") == 0) {
736 uDevTyp = MCI_DEVTYPE_ANIMATION;
737 } else
738 if (strcmp(str, "AVIVIDEO") == 0) {
739 uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
740 }
741 }
742 }
743 GetDrv(wDevID)->wType = uDevTyp;
744 GetDrv(wDevID)->wDeviceID = 0; /* FIXME? for multiple devices */
745 lpParms->wDeviceID = wDevID;
746 dprintf_mmsys(stddeb, "MCI_OPEN // mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
747 wDevID, uDevTyp, lpParms->wDeviceID);
748 switch(uDevTyp)
749 {
750 case MCI_DEVTYPE_CD_AUDIO:
751 dwret = CDAUDIO_DriverProc( 0, 0, MCI_OPEN_DRIVER,
752 dwParam, (DWORD)lp16Parms);
753 break;
754 case MCI_DEVTYPE_WAVEFORM_AUDIO:
755 dwret = WAVE_DriverProc( 0, 0, MCI_OPEN_DRIVER,
756 dwParam, (DWORD)lp16Parms);
757 break;
758 case MCI_DEVTYPE_SEQUENCER:
759 dwret = MIDI_DriverProc( 0, 0, MCI_OPEN_DRIVER,
760 dwParam, (DWORD)lp16Parms);
761 break;
762 case MCI_DEVTYPE_ANIMATION:
763 dwret = ANIM_DriverProc( 0, 0, MCI_OPEN_DRIVER,
764 dwParam, (DWORD)lp16Parms);
765 break;
766 case MCI_DEVTYPE_DIGITAL_VIDEO:
767 dprintf_mmsys(stddeb, "MCI_OPEN // No DIGITAL_VIDEO yet !\n");
768 return MCIERR_DEVICE_NOT_INSTALLED;
769 default:
770 dprintf_mmsys(stddeb, "MCI_OPEN // Invalid Device Name '%08lx' !\n", lpParms->lpstrDeviceType);
771 return MCIERR_INVALID_DEVICE_NAME;
772 }
773
774
775 if (dwParam&MCI_NOTIFY)
776 mciDriverNotify(lpParms->dwCallback,wDevID,
777 (dwret==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
778
779 /* only handled devices fall through */
780 dprintf_mmsys(stddeb, "MCI_OPEN // wDevID = %04X wDeviceID = %d dwret = %ld\n",wDevID, lpParms->wDeviceID, dwret);
781 return dwret;
782 }
783
784
785 /**************************************************************************
786 * mciClose [internal]
787 */
788 DWORD mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
789 {
790 DWORD dwRet = MCIERR_INTERNAL;
791
792 dprintf_mmsys(stddeb, "mciClose(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
793 switch(GetDrv(wDevID)->wType) {
794 case MCI_DEVTYPE_CD_AUDIO:
795 dwRet = CDAUDIO_DriverProc(GetDrv(wDevID)->wDeviceID,0,
796 MCI_CLOSE, dwParam, (DWORD)lpParms);
797 break;
798 case MCI_DEVTYPE_WAVEFORM_AUDIO:
799 dwRet = WAVE_DriverProc(GetDrv(wDevID)->wDeviceID, 0,
800 MCI_CLOSE, dwParam,
801 (DWORD)lpParms);
802 break;
803 case MCI_DEVTYPE_SEQUENCER:
804 dwRet = MIDI_DriverProc(GetDrv(wDevID)->wDeviceID, 0,
805 MCI_CLOSE, dwParam,
806 (DWORD)lpParms);
807 break;
808 case MCI_DEVTYPE_ANIMATION:
809 dwRet = ANIM_DriverProc(GetDrv(wDevID)->wDeviceID, 0,
810 MCI_CLOSE, dwParam,
811 (DWORD)lpParms);
812 break;
813 default:
814 dprintf_mmsys(stddeb, "mciClose() // unknown device type=%04X !\n", GetDrv(wDevID)->wType);
815 dwRet = MCIERR_DEVICE_NOT_INSTALLED;
816 }
817 GetDrv(wDevID)->wType = 0;
818
819 if (dwParam&MCI_NOTIFY)
820 mciDriverNotify(lpParms->dwCallback,wDevID,
821 (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
822
823 dprintf_mmsys(stddeb, "mciClose() // returns %ld\n",dwRet);
824 return dwRet;
825 }
826
827
828 /**************************************************************************
829 * mciSysinfo [internal]
830 */
831 DWORD mciSysInfo(DWORD dwFlags, LPMCI_SYSINFO_PARMS lpParms)
832 {
833 int len;
834 LPSTR ptr;
835 LPSTR lpstrReturn;
836 DWORD *lpdwRet;
837 LPSTR SysFile = "SYSTEM.INI";
838 dprintf_mci(stddeb, "mciSysInfo(%08lX, %08lX)\n", dwFlags, (DWORD)lpParms);
839 lpstrReturn = PTR_SEG_TO_LIN(lpParms->lpstrReturn);
840 switch(dwFlags) {
841 case MCI_SYSINFO_QUANTITY:
842 dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_QUANTITY \n");
843 lpdwRet = (DWORD *)lpstrReturn;
844 *(lpdwRet) = InstalledCount;
845 return 0;
846 case MCI_SYSINFO_INSTALLNAME:
847 dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_INSTALLNAME \n");
848 if (lpInstallNames == NULL) {
849 InstalledCount = 0;
850 InstalledListLen = 0;
851 ptr = lpInstallNames = xmalloc(2048);
852 GetPrivateProfileString32A("mci", NULL, "", lpInstallNames, 2000, SysFile);
853 while(strlen(ptr) > 0) {
854 dprintf_mci(stddeb, "---> '%s' \n", ptr);
855 len = strlen(ptr) + 1;
856 ptr += len;
857 InstalledListLen += len;
858 InstalledCount++;
859 }
860 }
861 if (lpParms->dwRetSize < InstalledListLen)
862 lstrcpyn32A(lpstrReturn, lpInstallNames, lpParms->dwRetSize - 1);
863 else
864 strcpy(lpstrReturn, lpInstallNames);
865 return 0;
866 case MCI_SYSINFO_NAME:
867 dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_NAME \n");
868 return 0;
869 case MCI_SYSINFO_OPEN:
870 dprintf_mci(stddeb, "mciSysInfo // MCI_SYSINFO_OPEN \n");
871 return 0;
872 }
873 return MMSYSERR_INVALPARAM;
874 }
875
876 /**************************************************************************
877 * mciSound [internal]
878 * not used anymore ??
879
880 DWORD mciSound(UINT16 wDevID, DWORD dwParam, LPMCI_SOUND_PARMS lpParms)
881 {
882 if (lpParms == NULL) return MCIERR_INTERNAL;
883 if (dwParam & MCI_SOUND_NAME)
884 dprintf_mci(stddeb, "MCI_SOUND // file='%s' !\n", lpParms->lpstrSoundName);
885 return MCIERR_INVALID_DEVICE_ID;
886 }
887 *
888 */
889
890 static const char *_mciCommandToString(UINT16 wMsg)
891 {
892 static char buffer[100];
893
894 #define CASE(s) case (s): return #s
895
896 switch (wMsg) {
897 CASE(MCI_OPEN);
898 CASE(MCI_CLOSE);
899 CASE(MCI_ESCAPE);
900 CASE(MCI_PLAY);
901 CASE(MCI_SEEK);
902 CASE(MCI_STOP);
903 CASE(MCI_PAUSE);
904 CASE(MCI_INFO);
905 CASE(MCI_GETDEVCAPS);
906 CASE(MCI_SPIN);
907 CASE(MCI_SET);
908 CASE(MCI_STEP);
909 CASE(MCI_RECORD);
910 CASE(MCI_SYSINFO);
911 CASE(MCI_BREAK);
912 CASE(MCI_SAVE);
913 CASE(MCI_STATUS);
914 CASE(MCI_CUE);
915 CASE(MCI_REALIZE);
916 CASE(MCI_WINDOW);
917 CASE(MCI_PUT);
918 CASE(MCI_WHERE);
919 CASE(MCI_FREEZE);
920 CASE(MCI_UNFREEZE);
921 CASE(MCI_LOAD);
922 CASE(MCI_CUT);
923 CASE(MCI_COPY);
924 CASE(MCI_PASTE);
925 CASE(MCI_UPDATE);
926 CASE(MCI_RESUME);
927 CASE(MCI_DELETE);
928 default:
929 sprintf(buffer, "%04X", wMsg);
930 return buffer;
931
932 }
933 }
934
935 /**************************************************************************
936 * mciSendCommand [MMSYSTEM.701]
937 */
938 DWORD mciSendCommand(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
939 {
940 HDRVR16 hDrv = 0;
941 dprintf_mci(stddeb, "mciSendCommand(%04X, %s, %08lX, %08lX)\n",
942 wDevID, _mciCommandToString(wMsg), dwParam1, dwParam2);
943 switch(wMsg)
944 {
945 case MCI_OPEN:
946 return mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
947 case MCI_CLOSE:
948 return mciClose( wDevID, dwParam1,
949 (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
950 case MCI_SYSINFO:
951 return mciSysInfo( dwParam1,
952 (LPMCI_SYSINFO_PARMS)PTR_SEG_TO_LIN(dwParam2));
953 default:
954 switch(GetDrv(wDevID)->wType)
955 {
956 case MCI_DEVTYPE_CD_AUDIO:
957 return CDAUDIO_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
958 wMsg, dwParam1, dwParam2);
959 case MCI_DEVTYPE_WAVEFORM_AUDIO:
960 return WAVE_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
961 wMsg, dwParam1, dwParam2);
962 case MCI_DEVTYPE_SEQUENCER:
963 return MIDI_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
964 wMsg, dwParam1, dwParam2);
965 case MCI_DEVTYPE_ANIMATION:
966 return ANIM_DriverProc(GetDrv(wDevID)->wDeviceID, hDrv,
967 wMsg, dwParam1, dwParam2);
968 default:
969 dprintf_mci(stddeb,
970 "mciSendCommand() // unknown device type=%04X !\n",
971 GetDrv(wDevID)->wType);
972 }
973 }
974 return MMSYSERR_INVALPARAM;
975 }
976
977 /**************************************************************************
978 * mciGetDeviceID [MMSYSTEM.703]
979 */
980 UINT16 mciGetDeviceID (LPCSTR lpstrName)
981 {
982 UINT16 wDevID;
983
984 dprintf_mci(stddeb, "mciGetDeviceID(\"%s\")\n", lpstrName);
985 if (lpstrName && !lstrcmpi32A(lpstrName, "ALL"))
986 return MCI_ALL_DEVICE_ID;
987
988 if (!lpstrName)
989 return 0;
990
991 wDevID = MMSYSTEM_FirstDevID();
992 while(MMSYSTEM_DevIDValid(wDevID) && GetDrv(wDevID)->wType) {
993 if (GetOpenDrv(wDevID)->lpstrDeviceType &&
994 strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrDeviceType), lpstrName) == 0)
995 return wDevID;
996
997 if (GetOpenDrv(wDevID)->lpstrAlias &&
998 strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrAlias), lpstrName) == 0)
999 return wDevID;
1000
1001 wDevID = MMSYSTEM_NextDevID(wDevID);
1002 }
1003
1004 return 0;
1005 }
1006
1007 /**************************************************************************
1008 * mciSetYieldProc [MMSYSTEM.714]
1009 */
1010 BOOL16 mciSetYieldProc (UINT16 uDeviceID,
1011 YIELDPROC fpYieldProc, DWORD dwYieldData)
1012 {
1013 return FALSE;
1014 }
1015
1016 /**************************************************************************
1017 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
1018 */
1019 UINT16 mciGetDeviceIDFromElementID(DWORD dwElementID, LPCSTR lpstrType)
1020 {
1021 return 0;
1022 }
1023
1024 /**************************************************************************
1025 * mciGetYieldProc [MMSYSTEM.716]
1026 */
1027 YIELDPROC mciGetYieldProc(UINT16 uDeviceID, DWORD * lpdwYieldData)
1028 {
1029 return NULL;
1030 }
1031
1032 /**************************************************************************
1033 * mciGetCreatorTask [MMSYSTEM.717]
1034 */
1035 HTASK16 mciGetCreatorTask(UINT16 uDeviceID)
1036 {
1037 return 0;
1038 }
1039
1040 /**************************************************************************
1041 * midiOutGetNumDevs [MMSYSTEM.201]
1042 */
1043 UINT16 midiOutGetNumDevs(void)
1044 {
1045 UINT16 count = 0;
1046 dprintf_mmsys(stddeb, "midiOutGetNumDevs\n");
1047 count += modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
1048 dprintf_mmsys(stddeb, "midiOutGetNumDevs return %u \n", count);
1049 return count;
1050 }
1051
1052 /**************************************************************************
1053 * midiOutGetDevCaps [MMSYSTEM.202]
1054 */
1055 UINT16 midiOutGetDevCaps(UINT16 uDeviceID, MIDIOUTCAPS * lpCaps, UINT16 uSize)
1056 {
1057 dprintf_mmsys(stddeb, "midiOutGetDevCaps\n");
1058 return modMessage(uDeviceID,MODM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);
1059 }
1060
1061 /**************************************************************************
1062 * midiOutGetErrorText [MMSYSTEM.203]
1063 */
1064 UINT16 midiOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1065 {
1066 dprintf_mmsys(stddeb, "midiOutGetErrorText\n");
1067 return midiGetErrorText(uError, lpText, uSize);
1068 }
1069
1070
1071 /**************************************************************************
1072 * midiGetErrorText [internal]
1073 */
1074 UINT16 midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1075 {
1076 LPSTR msgptr;
1077 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1078 lpText[0] = '\0';
1079 switch(uError) {
1080 case MIDIERR_UNPREPARED:
1081 msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1082 break;
1083 case MIDIERR_STILLPLAYING:
1084 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1085 break;
1086 case MIDIERR_NOMAP:
1087 msgptr = "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing.";
1088 break;
1089 case MIDIERR_NOTREADY:
1090 msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
1091 break;
1092 case MIDIERR_NODEVICE:
1093 msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.";
1094 break;
1095 case MIDIERR_INVALIDSETUP:
1096 msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
1097 break;
1098 /*
1099 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
1100 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
1101 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
1102 msg# 339 : The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.
1103 msg# 340 : An error occurred using the specified port.
1104 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
1105 msg# 342 : There is no current MIDI port.
1106 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
1107 */
1108 default:
1109 msgptr = "Unknown MIDI Error !\n";
1110 break;
1111 }
1112 lstrcpyn32A(lpText, msgptr, uSize);
1113 return TRUE;
1114 }
1115
1116 /**************************************************************************
1117 * midiOutOpen [MMSYSTEM.204]
1118 */
1119 UINT16 midiOutOpen(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
1120 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1121 {
1122 HMIDI16 hMidiOut;
1123 LPMIDIOPENDESC lpDesc;
1124 LPMIDIOPENDESC lp16Desc;
1125 DWORD dwRet = 0;
1126 BOOL32 bMapperFlg = FALSE;
1127 if (lphMidiOut != NULL) *lphMidiOut = 0;
1128 dprintf_mmsys(stddeb, "midiOutOpen(%p, %d, %08lX, %08lX, %08lX);\n",
1129 lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
1130 if (uDeviceID == (UINT16)MIDI_MAPPER) {
1131 dprintf_mmsys(stddeb, "midiOutOpen // MIDI_MAPPER mode requested !\n");
1132 bMapperFlg = TRUE;
1133 uDeviceID = 0;
1134 }
1135 hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1136 if (lphMidiOut != NULL) *lphMidiOut = hMidiOut;
1137 lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiOut);
1138 lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1139 if (lpDesc == NULL) return MMSYSERR_NOMEM;
1140 lpDesc->hMidi = hMidiOut;
1141 lpDesc->dwCallback = dwCallback;
1142 lpDesc->dwInstance = dwInstance;
1143 while(uDeviceID < MAXMIDIDRIVERS) {
1144 dwRet = modMessage(uDeviceID, MODM_OPEN,
1145 lpDesc->dwInstance, (DWORD)lp16Desc, 0L);
1146 if (dwRet == MMSYSERR_NOERROR) break;
1147 if (!bMapperFlg) break;
1148 uDeviceID++;
1149 dprintf_mmsys(stddeb, "midiOutOpen // MIDI_MAPPER mode ! try next driver...\n");
1150 }
1151 return dwRet;
1152 }
1153
1154 /**************************************************************************
1155 * midiOutClose [MMSYSTEM.205]
1156 */
1157 UINT16 midiOutClose(HMIDIOUT16 hMidiOut)
1158 {
1159 LPMIDIOPENDESC lpDesc;
1160 dprintf_mmsys(stddeb, "midiOutClose(%04X)\n", hMidiOut);
1161 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1162 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1163 return modMessage(0, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1164 }
1165
1166 /**************************************************************************
1167 * midiOutPrepareHeader [MMSYSTEM.206]
1168 */
1169 UINT16 midiOutPrepareHeader(HMIDIOUT16 hMidiOut,
1170 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1171 {
1172 LPMIDIOPENDESC lpDesc;
1173 dprintf_mmsys(stddeb, "midiOutPrepareHeader(%04X, %p, %d)\n",
1174 hMidiOut, lpMidiOutHdr, uSize);
1175 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1176 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1177 return modMessage(0, MODM_PREPARE, lpDesc->dwInstance,
1178 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1179 }
1180
1181 /**************************************************************************
1182 * midiOutUnprepareHeader [MMSYSTEM.207]
1183 */
1184 UINT16 midiOutUnprepareHeader(HMIDIOUT16 hMidiOut,
1185 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1186 {
1187 LPMIDIOPENDESC lpDesc;
1188 dprintf_mmsys(stddeb, "midiOutUnprepareHeader(%04X, %p, %d)\n",
1189 hMidiOut, lpMidiOutHdr, uSize);
1190 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1191 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1192 return modMessage(0, MODM_UNPREPARE, lpDesc->dwInstance,
1193 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1194 }
1195
1196 /**************************************************************************
1197 * midiOutShortMsg [MMSYSTEM.208]
1198 */
1199 UINT16 midiOutShortMsg(HMIDIOUT16 hMidiOut, DWORD dwMsg)
1200 {
1201 LPMIDIOPENDESC lpDesc;
1202 dprintf_mmsys(stddeb, "midiOutShortMsg(%04X, %08lX)\n", hMidiOut, dwMsg);
1203 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1204 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1205 return modMessage(0, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
1206 }
1207
1208 /**************************************************************************
1209 * midiOutLongMsg [MMSYSTEM.209]
1210 */
1211 UINT16 midiOutLongMsg(HMIDIOUT16 hMidiOut,
1212 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1213 {
1214 LPMIDIOPENDESC lpDesc;
1215 dprintf_mmsys(stddeb, "midiOutLongMsg(%04X, %p, %d)\n",
1216 hMidiOut, lpMidiOutHdr, uSize);
1217 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1218 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1219 return modMessage(0, MODM_LONGDATA, lpDesc->dwInstance,
1220 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1221 }
1222
1223 /**************************************************************************
1224 * midiOutReset [MMSYSTEM.210]
1225 */
1226 UINT16 midiOutReset(HMIDIOUT16 hMidiOut)
1227 {
1228 LPMIDIOPENDESC lpDesc;
1229 dprintf_mmsys(stddeb, "midiOutReset(%04X)\n", hMidiOut);
1230 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1231 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1232 return modMessage(0, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
1233 }
1234
1235 /**************************************************************************
1236 * midiOutGetVolume [MMSYSTEM.211]
1237 */
1238 UINT16 midiOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume)
1239 {
1240 dprintf_mmsys(stddeb, "midiOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume);
1241 return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
1242 return 0;
1243 }
1244
1245 /**************************************************************************
1246 * midiOutSetVolume [MMSYSTEM.212]
1247 */
1248 UINT16 midiOutSetVolume(UINT16 uDeviceID, DWORD dwVolume)
1249 {
1250 dprintf_mmsys(stddeb, "midiOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume);
1251 return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
1252 return 0;
1253 }
1254
1255 /**************************************************************************
1256 * midiOutCachePatches [MMSYSTEM.213]
1257 */
1258 UINT16 midiOutCachePatches(HMIDIOUT16 hMidiOut,
1259 UINT16 uBank, WORD * lpwPatchArray, UINT16 uFlags)
1260 {
1261 /* not really necessary to support this */
1262 fprintf(stdnimp, "midiOutCachePatches: not supported yet\n");
1263 return MMSYSERR_NOTSUPPORTED;
1264 }
1265
1266 /**************************************************************************
1267 * midiOutCacheDrumPatches [MMSYSTEM.214]
1268 */
1269 UINT16 midiOutCacheDrumPatches(HMIDIOUT16 hMidiOut,
1270 UINT16 uPatch, WORD * lpwKeyArray, UINT16 uFlags)
1271 {
1272 fprintf(stdnimp, "midiOutCacheDrumPatchesi: not supported yet\n");
1273 return MMSYSERR_NOTSUPPORTED;
1274 }
1275
1276 /**************************************************************************
1277 * midiOutGetID [MMSYSTEM.215]
1278 */
1279 UINT16 midiOutGetID(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID)
1280 {
1281 dprintf_mmsys(stddeb, "midiOutGetID\n");
1282 return 0;
1283 }
1284
1285 /**************************************************************************
1286 * midiOutMessage [MMSYSTEM.216]
1287 */
1288 DWORD midiOutMessage(HMIDIOUT16 hMidiOut, UINT16 uMessage,
1289 DWORD dwParam1, DWORD dwParam2)
1290 {
1291 LPMIDIOPENDESC lpDesc;
1292 dprintf_mmsys(stddeb, "midiOutMessage(%04X, %04X, %08lX, %08lX)\n",
1293 hMidiOut, uMessage, dwParam1, dwParam2);
1294 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1295 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1296 return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1297 return 0;
1298 }
1299
1300 /**************************************************************************
1301 * midiInGetNumDevs [MMSYSTEM.301]
1302 */
1303 UINT16 midiInGetNumDevs(void)
1304 {
1305 UINT16 count = 0;
1306 dprintf_mmsys(stddeb, "midiInGetNumDevs\n");
1307 count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
1308 dprintf_mmsys(stddeb, "midiInGetNumDevs return %u \n", count);
1309 return count;
1310 }
1311
1312 /**************************************************************************
1313 * midiInGetDevCaps [MMSYSTEM.302]
1314 */
1315 UINT16 midiInGetDevCaps(UINT16 uDeviceID,
1316 LPMIDIINCAPS lpCaps, UINT16 uSize)
1317 {
1318 dprintf_mmsys(stddeb, "midiInGetDevCaps\n");
1319 return midMessage(uDeviceID,MIDM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);;
1320 }
1321
1322 /**************************************************************************
1323 * midiInGetErrorText [MMSYSTEM.303]
1324 */
1325 UINT16 midiInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1326 {
1327 dprintf_mmsys(stddeb, "midiInGetErrorText\n");
1328 return (midiGetErrorText(uError, lpText, uSize));
1329 }
1330
1331 /**************************************************************************
1332 * midiInOpen [MMSYSTEM.304]
1333 */
1334 UINT16 midiInOpen(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
1335 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1336 {
1337 HMIDI16 hMidiIn;
1338 LPMIDIOPENDESC lpDesc;
1339 LPMIDIOPENDESC lp16Desc;
1340 DWORD dwRet = 0;
1341 BOOL32 bMapperFlg = FALSE;
1342 if (lphMidiIn != NULL) *lphMidiIn = 0;
1343 dprintf_mmsys(stddeb, "midiInOpen(%p, %d, %08lX, %08lX, %08lX);\n",
1344 lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
1345 if (uDeviceID == (UINT16)MIDI_MAPPER) {
1346 dprintf_mmsys(stddeb, "midiInOpen // MIDI_MAPPER mode requested !\n");
1347 bMapperFlg = TRUE;
1348 uDeviceID = 0;
1349 }
1350 hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1351 if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
1352 lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiIn);
1353 lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1354 if (lpDesc == NULL) return MMSYSERR_NOMEM;
1355 lpDesc->hMidi = hMidiIn;
1356 lpDesc->dwCallback = dwCallback;
1357 lpDesc->dwInstance = dwInstance;
1358 while(uDeviceID < MAXMIDIDRIVERS) {
1359 dwRet = midMessage(uDeviceID, MIDM_OPEN,
1360 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
1361 if (dwRet == MMSYSERR_NOERROR) break;
1362 if (!bMapperFlg) break;
1363 uDeviceID++;
1364 dprintf_mmsys(stddeb, "midiInOpen // MIDI_MAPPER mode ! try next driver...\n");
1365 }
1366 return dwRet;
1367 }
1368
1369 /**************************************************************************
1370 * midiInClose [MMSYSTEM.305]
1371 */
1372 UINT16 midiInClose(HMIDIIN16 hMidiIn)
1373 {
1374 LPMIDIOPENDESC lpDesc;
1375 dprintf_mmsys(stddeb, "midiInClose(%04X)\n", hMidiIn);
1376 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1377 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1378 return midMessage(0, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1379 }
1380
1381 /**************************************************************************
1382 * midiInPrepareHeader [MMSYSTEM.306]
1383 */
1384 UINT16 midiInPrepareHeader(HMIDIIN16 hMidiIn,
1385 MIDIHDR * lpMidiInHdr, UINT16 uSize)
1386 {
1387 LPMIDIOPENDESC lpDesc;
1388 dprintf_mmsys(stddeb, "midiInPrepareHeader(%04X, %p, %d)\n",
1389 hMidiIn, lpMidiInHdr, uSize);
1390 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1391 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1392 return midMessage(0, MIDM_PREPARE, lpDesc->dwInstance,
1393 (DWORD)lpMidiInHdr, (DWORD)uSize);
1394 }
1395
1396 /**************************************************************************
1397 * midiInUnprepareHeader [MMSYSTEM.307]
1398 */
1399 UINT16 midiInUnprepareHeader(HMIDIIN16 hMidiIn,
1400 MIDIHDR * lpMidiInHdr, UINT16 uSize)
1401 {
1402 LPMIDIOPENDESC lpDesc;
1403 dprintf_mmsys(stddeb, "midiInUnprepareHeader(%04X, %p, %d)\n",
1404 hMidiIn, lpMidiInHdr, uSize);
1405 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1406 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1407 return midMessage(0, MIDM_UNPREPARE, lpDesc->dwInstance,
1408 (DWORD)lpMidiInHdr, (DWORD)uSize);
1409 }
1410
1411 /**************************************************************************
1412 * midiInAddBuffer [MMSYSTEM.308]
1413 */
1414 UINT16 midiInAddBuffer(HMIDIIN16 hMidiIn,
1415 MIDIHDR * lpMidiInHdr, UINT16 uSize)
1416 {
1417 dprintf_mmsys(stddeb, "midiInAddBuffer\n");
1418 return 0;
1419 }
1420
1421 /**************************************************************************
1422 * midiInStart [MMSYSTEM.309]
1423 */
1424 UINT16 midiInStart(HMIDIIN16 hMidiIn)
1425 {
1426 dprintf_mmsys(stddeb, "midiInStart\n");
1427 return 0;
1428 }
1429
1430 /**************************************************************************
1431 * midiInStop [MMSYSTEM.310]
1432 */
1433 UINT16 midiInStop(HMIDIIN16 hMidiIn)
1434 {
1435 dprintf_mmsys(stddeb, "midiInStop\n");
1436 return 0;
1437 }
1438
1439 /**************************************************************************
1440 * midiInReset [MMSYSTEM.311]
1441 */
1442 UINT16 midiInReset(HMIDIIN16 hMidiIn)
1443 {
1444 dprintf_mmsys(stddeb, "midiInReset\n");
1445 return 0;
1446 }
1447
1448 /**************************************************************************
1449 * midiInGetID [MMSYSTEM.312]
1450 */
1451 UINT16 midiInGetID(HMIDIIN16 hMidiIn, UINT16 * lpuDeviceID)
1452 {
1453 dprintf_mmsys(stddeb, "midiInGetID\n");
1454 return 0;
1455 }
1456
1457 /**************************************************************************
1458 * midiInMessage [MMSYSTEM.313]
1459 */
1460 DWORD midiInMessage(HMIDIIN16 hMidiIn, UINT16 uMessage,
1461 DWORD dwParam1, DWORD dwParam2)
1462 {
1463 LPMIDIOPENDESC lpDesc;
1464 dprintf_mmsys(stddeb, "midiInMessage(%04X, %04X, %08lX, %08lX)\n",
1465 hMidiIn, uMessage, dwParam1, dwParam2);
1466 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1467 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1468 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1469 }
1470
1471
1472 /**************************************************************************
1473 * waveOutGetNumDevs [MMSYSTEM.401]
1474 */
1475 UINT16 waveOutGetNumDevs()
1476 {
1477 UINT16 count = 0;
1478 dprintf_mmsys(stddeb, "waveOutGetNumDevs\n");
1479 count += wodMessage( MMSYSTEM_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L);
1480 dprintf_mmsys(stddeb, "waveOutGetNumDevs return %u \n", count);
1481 return count;
1482 }
1483
1484 /**************************************************************************
1485 * waveOutGetDevCaps [MMSYSTEM.402]
1486 */
1487 UINT16 waveOutGetDevCaps(UINT16 uDeviceID, WAVEOUTCAPS * lpCaps, UINT16 uSize)
1488 {
1489 if (uDeviceID > waveOutGetNumDevs() - 1) return MMSYSERR_BADDEVICEID;
1490 if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */
1491 dprintf_mmsys(stddeb, "waveOutGetDevCaps\n");
1492 return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
1493 }
1494
1495 /**************************************************************************
1496 * waveOutGetErrorText [MMSYSTEM.403]
1497 */
1498 UINT16 waveOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1499 {
1500 dprintf_mmsys(stddeb, "waveOutGetErrorText\n");
1501 return(waveGetErrorText(uError, lpText, uSize));
1502 }
1503
1504
1505 /**************************************************************************
1506 * waveGetErrorText [internal]
1507 */
1508 UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1509 {
1510 LPSTR msgptr;
1511 dprintf_mmsys(stddeb, "waveGetErrorText(%04X, %p, %d);\n", uError, lpText, uSize);
1512 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1513 lpText[0] = '\0';
1514 switch(uError) {
1515 case MMSYSERR_NOERROR:
1516 msgptr = "The specified command was carried out.";
1517 break;
1518 case MMSYSERR_ERROR:
1519 msgptr = "Undefined external error.";
1520 break;
1521 case MMSYSERR_BADDEVICEID:
1522 msgptr = "A device ID has been used that is out of range for your system.";
1523 break;
1524 case MMSYSERR_NOTENABLED:
1525 msgptr = "The driver was not enabled.";
1526 break;
1527 case MMSYSERR_ALLOCATED:
1528 msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
1529 break;
1530 case MMSYSERR_INVALHANDLE:
1531 msgptr = "The specified device handle is invalid.";
1532 break;
1533 case MMSYSERR_NODRIVER:
1534 msgptr = "There is no driver installed on your system !\n";
1535 break;
1536 case MMSYSERR_NOMEM:
1537 msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
1538 break;
1539 case MMSYSERR_NOTSUPPORTED:
1540 msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
1541 break;
1542 case MMSYSERR_BADERRNUM:
1543 msgptr = "An error number was specified that is not defined in the system.";
1544 break;
1545 case MMSYSERR_INVALFLAG:
1546 msgptr = "An invalid flag was passed to a system function.";
1547 break;
1548 case MMSYSERR_INVALPARAM:
1549 msgptr = "An invalid parameter was passed to a system function.";
1550 break;
1551 case WAVERR_BADFORMAT:
1552 msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
1553 break;
1554 case WAVERR_STILLPLAYING:
1555 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1556 break;
1557 case WAVERR_UNPREPARED:
1558 msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1559 break;
1560 case WAVERR_SYNC:
1561 msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
1562 break;
1563 default:
1564 msgptr = "Unknown MMSYSTEM Error !\n";
1565 break;
1566 }
1567 lstrcpyn32A(lpText, msgptr, uSize);
1568 return TRUE;
1569 }
1570
1571 /**************************************************************************
1572 * waveOutOpen [MMSYSTEM.404]
1573 */
1574 UINT16 waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
1575 const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1576 {
1577 HWAVEOUT16 hWaveOut;
1578 LPWAVEOPENDESC lpDesc;
1579 LPWAVEOPENDESC lp16Desc;
1580 DWORD dwRet = 0;
1581 BOOL32 bMapperFlg = FALSE;
1582
1583 dprintf_mmsys(stddeb, "waveOutOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
1584 lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
1585 if (dwFlags & WAVE_FORMAT_QUERY) {
1586 dprintf_mmsys(stddeb, "waveOutOpen // WAVE_FORMAT_QUERY requested !\n");
1587 }
1588 if (uDeviceID == (UINT16)WAVE_MAPPER) {
1589 dprintf_mmsys(stddeb, "waveOutOpen // WAVE_MAPPER mode requested !\n");
1590 bMapperFlg = TRUE;
1591 uDeviceID = 0;
1592 }
1593 if (lpFormat == NULL) return WAVERR_BADFORMAT;
1594
1595 hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
1596 if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
1597 lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveOut);
1598 lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1599 if (lpDesc == NULL) return MMSYSERR_NOMEM;
1600 lpDesc->hWave = hWaveOut;
1601 lpDesc->lpFormat = lpFormat; /* should the struct be copied iso pointer? */
1602 lpDesc->dwCallBack = dwCallback;
1603 lpDesc->dwInstance = dwInstance;
1604 if (uDeviceID >= MAXWAVEDRIVERS) uDeviceID = 0;
1605 while(uDeviceID < MAXWAVEDRIVERS) {
1606 dwRet = wodMessage(uDeviceID, WODM_OPEN,
1607 lpDesc->dwInstance, (DWORD)lp16Desc, dwFlags);
1608 if (dwRet == MMSYSERR_NOERROR) break;
1609 if (!bMapperFlg) break;
1610 uDeviceID++;
1611 dprintf_mmsys(stddeb, "waveOutOpen // WAVE_MAPPER mode ! try next driver...\n");
1612 }
1613 lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */
1614 if (dwFlags & WAVE_FORMAT_QUERY) {
1615 dprintf_mmsys(stddeb, "waveOutOpen // End of WAVE_FORMAT_QUERY !\n");
1616 dwRet = waveOutClose(hWaveOut);
1617 }
1618 return dwRet;
1619 }
1620
1621 /**************************************************************************
1622 * waveOutClose [MMSYSTEM.405]
1623 */
1624 UINT16 waveOutClose(HWAVEOUT16 hWaveOut)
1625 {
1626 LPWAVEOPENDESC lpDesc;
1627
1628 dprintf_mmsys(stddeb, "waveOutClose(%04X)\n", hWaveOut);
1629 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1630 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1631 return wodMessage( lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1632 }
1633
1634 /**************************************************************************
1635 * waveOutPrepareHeader [MMSYSTEM.406]
1636 */
1637 UINT16 waveOutPrepareHeader(HWAVEOUT16 hWaveOut,
1638 WAVEHDR * lpWaveOutHdr, UINT16 uSize)
1639 {
1640 LPWAVEOPENDESC lpDesc;
1641
1642 dprintf_mmsys(stddeb, "waveOutPrepareHeader(%04X, %p, %u);\n",
1643 hWaveOut, lpWaveOutHdr, uSize);
1644 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1645 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1646 return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
1647 (DWORD)lpWaveOutHdr, uSize);
1648 }
1649
1650 /**************************************************************************
1651 * waveOutUnprepareHeader [MMSYSTEM.407]
1652 */
1653 UINT16 waveOutUnprepareHeader(HWAVEOUT16 hWaveOut,
1654 WAVEHDR * lpWaveOutHdr, UINT16 uSize)
1655 {
1656 LPWAVEOPENDESC lpDesc;
1657
1658 dprintf_mmsys(stddeb, "waveOutUnprepareHeader(%04X, %p, %u);\n",
1659 hWaveOut, lpWaveOutHdr, uSize);
1660 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1661 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1662 return wodMessage( lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance,
1663 (DWORD)lpWaveOutHdr, uSize);
1664 }
1665
1666 /**************************************************************************
1667 * waveOutWrite [MMSYSTEM.408]
1668 */
1669 UINT16 waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, UINT16 uSize)
1670 {
1671 LPWAVEOPENDESC lpDesc;
1672
1673 dprintf_mmsys(stddeb, "waveOutWrite(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
1674 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1675 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1676 return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance,
1677 (DWORD)lpWaveOutHdr, uSize);
1678 }
1679
1680 /**************************************************************************
1681 * waveOutPause [MMSYSTEM.409]
1682 */
1683 UINT16 waveOutPause(HWAVEOUT16 hWaveOut)
1684 {
1685 LPWAVEOPENDESC lpDesc;
1686
1687 dprintf_mmsys(stddeb, "waveOutPause(%04X)\n", hWaveOut);
1688 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1689 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1690 return wodMessage( lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
1691 }
1692
1693 /**************************************************************************
1694 * waveOutRestart [MMSYSTEM.410]
1695 */
1696 UINT16 waveOutRestart(HWAVEOUT16 hWaveOut)
1697 {
1698 LPWAVEOPENDESC lpDesc;
1699
1700 dprintf_mmsys(stddeb, "waveOutRestart(%04X)\n", hWaveOut);
1701 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1702 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1703 return wodMessage( lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
1704 }
1705
1706 /**************************************************************************
1707 * waveOutReset [MMSYSTEM.411]
1708 */
1709 UINT16 waveOutReset(HWAVEOUT16 hWaveOut)
1710 {
1711 LPWAVEOPENDESC lpDesc;
1712 dprintf_mmsys(stddeb, "waveOutReset(%04X)\n", hWaveOut);
1713 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1714 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1715 return wodMessage( lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
1716 }
1717
1718 /**************************************************************************
1719 * waveOutGetPosition [MMSYSTEM.412]
1720 */
1721 UINT16 waveOutGetPosition(HWAVEOUT16 hWaveOut, MMTIME * lpTime, UINT16 uSize)
1722 {
1723 LPWAVEOPENDESC lpDesc;
1724 dprintf_mmsys(stddeb, "waveOutGetPosition(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
1725 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1726 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1727 return wodMessage( lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance,
1728 (DWORD)lpTime, (DWORD)uSize);
1729 }
1730
1731 /**************************************************************************
1732 * waveOutGetPitch [MMSYSTEM.413]
1733 */
1734 UINT16 waveOutGetPitch(HWAVEOUT16 hWaveOut, DWORD * lpdwPitch)
1735 {
1736 LPWAVEOPENDESC lpDesc;
1737 dprintf_mmsys(stddeb, "waveOutGetPitch(%04X, %p);\n", hWaveOut, lpdwPitch);
1738 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1739 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1740 return wodMessage( lpDesc->uDeviceID, WODM_GETPITCH, lpDesc->dwInstance,
1741 (DWORD)lpdwPitch, 0L);
1742 }
1743
1744 /**************************************************************************
1745 * waveOutSetPitch [MMSYSTEM.414]
1746 */
1747 UINT16 waveOutSetPitch(HWAVEOUT16 hWaveOut, DWORD dwPitch)
1748 {
1749 LPWAVEOPENDESC lpDesc;
1750 dprintf_mmsys(stddeb, "waveOutSetPitch(%04X, %08lX);\n", hWaveOut, dwPitch);
1751 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1752 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1753 return wodMessage( lpDesc->uDeviceID, WODM_SETPITCH, lpDesc->dwInstance, (DWORD)dwPitch, 0L);
1754 }
1755
1756 /**************************************************************************
1757 * waveOutGetVolume [MMSYSTEM.415]
1758 */
1759 UINT16 waveOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume)
1760 {
1761 dprintf_mmsys(stddeb, "waveOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume);
1762 return wodMessage(uDeviceID, WODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
1763 }
1764
1765 /**************************************************************************
1766 * waveOutSetVolume [MMSYSTEM.416]
1767 */
1768 UINT16 waveOutSetVolume(UINT16 uDeviceID, DWORD dwVolume)
1769 {
1770 dprintf_mmsys(stddeb, "waveOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume);
1771 return wodMessage(uDeviceID, WODM_SETVOLUME, 0L, dwVolume, 0L);
1772 }
1773
1774 /**************************************************************************
1775 * waveOutGetPlaybackRate [MMSYSTEM.417]
1776 */
1777 UINT16 waveOutGetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD * lpdwRate)
1778 {
1779 LPWAVEOPENDESC lpDesc;
1780 dprintf_mmsys(stddeb, "waveOutGetPlaybackRate(%04X, %p);\n", hWaveOut, lpdwRate);
1781 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1782 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1783 return wodMessage( lpDesc->uDeviceID, WODM_GETPLAYBACKRATE, lpDesc->dwInstance,
1784 (DWORD)lpdwRate, 0L);
1785 }
1786
1787 /**************************************************************************
1788 * waveOutSetPlaybackRate [MMSYSTEM.418]
1789 */
1790 UINT16 waveOutSetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD dwRate)
1791 {
1792 LPWAVEOPENDESC lpDesc;
1793 dprintf_mmsys(stddeb, "waveOutSetPlaybackRate(%04X, %08lX);\n", hWaveOut, dwRate);
1794 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1795 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1796 return wodMessage( lpDesc->uDeviceID, WODM_SETPLAYBACKRATE,
1797 lpDesc->dwInstance, (DWORD)dwRate, 0L);
1798 }
1799
1800 /**************************************************************************
1801 * waveOutBreakLoop [MMSYSTEM.419]
1802 */
1803 UINT16 waveOutBreakLoop(HWAVEOUT16 hWaveOut)
1804 {
1805 dprintf_mmsys(stddeb, "waveOutBreakLoop(%04X)\n", hWaveOut);
1806 return MMSYSERR_INVALHANDLE;
1807 }
1808
1809 /**************************************************************************
1810 * waveOutGetID [MMSYSTEM.420]
1811 */
1812 UINT16 waveOutGetID(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID)
1813 {
1814 LPWAVEOPENDESC lpDesc;
1815 dprintf_mmsys(stddeb, "waveOutGetID(%04X, %p);\n", hWaveOut, lpuDeviceID);
1816 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1817 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1818 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
1819 *lpuDeviceID = lpDesc->uDeviceID;
1820 return 0;
1821 }
1822
1823 /**************************************************************************
1824 * waveOutMessage [MMSYSTEM.421]
1825 */
1826 DWORD waveOutMessage(HWAVEOUT16 hWaveOut, UINT16 uMessage,
1827 DWORD dwParam1, DWORD dwParam2)
1828 {
1829 LPWAVEOPENDESC lpDesc;
1830 dprintf_mmsys(stddeb, "waveOutMessage(%04X, %04X, %08lX, %08lX)\n",
1831 hWaveOut, uMessage, dwParam1, dwParam2);
1832 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1833 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1834 return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1835 }
1836
1837 /**************************************************************************
1838 * waveInGetNumDevs [MMSYSTEM.501]
1839 */
1840 UINT16 waveInGetNumDevs()
1841 {
1842 UINT16 count = 0;
1843 dprintf_mmsys(stddeb, "waveInGetNumDevs\n");
1844 count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
1845 dprintf_mmsys(stddeb, "waveInGetNumDevs return %u \n", count);
1846 return count;
1847 }
1848
1849
1850 /**************************************************************************
1851 * waveInGetDevCaps [MMSYSTEM.502]
1852 */
1853 UINT16 waveInGetDevCaps(UINT16 uDeviceID, WAVEINCAPS * lpCaps, UINT16 uSize)
1854 {
1855 dprintf_mmsys(stddeb, "waveInGetDevCaps\n");
1856 return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
1857 }
1858
1859
1860 /**************************************************************************
1861 * waveInGetErrorText [MMSYSTEM.503]
1862 */
1863 UINT16 waveInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1864 {
1865 dprintf_mmsys(stddeb, "waveInGetErrorText\n");
1866 return(waveGetErrorText(uError, lpText, uSize));
1867 }
1868
1869
1870 /**************************************************************************
1871 * waveInOpen [MMSYSTEM.504]
1872 */
1873 UINT16 waveInOpen(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
1874 const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1875 {
1876 HWAVEIN16 hWaveIn;
1877 LPWAVEOPENDESC lpDesc;
1878 LPWAVEOPENDESC lp16Desc;
1879 DWORD dwRet = 0;
1880 BOOL32 bMapperFlg = FALSE;
1881 dprintf_mmsys(stddeb, "waveInOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
1882 lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
1883 if (dwFlags & WAVE_FORMAT_QUERY) {
1884 dprintf_mmsys(stddeb, "waveInOpen // WAVE_FORMAT_QUERY requested !\n");
1885 }
1886 if (uDeviceID == (UINT16)WAVE_MAPPER) {
1887 dprintf_mmsys(stddeb, "waveInOpen // WAVE_MAPPER mode requested !\n");
1888 bMapperFlg = TRUE;
1889 uDeviceID = 0;
1890 }
1891 if (lpFormat == NULL) return WAVERR_BADFORMAT;
1892 hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
1893 if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
1894 lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveIn);
1895 lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1896 if (lpDesc == NULL) return MMSYSERR_NOMEM;
1897 lpDesc->hWave = hWaveIn;
1898 lpDesc->lpFormat = lpFormat;
1899 lpDesc->dwCallBack = dwCallback;
1900 lpDesc->dwInstance = dwInstance;
1901 while(uDeviceID < MAXWAVEDRIVERS) {
1902 dwRet = widMessage(uDeviceID, WIDM_OPEN,
1903 lpDesc->dwInstance, (DWORD)lp16Desc, 0L);
1904 if (dwRet == MMSYSERR_NOERROR) break;
1905 if (!bMapperFlg) break;
1906 uDeviceID++;
1907 dprintf_mmsys(stddeb, "waveInOpen // WAVE_MAPPER mode ! try next driver...\n");
1908 }
1909 lpDesc->uDeviceID = uDeviceID;
1910 if (dwFlags & WAVE_FORMAT_QUERY) {
1911 dprintf_mmsys(stddeb, "waveInOpen // End of WAVE_FORMAT_QUERY !\n");
1912 dwRet = waveInClose(hWaveIn);
1913 }
1914 return dwRet;
1915 }
1916
1917
1918 /**************************************************************************
1919 * waveInClose [MMSYSTEM.505]
1920 */
1921 UINT16 waveInClose(HWAVEIN16 hWaveIn)
1922 {
1923 LPWAVEOPENDESC lpDesc;
1924
1925 dprintf_mmsys(stddeb, "waveInClose(%04X)\n", hWaveIn);
1926 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1927 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1928 return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1929 }
1930
1931
1932 /**************************************************************************
1933 * waveInPrepareHeader [MMSYSTEM.506]
1934 */
1935 UINT16 waveInPrepareHeader(HWAVEIN16 hWaveIn,
1936 WAVEHDR * lpWaveInHdr, UINT16 uSize)
1937 {
1938 LPWAVEOPENDESC lpDesc;
1939 LPWAVEHDR lp32WaveInHdr;
1940
1941 dprintf_mmsys(stddeb, "waveInPrepareHeader(%04X, %p, %u);\n",
1942 hWaveIn, lpWaveInHdr, uSize);
1943 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1944 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1945 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1946 lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
1947 lp32WaveInHdr->lp16Next = (SEGPTR)NULL;
1948 lp32WaveInHdr->dwBytesRecorded = 0;
1949 dprintf_mmsys(stddeb, "waveInPrepareHeader // lpData=%p size=%lu \n",
1950 lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength);
1951 return widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance,
1952 (DWORD)lpWaveInHdr, uSize);
1953 }
1954
1955
1956 /**************************************************************************
1957 * waveInUnprepareHeader [MMSYSTEM.507]
1958 */
1959 UINT16 waveInUnprepareHeader(HWAVEIN16 hWaveIn,
1960 WAVEHDR * lpWaveInHdr, UINT16 uSize)
1961 {
1962 LPWAVEOPENDESC lpDesc;
1963 LPWAVEHDR lp32WaveInHdr;
1964
1965 dprintf_mmsys(stddeb, "waveInUnprepareHeader(%04X, %p, %u);\n",
1966 hWaveIn, lpWaveInHdr, uSize);
1967 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1968 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1969 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1970 lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
1971 USER_HEAP_FREE(HIWORD((DWORD)lp32WaveInHdr->lpData));
1972 lp32WaveInHdr->lpData = NULL;
1973 lp32WaveInHdr->lp16Next = (SEGPTR)NULL;
1974 return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance,
1975 (DWORD)lpWaveInHdr, uSize);
1976 }
1977
1978
1979 /**************************************************************************
1980 * waveInAddBuffer [MMSYSTEM.508]
1981 */
1982 UINT16 waveInAddBuffer(HWAVEIN16 hWaveIn,
1983 WAVEHDR * lpWaveInHdr, UINT16 uSize)
1984 {
1985 LPWAVEOPENDESC lpDesc;
1986 LPWAVEHDR lp32WaveInHdr;
1987
1988 dprintf_mmsys(stddeb, "waveInAddBuffer(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
1989 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1990 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1991 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1992 lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
1993 lp32WaveInHdr->lp16Next = (SEGPTR)NULL;
1994 lp32WaveInHdr->dwBytesRecorded = 0;
1995 dprintf_mmsys(stddeb, "waveInAddBuffer // lpData=%p size=%lu \n",
1996 lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength);
1997 return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
1998 (DWORD)lpWaveInHdr, uSize);
1999 }
2000
2001
2002 /**************************************************************************
2003 * waveInStart [MMSYSTEM.509]
2004 */
2005 UINT16 waveInStart(HWAVEIN16 hWaveIn)
2006 {
2007 LPWAVEOPENDESC lpDesc;
2008
2009 dprintf_mmsys(stddeb, "waveInStart(%04X)\n", hWaveIn);
2010 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2011 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2012 return widMessage(lpDesc->uDeviceID, WIDM_START, lpDesc->dwInstance, 0L, 0L);
2013 }
2014
2015
2016 /**************************************************************************
2017 * waveInStop [MMSYSTEM.510]
2018 */
2019 UINT16 waveInStop(HWAVEIN16 hWaveIn)
2020 {
2021 LPWAVEOPENDESC lpDesc;
2022
2023 dprintf_mmsys(stddeb, "waveInStop(%04X)\n", hWaveIn);
2024 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2025 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2026 return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
2027 }
2028
2029
2030 /**************************************************************************
2031 * waveInReset [MMSYSTEM.511]
2032 */
2033 UINT16 waveInReset(HWAVEIN16 hWaveIn)
2034 {
2035 LPWAVEOPENDESC lpDesc;
2036
2037 dprintf_mmsys(stddeb, "waveInReset(%04X)\n", hWaveIn);
2038 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2039 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2040 return widMessage(lpDesc->uDeviceID, WIDM_RESET, lpDesc->dwInstance, 0L, 0L);
2041 }
2042
2043
2044 /**************************************************************************
2045 * waveInGetPosition [MMSYSTEM.512]
2046 */
2047 UINT16 waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpTime, UINT16 uSize)
2048 {
2049 LPWAVEOPENDESC lpDesc;
2050
2051 dprintf_mmsys(stddeb, "waveInGetPosition(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
2052 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2053 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2054 return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance,
2055 (DWORD)lpTime, (DWORD)uSize);
2056 }
2057
2058
2059 /**************************************************************************
2060 * waveInGetID [MMSYSTEM.513]
2061 */
2062 UINT16 waveInGetID(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID)
2063 {
2064 LPWAVEOPENDESC lpDesc;
2065
2066 dprintf_mmsys(stddeb, "waveInGetID\n");
2067 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
2068 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2069 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2070 *lpuDeviceID = lpDesc->uDeviceID;
2071 return 0;
2072 }
2073
2074
2075 /**************************************************************************
2076 * waveInMessage [MMSYSTEM.514]
2077 */
2078 DWORD waveInMessage(HWAVEIN16 hWaveIn, UINT16 uMessage,
2079 DWORD dwParam1, DWORD dwParam2)
2080 {
2081 LPWAVEOPENDESC lpDesc;
2082
2083 dprintf_mmsys(stddeb, "waveInMessage(%04X, %04X, %08lX, %08lX)\n",
2084 hWaveIn, uMessage, dwParam1, dwParam2);
2085 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
2086 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2087 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2088 }
2089
2090
2091 /**************************************************************************
2092 * mmioOpen [MMSYSTEM.1210]
2093 */
2094 HMMIO16 mmioOpen(LPSTR szFileName, MMIOINFO * lpmmioinfo, DWORD dwOpenFlags)
2095 {
2096 HFILE32 hFile;
2097 HMMIO16 hmmio;
2098 OFSTRUCT ofs;
2099 LPMMIOINFO lpmminfo;
2100 dprintf_mmio(stddeb, "mmioOpen('%s', %p, %08lX);\n", szFileName, lpmmioinfo, dwOpenFlags);
2101 if (!szFileName)
2102 {
2103 /* FIXME: should load memory file if szFileName == NULL */
2104 fprintf(stderr, "WARNING: mmioOpen(): szFileName == NULL (memory file ???)\n");
2105 return 0;
2106 }
2107 hFile = OpenFile32(szFileName, &ofs, dwOpenFlags);
2108 if (hFile == -1) return 0;
2109 hmmio = GlobalAlloc16(GMEM_MOVEABLE, sizeof(MMIOINFO));
2110 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2111 if (lpmminfo == NULL) return 0;
2112 memset(lpmminfo, 0, sizeof(MMIOINFO));
2113 lpmminfo->hmmio = hmmio;
2114 lpmminfo->dwReserved2 = hFile;
2115 GlobalUnlock16(hmmio);
2116 dprintf_mmio(stddeb, "mmioOpen // return hmmio=%04X\n", hmmio);
2117 return hmmio;
2118 }
2119
2120
2121 /**************************************************************************
2122 * mmioClose [MMSYSTEM.1211]
2123 */
2124 UINT16 mmioClose(HMMIO16 hmmio, UINT16 uFlags)
2125 {
2126 LPMMIOINFO lpmminfo;
2127 dprintf_mmio(stddeb, "mmioClose(%04X, %04X);\n", hmmio, uFlags);
2128 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2129 if (lpmminfo == NULL) return 0;
2130 _lclose32((HFILE32)lpmminfo->dwReserved2);
2131 GlobalUnlock16(hmmio);
2132 GlobalFree16(hmmio);
2133 return 0;
2134 }
2135
2136
2137
2138 /**************************************************************************
2139 * mmioRead [MMSYSTEM.1212]
2140 */
2141 LONG mmioRead(HMMIO16 hmmio, HPSTR pch, LONG cch)
2142 {
2143 LONG count;
2144 LPMMIOINFO lpmminfo;
2145 dprintf_mmio(stddeb, "mmioRead(%04X, %p, %ld);\n", hmmio, pch, cch);
2146 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2147 if (lpmminfo == NULL) return 0;
2148 count = _lread32(LOWORD(lpmminfo->dwReserved2), pch, cch);
2149 GlobalUnlock16(hmmio);
2150 dprintf_mmio(stddeb, "mmioRead // count=%ld\n", count);
2151 return count;
2152 }
2153
2154
2155
2156 /**************************************************************************
2157 * mmioWrite [MMSYSTEM.1213]
2158 */
2159 LONG mmioWrite(HMMIO16 hmmio, HPCSTR pch, LONG cch)
2160 {
2161 LONG count;
2162 LPMMIOINFO lpmminfo;
2163 dprintf_mmio(stddeb, "mmioWrite(%04X, %p, %ld);\n", hmmio, pch, cch);
2164 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2165 if (lpmminfo == NULL) return 0;
2166 count = _lwrite32(LOWORD(lpmminfo->dwReserved2), (LPSTR)pch, cch);
2167 GlobalUnlock16(hmmio);
2168 return count;
2169 }
2170
2171 /**************************************************************************
2172 * mmioSeek [MMSYSTEM.1214]
2173 */
2174 LONG mmioSeek(HMMIO16 hmmio, LONG lOffset, int iOrigin)
2175 {
2176 int count;
2177 LPMMIOINFO lpmminfo;
2178 dprintf_mmio(stddeb, "mmioSeek(%04X, %08lX, %d);\n", hmmio, lOffset, iOrigin);
2179 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2180 if (lpmminfo == NULL) {
2181 dprintf_mmio(stddeb, "mmioSeek // can't lock hmmio=%04X !\n", hmmio);
2182 return 0;
2183 }
2184 count = _llseek32((HFILE32)lpmminfo->dwReserved2, lOffset, iOrigin);
2185 GlobalUnlock16(hmmio);
2186 return count;
2187 }
2188
2189 /**************************************************************************
2190 * mmioGetInfo [MMSYSTEM.1215]
2191 */
2192 UINT16 mmioGetInfo(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags)
2193 {
2194 LPMMIOINFO lpmminfo;
2195 dprintf_mmio(stddeb, "mmioGetInfo\n");
2196 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2197 if (lpmminfo == NULL) return 0;
2198 memcpy(lpmmioinfo, lpmminfo, sizeof(MMIOINFO));
2199 GlobalUnlock16(hmmio);
2200 return 0;
2201 }
2202
2203 /**************************************************************************
2204 * mmioSetInfo [MMSYSTEM.1216]
2205 */
2206 UINT16 mmioSetInfo(HMMIO16 hmmio, const MMIOINFO * lpmmioinfo, UINT16 uFlags)
2207 {
2208 LPMMIOINFO lpmminfo;
2209 dprintf_mmio(stddeb, "mmioSetInfo\n");
2210 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2211 if (lpmminfo == NULL) return 0;
2212 GlobalUnlock16(hmmio);
2213 return 0;
2214 }
2215
2216 /**************************************************************************
2217 * mmioSetBuffer [MMSYSTEM.1217]
2218 */
2219 UINT16 mmioSetBuffer(HMMIO16 hmmio, LPSTR pchBuffer,
2220 LONG cchBuffer, UINT16 uFlags)
2221 {
2222 dprintf_mmio(stddeb, "mmioSetBuffer // empty stub \n");
2223 return 0;
2224 }
2225
2226 /**************************************************************************
2227 * mmioFlush [MMSYSTEM.1218]
2228 */
2229 UINT16 mmioFlush(HMMIO16 hmmio, UINT16 uFlags)
2230 {
2231 LPMMIOINFO lpmminfo;
2232 dprintf_mmio(stddeb, "mmioFlush(%04X, %04X)\n", hmmio, uFlags);
2233 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2234 if (lpmminfo == NULL) return 0;
2235 GlobalUnlock16(hmmio);
2236 return 0;
2237 }
2238
2239 /**************************************************************************
2240 * mmioAdvance [MMSYSTEM.1219]
2241 */
2242 UINT16 mmioAdvance(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags)
2243 {
2244 int count = 0;
2245 LPMMIOINFO lpmminfo;
2246 dprintf_mmio(stddeb, "mmioAdvance\n");
2247 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2248 if (lpmminfo == NULL) return 0;
2249 if (uFlags == MMIO_READ) {
2250 count = _lread32(LOWORD(lpmminfo->dwReserved2),
2251 lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer);
2252 }
2253 if (uFlags == MMIO_WRITE) {
2254 count = _lwrite32(LOWORD(lpmminfo->dwReserved2),
2255 lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer);
2256 }
2257 lpmmioinfo->pchNext += count;
2258 GlobalUnlock16(hmmio);
2259 lpmminfo->lDiskOffset = _llseek32((HFILE32)lpmminfo->dwReserved2, 0, SEEK_CUR);
2260 return 0;
2261 }
2262
2263 /**************************************************************************
2264 * mmioStringToFOURCC [MMSYSTEM.1220]
2265 */
2266 FOURCC mmioStringToFOURCC(LPCSTR sz, UINT16 uFlags)
2267 {
2268 dprintf_mmio(stddeb, "mmioStringToFOURCC // empty stub \n");
2269 return 0;
2270 }
2271
2272 /**************************************************************************
2273 * mmioInstallIOProc [MMSYSTEM.1221]
2274 */
2275 LPMMIOPROC mmioInstallIOProc(FOURCC fccIOProc,
2276 LPMMIOPROC pIOProc, DWORD dwFlags)
2277 {
2278 dprintf_mmio(stddeb, "mmioInstallIOProc // empty stub \n");
2279 return 0;
2280 }
2281
2282 /**************************************************************************
2283 * mmioSendMessage [MMSYSTEM.1222]
2284 */
2285 LRESULT mmioSendMessage(HMMIO16 hmmio, UINT16 uMessage,
2286 LPARAM lParam1, LPARAM lParam2)
2287 {
2288 dprintf_mmio(stddeb, "mmioSendMessage // empty stub \n");
2289 return 0;
2290 }
2291
2292 /**************************************************************************
2293 * mmioDescend [MMSYSTEM.1223]
2294 */
2295 UINT16 mmioDescend(HMMIO16 hmmio, MMCKINFO * lpck,
2296 const MMCKINFO * lpckParent, UINT16 uFlags)
2297 {
2298 DWORD dwfcc, dwOldPos;
2299 LPMMIOINFO lpmminfo;
2300 dprintf_mmio(stddeb, "mmioDescend(%04X, %p, %p, %04X);\n",
2301 hmmio, lpck, lpckParent, uFlags);
2302 if (lpck == NULL) return 0;
2303 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2304 if (lpmminfo == NULL) return 0;
2305 dwfcc = lpck->ckid;
2306 dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX\n", dwfcc);
2307 dprintf_mmio(stddeb, "mmioDescend // hfile = %ld\n", lpmminfo->dwReserved2);
2308 dwOldPos = _llseek32((HFILE32)lpmminfo->dwReserved2, 0, SEEK_CUR);
2309 dprintf_mmio(stddeb, "mmioDescend // dwOldPos=%ld\n", dwOldPos);
2310 if (lpckParent != NULL) {
2311 dprintf_mmio(stddeb, "mmioDescend // seek inside parent at %ld !\n", lpckParent->dwDataOffset);
2312 dwOldPos = _llseek32((HFILE32)lpmminfo->dwReserved2,
2313 lpckParent->dwDataOffset, SEEK_SET);
2314 }
2315 /*
2316
2317 It seems to be that FINDRIFF should not be treated the same as the
2318 other FINDxxx so I treat it as a MMIO_FINDxxx
2319
2320 if ((uFlags & MMIO_FINDCHUNK) || (uFlags & MMIO_FINDRIFF) ||
2321 (uFlags & MMIO_FINDLIST)) {
2322 */
2323 if ((uFlags & MMIO_FINDCHUNK) || (uFlags & MMIO_FINDLIST)) {
2324 dprintf_mmio(stddeb, "mmioDescend // MMIO_FINDxxxx dwfcc=%08lX !\n", dwfcc);
2325 while (TRUE) {
2326 size_t ix;
2327
2328 ix =_lread32((HFILE32)lpmminfo->dwReserved2, (LPSTR)lpck, sizeof(MMCKINFO));
2329 dprintf_mmio(stddeb, "mmioDescend // after _lread32 ix = %d req = %d, errno = %d\n",ix,sizeof(MMCKINFO),errno);
2330 if (ix < sizeof(MMCKINFO)) {
2331
2332 _llseek32((HFILE32)lpmminfo->dwReserved2, dwOldPos, SEEK_SET);
2333 GlobalUnlock16(hmmio);
2334 dprintf_mmio(stddeb, "mmioDescend // return ChunkNotFound\n");
2335 return MMIOERR_CHUNKNOTFOUND;
2336 }
2337 dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX ckid=%08lX cksize=%08lX !\n",
2338 dwfcc, lpck->ckid, lpck->cksize);
2339 if (dwfcc == lpck->ckid) break;
2340 dwOldPos += lpck->cksize + 2 * sizeof(DWORD);
2341 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
2342 dwOldPos += sizeof(DWORD);
2343 _llseek32((HFILE32)lpmminfo->dwReserved2, dwOldPos, SEEK_SET);
2344 }
2345 }
2346 else {
2347 if (_lread32(LOWORD(lpmminfo->dwReserved2), (LPSTR)lpck,
2348 sizeof(MMCKINFO)) < sizeof(MMCKINFO)) {
2349 _llseek32((HFILE32)lpmminfo->dwReserved2, dwOldPos, SEEK_SET);
2350 GlobalUnlock16(hmmio);
2351 dprintf_mmio(stddeb, "mmioDescend // return ChunkNotFound 2nd\n");
2352 return MMIOERR_CHUNKNOTFOUND;
2353 }
2354 }
2355 lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
2356 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
2357 lpck->dwDataOffset += sizeof(DWORD);
2358 lpmminfo->lDiskOffset = _llseek32((HFILE32)lpmminfo->dwReserved2,
2359 lpck->dwDataOffset, SEEK_SET);
2360 GlobalUnlock16(hmmio);
2361 dprintf_mmio(stddeb, "mmioDescend // lpck->ckid=%08lX lpck->cksize=%ld !\n",
2362 lpck->ckid, lpck->cksize);
2363 dprintf_mmio(stddeb, "mmioDescend // lpck->fccType=%08lX !\n", lpck->fccType);
2364 return 0;
2365 }
2366
2367 /**************************************************************************
2368 * mmioAscend [MMSYSTEM.1224]
2369 */
2370 UINT16 mmioAscend(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags)
2371 {
2372 dprintf_mmio(stddeb, "mmioAscend // empty stub !\n");
2373 return 0;
2374 }
2375
2376 /**************************************************************************
2377 * mmioCreateChunk [MMSYSTEM.1225]
2378 */
2379 UINT16 mmioCreateChunk(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags)
2380 {
2381 dprintf_mmio(stddeb, "mmioCreateChunk // empty stub \n");
2382 return 0;
2383 }
2384
2385
2386 /**************************************************************************
2387 * mmioRename [MMSYSTEM.1226]
2388 */
2389 UINT16 mmioRename(LPCSTR szFileName, LPCSTR szNewFileName,
2390 MMIOINFO * lpmmioinfo, DWORD dwRenameFlags)
2391 {
2392 dprintf_mmio(stddeb, "mmioRename('%s', '%s', %p, %08lX); // empty stub \n",
2393 szFileName, szNewFileName, lpmmioinfo, dwRenameFlags);
2394 return 0;
2395 }
2396
2397 /**************************************************************************
2398 * DrvOpen [MMSYSTEM.1100]
2399 */
2400 HDRVR16 DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
2401 {
2402 dprintf_mmsys(stddeb, "DrvOpen('%s', '%s', %08lX);\n",
2403 lpDriverName, lpSectionName, lParam);
2404 return OpenDriver(lpDriverName, lpSectionName, lParam);
2405 }
2406
2407
2408 /**************************************************************************
2409 * DrvClose [MMSYSTEM.1101]
2410 */
2411 LRESULT DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
2412 {
2413 dprintf_mmsys(stddeb, "DrvClose(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
2414 return CloseDriver(hDrvr, lParam1, lParam2);
2415 }
2416
2417
2418 /**************************************************************************
2419 * DrvSendMessage [MMSYSTEM.1102]
2420 */
2421 LRESULT DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1, LPARAM lParam2)
2422 {
2423 DWORD dwDriverID = 0;
2424 dprintf_mmsys(stddeb, "DrvSendMessage(%04X, %04X, %08lX, %08lX);\n",
2425 hDriver, msg, lParam1, lParam2);
2426 return CDAUDIO_DriverProc(dwDriverID, hDriver, msg, lParam1, lParam2);
2427 }
2428
2429 /**************************************************************************
2430 * DrvGetModuleHandle [MMSYSTEM.1103]
2431 */
2432 HANDLE16 DrvGetModuleHandle(HDRVR16 hDrvr)
2433 {
2434 dprintf_mmsys(stddeb, "DrvGetModuleHandle(%04X);\n", hDrvr);
2435 return 0;
2436 }
2437
2438
2439 /**************************************************************************
2440 * DrvDefDriverProc [MMSYSTEM.1104]
2441 */
2442 LRESULT DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg,
2443 DWORD dwParam1, DWORD dwParam2)
2444 {
2445 return DefDriverProc(dwDriverID, hDriv, wMsg, dwParam1, dwParam2);
2446 }
Maarten's multimedia branch