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