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