?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 961013
[wine.git] / multimedia / mmsystem.c
blobc8a066a103b11f07b63275e7ab8d7d535fd5fcad
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 GetProfileString("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 GetProfileString("mci extensions",t+1,"*",str,sizeof(str));
590 AnsiUpper(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 AnsiUpper(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 GetPrivateProfileString("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 != NULL) {
833 strcpy(str, lpstrName);
834 AnsiUpper(str);
835 if (strcmp(str, "ALL") == 0) return MCI_ALL_DEVICE_ID;
836 }
837 return 0;
838 }
839
840 /**************************************************************************
841 * mciSetYieldProc [MMSYSTEM.714]
842 */
843 BOOL mciSetYieldProc (UINT uDeviceID,
844 YIELDPROC fpYieldProc, DWORD dwYieldData)
845 {
846 return FALSE;
847 }
848
849 /**************************************************************************
850 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
851 */
852 UINT mciGetDeviceIDFromElementID(DWORD dwElementID, LPCSTR lpstrType)
853 {
854 return 0;
855 }
856
857 /**************************************************************************
858 * mciGetYieldProc [MMSYSTEM.716]
859 */
860 YIELDPROC mciGetYieldProc(UINT uDeviceID, DWORD * lpdwYieldData)
861 {
862 return NULL;
863 }
864
865 /**************************************************************************
866 * mciGetCreatorTask [MMSYSTEM.717]
867 */
868 HTASK16 mciGetCreatorTask(UINT uDeviceID)
869 {
870 return 0;
871 }
872
873 /**************************************************************************
874 * midiOutGetNumDevs [MMSYSTEM.201]
875 */
876 UINT midiOutGetNumDevs(void)
877 {
878 UINT count = 0;
879 dprintf_mmsys(stddeb, "midiOutGetNumDevs\n");
880 count += modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
881 dprintf_mmsys(stddeb, "midiOutGetNumDevs return %u \n", count);
882 return count;
883 }
884
885 /**************************************************************************
886 * midiOutGetDevCaps [MMSYSTEM.202]
887 */
888 UINT midiOutGetDevCaps(UINT uDeviceID, MIDIOUTCAPS * lpCaps, UINT uSize)
889 {
890 dprintf_mmsys(stddeb, "midiOutGetDevCaps\n");
891 return 0;
892 }
893
894 /**************************************************************************
895 * midiOutGetErrorText [MMSYSTEM.203]
896 */
897 UINT midiOutGetErrorText(UINT uError, LPSTR lpText, UINT uSize)
898 {
899 dprintf_mmsys(stddeb, "midiOutGetErrorText\n");
900 return midiGetErrorText(uError, lpText, uSize);
901 }
902
903
904 /**************************************************************************
905 * midiGetErrorText [internal]
906 */
907 UINT midiGetErrorText(UINT uError, LPSTR lpText, UINT uSize)
908 {
909 LPSTR msgptr;
910 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
911 lpText[0] = '\0';
912 switch(uError) {
913 case MIDIERR_UNPREPARED:
914 msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
915 break;
916 case MIDIERR_STILLPLAYING:
917 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
918 break;
919 case MIDIERR_NOMAP:
920 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.";
921 break;
922 case MIDIERR_NOTREADY:
923 msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
924 break;
925 case MIDIERR_NODEVICE:
926 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.";
927 break;
928 case MIDIERR_INVALIDSETUP:
929 msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
930 break;
931 /*
932 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
933 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
934 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
935 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.
936 msg# 340 : An error occurred using the specified port.
937 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
938 msg# 342 : There is no current MIDI port.
939 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
940 */
941 default:
942 msgptr = "Unknown MIDI Error !\n";
943 break;
944 }
945 lstrcpyn32A(lpText, msgptr, uSize);
946 return TRUE;
947 }
948
949 /**************************************************************************
950 * midiOutOpen [MMSYSTEM.204]
951 */
952 UINT midiOutOpen(HMIDIOUT16 * lphMidiOut, UINT uDeviceID,
953 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
954 {
955 HMIDI16 hMidiOut;
956 LPMIDIOPENDESC lpDesc;
957 LPMIDIOPENDESC lp16Desc;
958 DWORD dwRet = 0;
959 BOOL bMapperFlg = FALSE;
960 if (lphMidiOut != NULL) *lphMidiOut = 0;
961 dprintf_mmsys(stddeb, "midiOutOpen(%p, %d, %08lX, %08lX, %08lX);\n",
962 lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
963 if (uDeviceID == (UINT)MIDI_MAPPER) {
964 dprintf_mmsys(stddeb, "midiOutOpen // MIDI_MAPPER mode requested !\n");
965 bMapperFlg = TRUE;
966 uDeviceID = 0;
967 }
968 hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
969 if (lphMidiOut != NULL) *lphMidiOut = hMidiOut;
970 lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiOut);
971 lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
972 if (lpDesc == NULL) return MMSYSERR_NOMEM;
973 lpDesc->hMidi = hMidiOut;
974 lpDesc->dwCallback = dwCallback;
975 lpDesc->dwInstance = dwInstance;
976 while(uDeviceID < MAXMIDIDRIVERS) {
977 dwRet = modMessage(uDeviceID, MODM_OPEN,
978 lpDesc->dwInstance, (DWORD)lp16Desc, 0L);
979 if (dwRet == MMSYSERR_NOERROR) break;
980 if (!bMapperFlg) break;
981 uDeviceID++;
982 dprintf_mmsys(stddeb, "midiOutOpen // MIDI_MAPPER mode ! try next driver...\n");
983 }
984 return dwRet;
985 }
986
987 /**************************************************************************
988 * midiOutClose [MMSYSTEM.205]
989 */
990 UINT midiOutClose(HMIDIOUT16 hMidiOut)
991 {
992 LPMIDIOPENDESC lpDesc;
993 dprintf_mmsys(stddeb, "midiOutClose(%04X)\n", hMidiOut);
994 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
995 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
996 return modMessage(0, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
997 }
998
999 /**************************************************************************
1000 * midiOutPrepareHeader [MMSYSTEM.206]
1001 */
1002 UINT midiOutPrepareHeader(HMIDIOUT16 hMidiOut,
1003 MIDIHDR * lpMidiOutHdr, UINT uSize)
1004 {
1005 LPMIDIOPENDESC lpDesc;
1006 dprintf_mmsys(stddeb, "midiOutPrepareHeader(%04X, %p, %d)\n",
1007 hMidiOut, lpMidiOutHdr, uSize);
1008 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1009 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1010 return modMessage(0, MODM_PREPARE, lpDesc->dwInstance,
1011 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1012 }
1013
1014 /**************************************************************************
1015 * midiOutUnprepareHeader [MMSYSTEM.207]
1016 */
1017 UINT midiOutUnprepareHeader(HMIDIOUT16 hMidiOut,
1018 MIDIHDR * lpMidiOutHdr, UINT uSize)
1019 {
1020 LPMIDIOPENDESC lpDesc;
1021 dprintf_mmsys(stddeb, "midiOutUnprepareHeader(%04X, %p, %d)\n",
1022 hMidiOut, lpMidiOutHdr, uSize);
1023 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1024 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1025 return modMessage(0, MODM_UNPREPARE, lpDesc->dwInstance,
1026 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1027 }
1028
1029 /**************************************************************************
1030 * midiOutShortMsg [MMSYSTEM.208]
1031 */
1032 UINT midiOutShortMsg(HMIDIOUT16 hMidiOut, DWORD dwMsg)
1033 {
1034 LPMIDIOPENDESC lpDesc;
1035 dprintf_mmsys(stddeb, "midiOutShortMsg(%04X, %08lX)\n", hMidiOut, dwMsg);
1036 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1037 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1038 return modMessage(0, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
1039 }
1040
1041 /**************************************************************************
1042 * midiOutLongMsg [MMSYSTEM.209]
1043 */
1044 UINT midiOutLongMsg(HMIDIOUT16 hMidiOut,
1045 MIDIHDR * lpMidiOutHdr, UINT uSize)
1046 {
1047 LPMIDIOPENDESC lpDesc;
1048 dprintf_mmsys(stddeb, "midiOutLongMsg(%04X, %p, %d)\n",
1049 hMidiOut, lpMidiOutHdr, uSize);
1050 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1051 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1052 return modMessage(0, MODM_LONGDATA, lpDesc->dwInstance,
1053 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1054 }
1055
1056 /**************************************************************************
1057 * midiOutReset [MMSYSTEM.210]
1058 */
1059 UINT midiOutReset(HMIDIOUT16 hMidiOut)
1060 {
1061 LPMIDIOPENDESC lpDesc;
1062 dprintf_mmsys(stddeb, "midiOutReset(%04X)\n", hMidiOut);
1063 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1064 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1065 return modMessage(0, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
1066 }
1067
1068 /**************************************************************************
1069 * midiOutGetVolume [MMSYSTEM.211]
1070 */
1071 UINT midiOutGetVolume(UINT uDeviceID, DWORD * lpdwVolume)
1072 {
1073 dprintf_mmsys(stddeb, "midiOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume);
1074 return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
1075 return 0;
1076 }
1077
1078 /**************************************************************************
1079 * midiOutSetVolume [MMSYSTEM.212]
1080 */
1081 UINT midiOutSetVolume(UINT uDeviceID, DWORD dwVolume)
1082 {
1083 dprintf_mmsys(stddeb, "midiOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume);
1084 return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
1085 return 0;
1086 }
1087
1088 /**************************************************************************
1089 * midiOutCachePatches [MMSYSTEM.213]
1090 */
1091 UINT midiOutCachePatches(HMIDIOUT16 hMidiOut,
1092 UINT uBank, WORD * lpwPatchArray, UINT uFlags)
1093 {
1094 /* not really necessary to support this */
1095 fprintf(stdnimp, "midiOutCachePatches: not supported yet\n");
1096 return MMSYSERR_NOTSUPPORTED;
1097 }
1098
1099 /**************************************************************************
1100 * midiOutCacheDrumPatches [MMSYSTEM.214]
1101 */
1102 UINT midiOutCacheDrumPatches(HMIDIOUT16 hMidiOut,
1103 UINT uPatch, WORD * lpwKeyArray, UINT uFlags)
1104 {
1105 fprintf(stdnimp, "midiOutCacheDrumPatchesi: not supported yet\n");
1106 return MMSYSERR_NOTSUPPORTED;
1107 }
1108
1109 /**************************************************************************
1110 * midiOutGetID [MMSYSTEM.215]
1111 */
1112 UINT midiOutGetID(HMIDIOUT16 hMidiOut, UINT * lpuDeviceID)
1113 {
1114 dprintf_mmsys(stddeb, "midiOutGetID\n");
1115 return 0;
1116 }
1117
1118 /**************************************************************************
1119 * midiOutMessage [MMSYSTEM.216]
1120 */
1121 DWORD midiOutMessage(HMIDIOUT16 hMidiOut, UINT uMessage,
1122 DWORD dwParam1, DWORD dwParam2)
1123 {
1124 LPMIDIOPENDESC lpDesc;
1125 dprintf_mmsys(stddeb, "midiOutMessage(%04X, %04X, %08lX, %08lX)\n",
1126 hMidiOut, uMessage, dwParam1, dwParam2);
1127 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1128 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1129 return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1130 return 0;
1131 }
1132
1133 /**************************************************************************
1134 * midiInGetNumDevs [MMSYSTEM.301]
1135 */
1136 UINT midiInGetNumDevs(void)
1137 {
1138 UINT count = 0;
1139 dprintf_mmsys(stddeb, "midiInGetNumDevs\n");
1140 count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
1141 dprintf_mmsys(stddeb, "midiInGetNumDevs return %u \n", count);
1142 return count;
1143 }
1144
1145 /**************************************************************************
1146 * midiInGetDevCaps [MMSYSTEM.302]
1147 */
1148 UINT midiInGetDevCaps(UINT uDeviceID,
1149 LPMIDIINCAPS lpCaps, UINT uSize)
1150 {
1151 dprintf_mmsys(stddeb, "midiInGetDevCaps\n");
1152 return 0;
1153 }
1154
1155 /**************************************************************************
1156 * midiInGetErrorText [MMSYSTEM.303]
1157 */
1158 UINT midiInGetErrorText(UINT uError, LPSTR lpText, UINT uSize)
1159 {
1160 dprintf_mmsys(stddeb, "midiInGetErrorText\n");
1161 return (midiGetErrorText(uError, lpText, uSize));
1162 }
1163
1164 /**************************************************************************
1165 * midiInOpen [MMSYSTEM.304]
1166 */
1167 UINT midiInOpen(HMIDIIN16 * lphMidiIn, UINT uDeviceID,
1168 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1169 {
1170 HMIDI16 hMidiIn;
1171 LPMIDIOPENDESC lpDesc;
1172 LPMIDIOPENDESC lp16Desc;
1173 DWORD dwRet = 0;
1174 BOOL bMapperFlg = FALSE;
1175 if (lphMidiIn != NULL) *lphMidiIn = 0;
1176 dprintf_mmsys(stddeb, "midiInOpen(%p, %d, %08lX, %08lX, %08lX);\n",
1177 lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
1178 if (uDeviceID == (UINT)MIDI_MAPPER) {
1179 dprintf_mmsys(stddeb, "midiInOpen // MIDI_MAPPER mode requested !\n");
1180 bMapperFlg = TRUE;
1181 uDeviceID = 0;
1182 }
1183 hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1184 if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
1185 lp16Desc = (LPMIDIOPENDESC) USER_HEAP_SEG_ADDR(hMidiIn);
1186 lpDesc = (LPMIDIOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1187 if (lpDesc == NULL) return MMSYSERR_NOMEM;
1188 lpDesc->hMidi = hMidiIn;
1189 lpDesc->dwCallback = dwCallback;
1190 lpDesc->dwInstance = dwInstance;
1191 while(uDeviceID < MAXMIDIDRIVERS) {
1192 dwRet = midMessage(uDeviceID, MIDM_OPEN,
1193 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
1194 if (dwRet == MMSYSERR_NOERROR) break;
1195 if (!bMapperFlg) break;
1196 uDeviceID++;
1197 dprintf_mmsys(stddeb, "midiInOpen // MIDI_MAPPER mode ! try next driver...\n");
1198 }
1199 return dwRet;
1200 }
1201
1202 /**************************************************************************
1203 * midiInClose [MMSYSTEM.305]
1204 */
1205 UINT midiInClose(HMIDIIN16 hMidiIn)
1206 {
1207 LPMIDIOPENDESC lpDesc;
1208 dprintf_mmsys(stddeb, "midiInClose(%04X)\n", hMidiIn);
1209 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1210 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1211 return midMessage(0, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1212 }
1213
1214 /**************************************************************************
1215 * midiInPrepareHeader [MMSYSTEM.306]
1216 */
1217 UINT midiInPrepareHeader(HMIDIIN16 hMidiIn,
1218 MIDIHDR * lpMidiInHdr, UINT uSize)
1219 {
1220 LPMIDIOPENDESC lpDesc;
1221 dprintf_mmsys(stddeb, "midiInPrepareHeader(%04X, %p, %d)\n",
1222 hMidiIn, lpMidiInHdr, uSize);
1223 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1224 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1225 return midMessage(0, MIDM_PREPARE, lpDesc->dwInstance,
1226 (DWORD)lpMidiInHdr, (DWORD)uSize);
1227 }
1228
1229 /**************************************************************************
1230 * midiInUnprepareHeader [MMSYSTEM.307]
1231 */
1232 UINT midiInUnprepareHeader(HMIDIIN16 hMidiIn,
1233 MIDIHDR * lpMidiInHdr, UINT uSize)
1234 {
1235 LPMIDIOPENDESC lpDesc;
1236 dprintf_mmsys(stddeb, "midiInUnprepareHeader(%04X, %p, %d)\n",
1237 hMidiIn, lpMidiInHdr, uSize);
1238 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1239 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1240 return midMessage(0, MIDM_UNPREPARE, lpDesc->dwInstance,
1241 (DWORD)lpMidiInHdr, (DWORD)uSize);
1242 }
1243
1244 /**************************************************************************
1245 * midiInAddBuffer [MMSYSTEM.308]
1246 */
1247 UINT midiInAddBuffer(HMIDIIN16 hMidiIn,
1248 MIDIHDR * lpMidiInHdr, UINT uSize)
1249 {
1250 dprintf_mmsys(stddeb, "midiInAddBuffer\n");
1251 return 0;
1252 }
1253
1254 /**************************************************************************
1255 * midiInStart [MMSYSTEM.309]
1256 */
1257 UINT midiInStart(HMIDIIN16 hMidiIn)
1258 {
1259 dprintf_mmsys(stddeb, "midiInStart\n");
1260 return 0;
1261 }
1262
1263 /**************************************************************************
1264 * midiInStop [MMSYSTEM.310]
1265 */
1266 UINT midiInStop(HMIDIIN16 hMidiIn)
1267 {
1268 dprintf_mmsys(stddeb, "midiInStop\n");
1269 return 0;
1270 }
1271
1272 /**************************************************************************
1273 * midiInReset [MMSYSTEM.311]
1274 */
1275 UINT midiInReset(HMIDIIN16 hMidiIn)
1276 {
1277 dprintf_mmsys(stddeb, "midiInReset\n");
1278 return 0;
1279 }
1280
1281 /**************************************************************************
1282 * midiInGetID [MMSYSTEM.312]
1283 */
1284 UINT midiInGetID(HMIDIIN16 hMidiIn, UINT * lpuDeviceID)
1285 {
1286 dprintf_mmsys(stddeb, "midiInGetID\n");
1287 return 0;
1288 }
1289
1290 /**************************************************************************
1291 * midiInMessage [MMSYSTEM.313]
1292 */
1293 DWORD midiInMessage(HMIDIIN16 hMidiIn, UINT uMessage,
1294 DWORD dwParam1, DWORD dwParam2)
1295 {
1296 LPMIDIOPENDESC lpDesc;
1297 dprintf_mmsys(stddeb, "midiInMessage(%04X, %04X, %08lX, %08lX)\n",
1298 hMidiIn, uMessage, dwParam1, dwParam2);
1299 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
1300 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1301 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1302 }
1303
1304
1305 /**************************************************************************
1306 * waveOutGetNumDevs [MMSYSTEM.401]
1307 */
1308 UINT waveOutGetNumDevs()
1309 {
1310 UINT count = 0;
1311 dprintf_mmsys(stddeb, "waveOutGetNumDevs\n");
1312 count += wodMessage(0, WODM_GETNUMDEVS, 0L, 0L, 0L);
1313 dprintf_mmsys(stddeb, "waveOutGetNumDevs return %u \n", count);
1314 return count;
1315 }
1316
1317 /**************************************************************************
1318 * waveOutGetDevCaps [MMSYSTEM.402]
1319 */
1320 UINT waveOutGetDevCaps(UINT uDeviceID, WAVEOUTCAPS * lpCaps, UINT uSize)
1321 {
1322 dprintf_mmsys(stddeb, "waveOutGetDevCaps\n");
1323 return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
1324 }
1325
1326 /**************************************************************************
1327 * waveOutGetErrorText [MMSYSTEM.403]
1328 */
1329 UINT waveOutGetErrorText(UINT uError, LPSTR lpText, UINT uSize)
1330 {
1331 dprintf_mmsys(stddeb, "waveOutGetErrorText\n");
1332 return(waveGetErrorText(uError, lpText, uSize));
1333 }
1334
1335
1336 /**************************************************************************
1337 * waveGetErrorText [internal]
1338 */
1339 UINT waveGetErrorText(UINT uError, LPSTR lpText, UINT uSize)
1340 {
1341 LPSTR msgptr;
1342 dprintf_mmsys(stddeb, "waveGetErrorText(%04X, %p, %d);\n", uError, lpText, uSize);
1343 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1344 lpText[0] = '\0';
1345 switch(uError) {
1346 case MMSYSERR_NOERROR:
1347 msgptr = "The specified command was carried out.";
1348 break;
1349 case MMSYSERR_ERROR:
1350 msgptr = "Undefined external error.";
1351 break;
1352 case MMSYSERR_BADDEVICEID:
1353 msgptr = "A device ID has been used that is out of range for your system.";
1354 break;
1355 case MMSYSERR_NOTENABLED:
1356 msgptr = "The driver was not enabled.";
1357 break;
1358 case MMSYSERR_ALLOCATED:
1359 msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
1360 break;
1361 case MMSYSERR_INVALHANDLE:
1362 msgptr = "The specified device handle is invalid.";
1363 break;
1364 case MMSYSERR_NODRIVER:
1365 msgptr = "There is no driver installed on your system !\n";
1366 break;
1367 case MMSYSERR_NOMEM:
1368 msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
1369 break;
1370 case MMSYSERR_NOTSUPPORTED:
1371 msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
1372 break;
1373 case MMSYSERR_BADERRNUM:
1374 msgptr = "An error number was specified that is not defined in the system.";
1375 break;
1376 case MMSYSERR_INVALFLAG:
1377 msgptr = "An invalid flag was passed to a system function.";
1378 break;
1379 case MMSYSERR_INVALPARAM:
1380 msgptr = "An invalid parameter was passed to a system function.";
1381 break;
1382 case WAVERR_BADFORMAT:
1383 msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
1384 break;
1385 case WAVERR_STILLPLAYING:
1386 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1387 break;
1388 case WAVERR_UNPREPARED:
1389 msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1390 break;
1391 case WAVERR_SYNC:
1392 msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
1393 break;
1394 default:
1395 msgptr = "Unknown MMSYSTEM Error !\n";
1396 break;
1397 }
1398 lstrcpyn32A(lpText, msgptr, uSize);
1399 return TRUE;
1400 }
1401
1402 /**************************************************************************
1403 * waveOutOpen [MMSYSTEM.404]
1404 */
1405 UINT waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT uDeviceID,
1406 const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1407 {
1408 HWAVEOUT16 hWaveOut;
1409 LPWAVEOPENDESC lpDesc;
1410 LPWAVEOPENDESC lp16Desc;
1411 DWORD dwRet = 0;
1412 BOOL bMapperFlg = FALSE;
1413 dprintf_mmsys(stddeb, "waveOutOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
1414 lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
1415 if (dwFlags & WAVE_FORMAT_QUERY) {
1416 dprintf_mmsys(stddeb, "waveOutOpen // WAVE_FORMAT_QUERY requested !\n");
1417 }
1418 if (uDeviceID == (UINT)WAVE_MAPPER) {
1419 dprintf_mmsys(stddeb, "waveOutOpen // WAVE_MAPPER mode requested !\n");
1420 bMapperFlg = TRUE;
1421 uDeviceID = 0;
1422 }
1423 if (lpFormat == NULL) return WAVERR_BADFORMAT;
1424 hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
1425 if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
1426 lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveOut);
1427 lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1428 if (lpDesc == NULL) return MMSYSERR_NOMEM;
1429 lpDesc->hWave = hWaveOut;
1430 lpDesc->lpFormat = lpFormat;
1431 lpDesc->dwCallBack = dwCallback;
1432 lpDesc->dwInstance = dwInstance;
1433 while(uDeviceID < MAXWAVEDRIVERS) {
1434 dwRet = wodMessage(uDeviceID, WODM_OPEN,
1435 lpDesc->dwInstance, (DWORD)lp16Desc, 0L);
1436 if (dwRet == MMSYSERR_NOERROR) break;
1437 if (!bMapperFlg) break;
1438 uDeviceID++;
1439 dprintf_mmsys(stddeb, "waveOutOpen // WAVE_MAPPER mode ! try next driver...\n");
1440 }
1441 if (dwFlags & WAVE_FORMAT_QUERY) {
1442 dprintf_mmsys(stddeb, "waveOutOpen // End of WAVE_FORMAT_QUERY !\n");
1443 waveOutClose(hWaveOut);
1444 }
1445 return dwRet;
1446 }
1447
1448 /**************************************************************************
1449 * waveOutClose [MMSYSTEM.405]
1450 */
1451 UINT waveOutClose(HWAVEOUT16 hWaveOut)
1452 {
1453 LPWAVEOPENDESC lpDesc;
1454 dprintf_mmsys(stddeb, "waveOutClose(%04X)\n", hWaveOut);
1455 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1456 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1457 return wodMessage(0, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1458 }
1459
1460 /**************************************************************************
1461 * waveOutPrepareHeader [MMSYSTEM.406]
1462 */
1463 UINT waveOutPrepareHeader(HWAVEOUT16 hWaveOut,
1464 WAVEHDR * lpWaveOutHdr, UINT uSize)
1465 {
1466 LPWAVEOPENDESC lpDesc;
1467 dprintf_mmsys(stddeb, "waveOutPrepareHeader(%04X, %p, %u);\n",
1468 hWaveOut, lpWaveOutHdr, uSize);
1469 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1470 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1471 return wodMessage(0, WODM_PREPARE, lpDesc->dwInstance,
1472 (DWORD)lpWaveOutHdr, uSize);
1473 }
1474
1475 /**************************************************************************
1476 * waveOutUnprepareHeader [MMSYSTEM.407]
1477 */
1478 UINT waveOutUnprepareHeader(HWAVEOUT16 hWaveOut,
1479 WAVEHDR * lpWaveOutHdr, UINT uSize)
1480 {
1481 LPWAVEOPENDESC lpDesc;
1482 dprintf_mmsys(stddeb, "waveOutUnprepareHeader(%04X, %p, %u);\n",
1483 hWaveOut, lpWaveOutHdr, uSize);
1484 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1485 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1486 return wodMessage(0, WODM_UNPREPARE, lpDesc->dwInstance,
1487 (DWORD)lpWaveOutHdr, uSize);
1488 }
1489
1490 /**************************************************************************
1491 * waveOutWrite [MMSYSTEM.408]
1492 */
1493 UINT waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, UINT uSize)
1494 {
1495 LPWAVEOPENDESC lpDesc;
1496 dprintf_mmsys(stddeb, "waveOutWrite(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
1497 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1498 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1499 return wodMessage(0, WODM_WRITE, lpDesc->dwInstance,
1500 (DWORD)lpWaveOutHdr, uSize);
1501 }
1502
1503 /**************************************************************************
1504 * waveOutPause [MMSYSTEM.409]
1505 */
1506 UINT waveOutPause(HWAVEOUT16 hWaveOut)
1507 {
1508 LPWAVEOPENDESC lpDesc;
1509 dprintf_mmsys(stddeb, "waveOutPause(%04X)\n", hWaveOut);
1510 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1511 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1512 return wodMessage(0, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
1513 }
1514
1515 /**************************************************************************
1516 * waveOutRestart [MMSYSTEM.410]
1517 */
1518 UINT waveOutRestart(HWAVEOUT16 hWaveOut)
1519 {
1520 LPWAVEOPENDESC lpDesc;
1521 dprintf_mmsys(stddeb, "waveOutRestart(%04X)\n", hWaveOut);
1522 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1523 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1524 return wodMessage(0, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
1525 }
1526
1527 /**************************************************************************
1528 * waveOutReset [MMSYSTEM.411]
1529 */
1530 UINT waveOutReset(HWAVEOUT16 hWaveOut)
1531 {
1532 LPWAVEOPENDESC lpDesc;
1533 dprintf_mmsys(stddeb, "waveOutReset(%04X)\n", hWaveOut);
1534 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1535 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1536 return wodMessage(0, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
1537 }
1538
1539 /**************************************************************************
1540 * waveOutGetPosition [MMSYSTEM.412]
1541 */
1542 UINT waveOutGetPosition(HWAVEOUT16 hWaveOut, MMTIME * lpTime, UINT uSize)
1543 {
1544 LPWAVEOPENDESC lpDesc;
1545 dprintf_mmsys(stddeb, "waveOutGetPosition(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
1546 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1547 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1548 return wodMessage(0, WODM_GETPOS, lpDesc->dwInstance,
1549 (DWORD)lpTime, (DWORD)uSize);
1550 }
1551
1552 /**************************************************************************
1553 * waveOutGetPitch [MMSYSTEM.413]
1554 */
1555 UINT waveOutGetPitch(HWAVEOUT16 hWaveOut, DWORD * lpdwPitch)
1556 {
1557 LPWAVEOPENDESC lpDesc;
1558 dprintf_mmsys(stddeb, "waveOutGetPitch(%04X, %p);\n", hWaveOut, lpdwPitch);
1559 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1560 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1561 return wodMessage(0, WODM_GETPITCH, lpDesc->dwInstance,
1562 (DWORD)lpdwPitch, 0L);
1563 }
1564
1565 /**************************************************************************
1566 * waveOutSetPitch [MMSYSTEM.414]
1567 */
1568 UINT waveOutSetPitch(HWAVEOUT16 hWaveOut, DWORD dwPitch)
1569 {
1570 LPWAVEOPENDESC lpDesc;
1571 dprintf_mmsys(stddeb, "waveOutSetPitch(%04X, %08lX);\n", hWaveOut, dwPitch);
1572 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1573 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1574 return wodMessage(0, WODM_SETPITCH, lpDesc->dwInstance, (DWORD)dwPitch, 0L);
1575 }
1576
1577 /**************************************************************************
1578 * waveOutGetVolume [MMSYSTEM.415]
1579 */
1580 UINT waveOutGetVolume(UINT uDeviceID, DWORD * lpdwVolume)
1581 {
1582 dprintf_mmsys(stddeb, "waveOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume);
1583 return wodMessage(uDeviceID, WODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
1584 }
1585
1586 /**************************************************************************
1587 * waveOutSetVolume [MMSYSTEM.416]
1588 */
1589 UINT waveOutSetVolume(UINT uDeviceID, DWORD dwVolume)
1590 {
1591 dprintf_mmsys(stddeb, "waveOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume);
1592 return wodMessage(uDeviceID, WODM_SETVOLUME, 0L, dwVolume, 0L);
1593 }
1594
1595 /**************************************************************************
1596 * waveOutGetPlaybackRate [MMSYSTEM.417]
1597 */
1598 UINT waveOutGetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD * lpdwRate)
1599 {
1600 LPWAVEOPENDESC lpDesc;
1601 dprintf_mmsys(stddeb, "waveOutGetPlaybackRate(%04X, %p);\n", hWaveOut, lpdwRate);
1602 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1603 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1604 return wodMessage(0, WODM_GETPLAYBACKRATE, lpDesc->dwInstance,
1605 (DWORD)lpdwRate, 0L);
1606 }
1607
1608 /**************************************************************************
1609 * waveOutSetPlaybackRate [MMSYSTEM.418]
1610 */
1611 UINT waveOutSetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD dwRate)
1612 {
1613 LPWAVEOPENDESC lpDesc;
1614 dprintf_mmsys(stddeb, "waveOutSetPlaybackRate(%04X, %08lX);\n", hWaveOut, dwRate);
1615 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1616 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1617 return wodMessage(0, WODM_SETPLAYBACKRATE,
1618 lpDesc->dwInstance, (DWORD)dwRate, 0L);
1619 }
1620
1621 /**************************************************************************
1622 * waveOutBreakLoop [MMSYSTEM.419]
1623 */
1624 UINT waveOutBreakLoop(HWAVEOUT16 hWaveOut)
1625 {
1626 dprintf_mmsys(stddeb, "waveOutBreakLoop(%04X)\n", hWaveOut);
1627 return MMSYSERR_INVALHANDLE;
1628 }
1629
1630 /**************************************************************************
1631 * waveOutGetID [MMSYSTEM.420]
1632 */
1633 UINT waveOutGetID(HWAVEOUT16 hWaveOut, UINT * lpuDeviceID)
1634 {
1635 LPWAVEOPENDESC lpDesc;
1636 dprintf_mmsys(stddeb, "waveOutGetID(%04X, %p);\n", hWaveOut, lpuDeviceID);
1637 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1638 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1639 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
1640 /*
1641 *lpuDeviceID = lpParms->wDeviceID;
1642 */
1643 return 0;
1644 }
1645
1646 /**************************************************************************
1647 * waveOutMessage [MMSYSTEM.421]
1648 */
1649 DWORD waveOutMessage(HWAVEOUT16 hWaveOut, UINT uMessage,
1650 DWORD dwParam1, DWORD dwParam2)
1651 {
1652 LPWAVEOPENDESC lpDesc;
1653 dprintf_mmsys(stddeb, "waveOutMessage(%04X, %04X, %08lX, %08lX)\n",
1654 hWaveOut, uMessage, dwParam1, dwParam2);
1655 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
1656 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1657 return wodMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1658 }
1659
1660 /**************************************************************************
1661 * waveInGetNumDevs [MMSYSTEM.501]
1662 */
1663 UINT waveInGetNumDevs()
1664 {
1665 UINT count = 0;
1666 dprintf_mmsys(stddeb, "waveInGetNumDevs\n");
1667 count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
1668 dprintf_mmsys(stddeb, "waveInGetNumDevs return %u \n", count);
1669 return count;
1670 }
1671
1672
1673 /**************************************************************************
1674 * waveInGetDevCaps [MMSYSTEM.502]
1675 */
1676 UINT waveInGetDevCaps(UINT uDeviceID, WAVEINCAPS * lpCaps, UINT uSize)
1677 {
1678 dprintf_mmsys(stddeb, "waveInGetDevCaps\n");
1679 return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
1680 }
1681
1682
1683 /**************************************************************************
1684 * waveInGetErrorText [MMSYSTEM.503]
1685 */
1686 UINT waveInGetErrorText(UINT uError, LPSTR lpText, UINT uSize)
1687 {
1688 dprintf_mmsys(stddeb, "waveInGetErrorText\n");
1689 return(waveGetErrorText(uError, lpText, uSize));
1690 }
1691
1692
1693 /**************************************************************************
1694 * waveInOpen [MMSYSTEM.504]
1695 */
1696 UINT waveInOpen(HWAVEIN16 * lphWaveIn, UINT uDeviceID,
1697 const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1698 {
1699 HWAVEIN16 hWaveIn;
1700 LPWAVEOPENDESC lpDesc;
1701 LPWAVEOPENDESC lp16Desc;
1702 DWORD dwRet = 0;
1703 BOOL bMapperFlg = FALSE;
1704 dprintf_mmsys(stddeb, "waveInOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
1705 lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
1706 if (dwFlags & WAVE_FORMAT_QUERY) {
1707 dprintf_mmsys(stddeb, "waveInOpen // WAVE_FORMAT_QUERY requested !\n");
1708 }
1709 if (uDeviceID == (UINT)WAVE_MAPPER) {
1710 dprintf_mmsys(stddeb, "waveInOpen // WAVE_MAPPER mode requested !\n");
1711 bMapperFlg = TRUE;
1712 uDeviceID = 0;
1713 }
1714 if (lpFormat == NULL) return WAVERR_BADFORMAT;
1715 hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
1716 if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
1717 lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveIn);
1718 lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc);
1719 if (lpDesc == NULL) return MMSYSERR_NOMEM;
1720 lpDesc->hWave = hWaveIn;
1721 lpDesc->lpFormat = lpFormat;
1722 lpDesc->dwCallBack = dwCallback;
1723 lpDesc->dwInstance = dwInstance;
1724 while(uDeviceID < MAXWAVEDRIVERS) {
1725 dwRet = widMessage(uDeviceID, WIDM_OPEN,
1726 lpDesc->dwInstance, (DWORD)lp16Desc, 0L);
1727 if (dwRet == MMSYSERR_NOERROR) break;
1728 if (!bMapperFlg) break;
1729 uDeviceID++;
1730 dprintf_mmsys(stddeb, "waveInOpen // WAVE_MAPPER mode ! try next driver...\n");
1731 }
1732 if (dwFlags & WAVE_FORMAT_QUERY) {
1733 dprintf_mmsys(stddeb, "waveInOpen // End of WAVE_FORMAT_QUERY !\n");
1734 waveInClose(hWaveIn);
1735 }
1736 return dwRet;
1737 }
1738
1739
1740 /**************************************************************************
1741 * waveInClose [MMSYSTEM.505]
1742 */
1743 UINT waveInClose(HWAVEIN16 hWaveIn)
1744 {
1745 LPWAVEOPENDESC lpDesc;
1746 dprintf_mmsys(stddeb, "waveInClose(%04X)\n", hWaveIn);
1747 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1748 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1749 return widMessage(0, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1750 }
1751
1752
1753 /**************************************************************************
1754 * waveInPrepareHeader [MMSYSTEM.506]
1755 */
1756 UINT waveInPrepareHeader(HWAVEIN16 hWaveIn,
1757 WAVEHDR * lpWaveInHdr, UINT uSize)
1758 {
1759 LPWAVEOPENDESC lpDesc;
1760 LPWAVEHDR lp32WaveInHdr;
1761 dprintf_mmsys(stddeb, "waveInPrepareHeader(%04X, %p, %u);\n",
1762 hWaveIn, lpWaveInHdr, uSize);
1763 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1764 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1765 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1766 lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
1767 lp32WaveInHdr->lpNext = NULL;
1768 lp32WaveInHdr->dwBytesRecorded = 0;
1769 dprintf_mmsys(stddeb, "waveInPrepareHeader // lpData=%p size=%lu \n",
1770 lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength);
1771 return widMessage(0, WIDM_PREPARE, lpDesc->dwInstance,
1772 (DWORD)lpWaveInHdr, uSize);
1773 }
1774
1775
1776 /**************************************************************************
1777 * waveInUnprepareHeader [MMSYSTEM.507]
1778 */
1779 UINT waveInUnprepareHeader(HWAVEIN16 hWaveIn,
1780 WAVEHDR * lpWaveInHdr, UINT uSize)
1781 {
1782 LPWAVEOPENDESC lpDesc;
1783 LPWAVEHDR lp32WaveInHdr;
1784 dprintf_mmsys(stddeb, "waveInUnprepareHeader(%04X, %p, %u);\n",
1785 hWaveIn, lpWaveInHdr, uSize);
1786 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1787 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1788 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1789 lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
1790 USER_HEAP_FREE(HIWORD((DWORD)lp32WaveInHdr->lpData));
1791 lp32WaveInHdr->lpData = NULL;
1792 lp32WaveInHdr->lpNext = NULL;
1793 return widMessage(0, WIDM_UNPREPARE, lpDesc->dwInstance,
1794 (DWORD)lpWaveInHdr, uSize);
1795 }
1796
1797
1798 /**************************************************************************
1799 * waveInAddBuffer [MMSYSTEM.508]
1800 */
1801 UINT waveInAddBuffer(HWAVEIN16 hWaveIn,
1802 WAVEHDR * lpWaveInHdr, UINT uSize)
1803 {
1804 LPWAVEOPENDESC lpDesc;
1805 LPWAVEHDR lp32WaveInHdr;
1806 dprintf_mmsys(stddeb, "waveInAddBuffer(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
1807 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1808 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1809 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
1810 lp32WaveInHdr = PTR_SEG_TO_LIN(lpWaveInHdr);
1811 lp32WaveInHdr->lpNext = NULL;
1812 lp32WaveInHdr->dwBytesRecorded = 0;
1813 dprintf_mmsys(stddeb, "waveInAddBuffer // lpData=%p size=%lu \n",
1814 lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength);
1815 return widMessage(0, WIDM_ADDBUFFER, lpDesc->dwInstance,
1816 (DWORD)lpWaveInHdr, uSize);
1817 }
1818
1819
1820 /**************************************************************************
1821 * waveInStart [MMSYSTEM.509]
1822 */
1823 UINT waveInStart(HWAVEIN16 hWaveIn)
1824 {
1825 LPWAVEOPENDESC lpDesc;
1826 dprintf_mmsys(stddeb, "waveInStart(%04X)\n", hWaveIn);
1827 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1828 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1829 return widMessage(0, WIDM_START, lpDesc->dwInstance, 0L, 0L);
1830 }
1831
1832
1833 /**************************************************************************
1834 * waveInStop [MMSYSTEM.510]
1835 */
1836 UINT waveInStop(HWAVEIN16 hWaveIn)
1837 {
1838 LPWAVEOPENDESC lpDesc;
1839 dprintf_mmsys(stddeb, "waveInStop(%04X)\n", hWaveIn);
1840 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1841 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1842 return widMessage(0, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
1843 }
1844
1845
1846 /**************************************************************************
1847 * waveInReset [MMSYSTEM.511]
1848 */
1849 UINT waveInReset(HWAVEIN16 hWaveIn)
1850 {
1851 LPWAVEOPENDESC lpDesc;
1852 dprintf_mmsys(stddeb, "waveInReset(%04X)\n", hWaveIn);
1853 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1854 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1855 return widMessage(0, WIDM_RESET, lpDesc->dwInstance, 0L, 0L);
1856 }
1857
1858
1859 /**************************************************************************
1860 * waveInGetPosition [MMSYSTEM.512]
1861 */
1862 UINT waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpTime, UINT uSize)
1863 {
1864 LPWAVEOPENDESC lpDesc;
1865 dprintf_mmsys(stddeb, "waveInGetPosition(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
1866 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1867 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1868 return widMessage(0, WIDM_GETPOS, lpDesc->dwInstance,
1869 (DWORD)lpTime, (DWORD)uSize);
1870 }
1871
1872
1873 /**************************************************************************
1874 * waveInGetID [MMSYSTEM.513]
1875 */
1876 UINT waveInGetID(HWAVEIN16 hWaveIn, UINT * lpuDeviceID)
1877 {
1878 dprintf_mmsys(stddeb, "waveInGetID\n");
1879 if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
1880 return 0;
1881 }
1882
1883
1884 /**************************************************************************
1885 * waveInMessage [MMSYSTEM.514]
1886 */
1887 DWORD waveInMessage(HWAVEIN16 hWaveIn, UINT uMessage,
1888 DWORD dwParam1, DWORD dwParam2)
1889 {
1890 LPWAVEOPENDESC lpDesc;
1891 dprintf_mmsys(stddeb, "waveInMessage(%04X, %04X, %08lX, %08lX)\n",
1892 hWaveIn, uMessage, dwParam1, dwParam2);
1893 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
1894 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1895 return widMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
1896 }
1897
1898
1899 /**************************************************************************
1900 * mmioOpen [MMSYSTEM.1210]
1901 */
1902 HMMIO16 mmioOpen(LPSTR szFileName, MMIOINFO * lpmmioinfo, DWORD dwOpenFlags)
1903 {
1904 int hFile;
1905 HMMIO16 hmmio;
1906 OFSTRUCT ofs;
1907 LPMMIOINFO lpmminfo;
1908 dprintf_mmsys(stddeb, "mmioOpen('%s', %p, %08lX);\n", szFileName, lpmmioinfo, dwOpenFlags);
1909 hFile = OpenFile(szFileName, &ofs, dwOpenFlags);
1910 if (hFile == -1) return 0;
1911 hmmio = GlobalAlloc16(GMEM_MOVEABLE, sizeof(MMIOINFO));
1912 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
1913 if (lpmminfo == NULL) return 0;
1914 memset(lpmminfo, 0, sizeof(MMIOINFO));
1915 lpmminfo->hmmio = hmmio;
1916 lpmminfo->dwReserved2 = MAKELONG(hFile, 0);
1917 GlobalUnlock16(hmmio);
1918 dprintf_mmsys(stddeb, "mmioOpen // return hmmio=%04X\n", hmmio);
1919 return hmmio;
1920 }
1921
1922
1923 /**************************************************************************
1924 * mmioClose [MMSYSTEM.1211]
1925 */
1926 UINT mmioClose(HMMIO16 hmmio, UINT uFlags)
1927 {
1928 LPMMIOINFO lpmminfo;
1929 dprintf_mmsys(stddeb, "mmioClose(%04X, %04X);\n", hmmio, uFlags);
1930 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
1931 if (lpmminfo == NULL) return 0;
1932 _lclose(LOWORD(lpmminfo->dwReserved2));
1933 GlobalUnlock16(hmmio);
1934 GlobalFree16(hmmio);
1935 return 0;
1936 }
1937
1938
1939
1940 /**************************************************************************
1941 * mmioRead [MMSYSTEM.1212]
1942 */
1943 LONG mmioRead(HMMIO16 hmmio, HPSTR pch, LONG cch)
1944 {
1945 LONG count;
1946 LPMMIOINFO lpmminfo;
1947 dprintf_mmio(stddeb, "mmioRead(%04X, %p, %ld);\n", hmmio, pch, cch);
1948 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
1949 if (lpmminfo == NULL) return 0;
1950 count = _lread32(LOWORD(lpmminfo->dwReserved2), pch, cch);
1951 GlobalUnlock16(hmmio);
1952 dprintf_mmio(stddeb, "mmioRead // count=%ld\n", count);
1953 return count;
1954 }
1955
1956
1957
1958 /**************************************************************************
1959 * mmioWrite [MMSYSTEM.1213]
1960 */
1961 LONG mmioWrite(HMMIO16 hmmio, HPCSTR pch, LONG cch)
1962 {
1963 LONG count;
1964 LPMMIOINFO lpmminfo;
1965 dprintf_mmsys(stddeb, "mmioWrite(%04X, %p, %ld);\n", hmmio, pch, cch);
1966 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
1967 if (lpmminfo == NULL) return 0;
1968 count = _lwrite32(LOWORD(lpmminfo->dwReserved2), (LPSTR)pch, cch);
1969 GlobalUnlock16(hmmio);
1970 return count;
1971 }
1972
1973 /**************************************************************************
1974 * mmioSeek [MMSYSTEM.1214]
1975 */
1976 LONG mmioSeek(HMMIO16 hmmio, LONG lOffset, int iOrigin)
1977 {
1978 int count;
1979 LPMMIOINFO lpmminfo;
1980 dprintf_mmsys(stddeb, "mmioSeek(%04X, %08lX, %d);\n", hmmio, lOffset, iOrigin);
1981 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
1982 if (lpmminfo == NULL) {
1983 dprintf_mmsys(stddeb, "mmioSeek // can't lock hmmio=%04X !\n", hmmio);
1984 return 0;
1985 }
1986 count = _llseek(LOWORD(lpmminfo->dwReserved2), lOffset, iOrigin);
1987 GlobalUnlock16(hmmio);
1988 return count;
1989 }
1990
1991 /**************************************************************************
1992 * mmioGetInfo [MMSYSTEM.1215]
1993 */
1994 UINT mmioGetInfo(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT uFlags)
1995 {
1996 LPMMIOINFO lpmminfo;
1997 dprintf_mmsys(stddeb, "mmioGetInfo\n");
1998 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
1999 if (lpmminfo == NULL) return 0;
2000 memcpy(lpmmioinfo, lpmminfo, sizeof(MMIOINFO));
2001 GlobalUnlock16(hmmio);
2002 return 0;
2003 }
2004
2005 /**************************************************************************
2006 * mmioSetInfo [MMSYSTEM.1216]
2007 */
2008 UINT mmioSetInfo(HMMIO16 hmmio, const MMIOINFO * lpmmioinfo, UINT uFlags)
2009 {
2010 LPMMIOINFO lpmminfo;
2011 dprintf_mmsys(stddeb, "mmioSetInfo\n");
2012 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2013 if (lpmminfo == NULL) return 0;
2014 GlobalUnlock16(hmmio);
2015 return 0;
2016 }
2017
2018 /**************************************************************************
2019 * mmioSetBuffer [MMSYSTEM.1217]
2020 */
2021 UINT mmioSetBuffer(HMMIO16 hmmio, LPSTR pchBuffer,
2022 LONG cchBuffer, UINT uFlags)
2023 {
2024 dprintf_mmsys(stddeb, "mmioSetBuffer // empty stub \n");
2025 return 0;
2026 }
2027
2028 /**************************************************************************
2029 * mmioFlush [MMSYSTEM.1218]
2030 */
2031 UINT mmioFlush(HMMIO16 hmmio, UINT uFlags)
2032 {
2033 LPMMIOINFO lpmminfo;
2034 dprintf_mmsys(stddeb, "mmioFlush(%04X, %04X)\n", hmmio, uFlags);
2035 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2036 if (lpmminfo == NULL) return 0;
2037 GlobalUnlock16(hmmio);
2038 return 0;
2039 }
2040
2041 /**************************************************************************
2042 * mmioAdvance [MMSYSTEM.1219]
2043 */
2044 UINT mmioAdvance(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT uFlags)
2045 {
2046 int count = 0;
2047 LPMMIOINFO lpmminfo;
2048 dprintf_mmsys(stddeb, "mmioAdvance\n");
2049 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2050 if (lpmminfo == NULL) return 0;
2051 if (uFlags == MMIO_READ) {
2052 count = _lread32(LOWORD(lpmminfo->dwReserved2),
2053 lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer);
2054 }
2055 if (uFlags == MMIO_WRITE) {
2056 count = _lwrite32(LOWORD(lpmminfo->dwReserved2),
2057 lpmmioinfo->pchBuffer, lpmmioinfo->cchBuffer);
2058 }
2059 lpmmioinfo->pchNext += count;
2060 GlobalUnlock16(hmmio);
2061 lpmminfo->lDiskOffset = _llseek(LOWORD(lpmminfo->dwReserved2), 0, SEEK_CUR);
2062 return 0;
2063 }
2064
2065 /**************************************************************************
2066 * mmioStringToFOURCC [MMSYSTEM.1220]
2067 */
2068 FOURCC mmioStringToFOURCC(LPCSTR sz, UINT uFlags)
2069 {
2070 dprintf_mmsys(stddeb, "mmioStringToFOURCC // empty stub \n");
2071 return 0;
2072 }
2073
2074 /**************************************************************************
2075 * mmioInstallIOProc [MMSYSTEM.1221]
2076 */
2077 LPMMIOPROC mmioInstallIOProc(FOURCC fccIOProc,
2078 LPMMIOPROC pIOProc, DWORD dwFlags)
2079 {
2080 dprintf_mmsys(stddeb, "mmioInstallIOProc // empty stub \n");
2081 return 0;
2082 }
2083
2084 /**************************************************************************
2085 * mmioSendMessage [MMSYSTEM.1222]
2086 */
2087 LRESULT mmioSendMessage(HMMIO16 hmmio, UINT uMessage,
2088 LPARAM lParam1, LPARAM lParam2)
2089 {
2090 dprintf_mmsys(stddeb, "mmioSendMessage // empty stub \n");
2091 return 0;
2092 }
2093
2094 /**************************************************************************
2095 * mmioDescend [MMSYSTEM.1223]
2096 */
2097 UINT mmioDescend(HMMIO16 hmmio, MMCKINFO * lpck,
2098 const MMCKINFO * lpckParent, UINT uFlags)
2099 {
2100 DWORD dwfcc, dwOldPos;
2101 LPMMIOINFO lpmminfo;
2102 dprintf_mmio(stddeb, "mmioDescend(%04X, %p, %p, %04X);\n",
2103 hmmio, lpck, lpckParent, uFlags);
2104 if (lpck == NULL) return 0;
2105 lpmminfo = (LPMMIOINFO)GlobalLock16(hmmio);
2106 if (lpmminfo == NULL) return 0;
2107 dwfcc = lpck->ckid;
2108 dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX\n", dwfcc);
2109 dwOldPos = _llseek(LOWORD(lpmminfo->dwReserved2), 0, SEEK_CUR);
2110 dprintf_mmio(stddeb, "mmioDescend // dwOldPos=%ld\n", dwOldPos);
2111 if (lpckParent != NULL) {
2112 dprintf_mmio(stddeb, "mmioDescend // seek inside parent at %ld !\n", lpckParent->dwDataOffset);
2113 dwOldPos = _llseek(LOWORD(lpmminfo->dwReserved2),
2114 lpckParent->dwDataOffset, SEEK_SET);
2115 }
2116 if ((uFlags & MMIO_FINDCHUNK) || (uFlags & MMIO_FINDRIFF) ||
2117 (uFlags & MMIO_FINDLIST)) {
2118 dprintf_mmio(stddeb, "mmioDescend // MMIO_FINDxxxx dwfcc=%08lX !\n", dwfcc);
2119 while (TRUE) {
2120 if (_lread32(LOWORD(lpmminfo->dwReserved2), (LPSTR)lpck,
2121 sizeof(MMCKINFO)) < sizeof(MMCKINFO)) {
2122 _llseek(LOWORD(lpmminfo->dwReserved2), dwOldPos, SEEK_SET);
2123 GlobalUnlock16(hmmio);
2124 return MMIOERR_CHUNKNOTFOUND;
2125 }
2126 dprintf_mmio(stddeb, "mmioDescend // dwfcc=%08lX ckid=%08lX cksize=%08lX !\n",
2127 dwfcc, lpck->ckid, lpck->cksize);
2128 if (dwfcc == lpck->ckid) break;
2129 dwOldPos += lpck->cksize + 2 * sizeof(DWORD);
2130 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
2131 dwOldPos += sizeof(DWORD);
2132 _llseek(LOWORD(lpmminfo->dwReserved2), dwOldPos, SEEK_SET);
2133 }
2134 }
2135 else {
2136 if (_lread32(LOWORD(lpmminfo->dwReserved2), (LPSTR)lpck,
2137 sizeof(MMCKINFO)) < sizeof(MMCKINFO)) {
2138 _llseek(LOWORD(lpmminfo->dwReserved2), dwOldPos, SEEK_SET);
2139 GlobalUnlock16(hmmio);
2140 return MMIOERR_CHUNKNOTFOUND;
2141 }
2142 }
2143 lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
2144 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
2145 lpck->dwDataOffset += sizeof(DWORD);
2146 lpmminfo->lDiskOffset = _llseek(LOWORD(lpmminfo->dwReserved2),
2147 lpck->dwDataOffset, SEEK_SET);
2148 GlobalUnlock16(hmmio);
2149 dprintf_mmio(stddeb, "mmioDescend // lpck->ckid=%08lX lpck->cksize=%ld !\n",
2150 lpck->ckid, lpck->cksize);
2151 dprintf_mmsys(stddeb, "mmioDescend // lpck->fccType=%08lX !\n", lpck->fccType);
2152 return 0;
2153 }
2154
2155 /**************************************************************************
2156 * mmioAscend [MMSYSTEM.1224]
2157 */
2158 UINT mmioAscend(HMMIO16 hmmio, MMCKINFO * lpck, UINT uFlags)
2159 {
2160 dprintf_mmsys(stddeb, "mmioAscend // empty stub !\n");
2161 return 0;
2162 }
2163
2164 /**************************************************************************
2165 * mmioCreateChunk [MMSYSTEM.1225]
2166 */
2167 UINT mmioCreateChunk(HMMIO16 hmmio, MMCKINFO * lpck, UINT uFlags)
2168 {
2169 dprintf_mmsys(stddeb, "mmioCreateChunk // empty stub \n");
2170 return 0;
2171 }
2172
2173
2174 /**************************************************************************
2175 * mmioRename [MMSYSTEM.1226]
2176 */
2177 UINT mmioRename(LPCSTR szFileName, LPCSTR szNewFileName,
2178 MMIOINFO * lpmmioinfo, DWORD dwRenameFlags)
2179 {
2180 dprintf_mmsys(stddeb, "mmioRename('%s', '%s', %p, %08lX); // empty stub \n",
2181 szFileName, szNewFileName, lpmmioinfo, dwRenameFlags);
2182 return 0;
2183 }
2184
2185 /**************************************************************************
2186 * DrvOpen [MMSYSTEM.1100]
2187 */
2188 HDRVR16 DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
2189 {
2190 dprintf_mmsys(stddeb, "DrvOpen('%s', '%s', %08lX);\n",
2191 lpDriverName, lpSectionName, lParam);
2192 return OpenDriver(lpDriverName, lpSectionName, lParam);
2193 }
2194
2195
2196 /**************************************************************************
2197 * DrvClose [MMSYSTEM.1101]
2198 */
2199 LRESULT DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
2200 {
2201 dprintf_mmsys(stddeb, "DrvClose(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
2202 return CloseDriver(hDrvr, lParam1, lParam2);
2203 }
2204
2205
2206 /**************************************************************************
2207 * DrvSendMessage [MMSYSTEM.1102]
2208 */
2209 LRESULT DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1, LPARAM lParam2)
2210 {
2211 DWORD dwDevID = 0;
2212 dprintf_mmsys(stddeb, "DrvSendMessage(%04X, %04X, %08lX, %08lX);\n",
2213 hDriver, msg, lParam1, lParam2);
2214 #ifndef WINELIB
2215 return CDAUDIO_DriverProc(dwDevID, hDriver, msg, lParam1, lParam2);
2216 #endif
2217 }
2218
2219 /**************************************************************************
2220 * DrvGetModuleHandle [MMSYSTEM.1103]
2221 */
2222 HANDLE16 DrvGetModuleHandle(HDRVR16 hDrvr)
2223 {
2224 dprintf_mmsys(stddeb, "DrvGetModuleHandle(%04X);\n", hDrvr);
2225 return 0;
2226 }
2227
2228
2229 /**************************************************************************
2230 * DrvDefDriverProc [MMSYSTEM.1104]
2231 */
2232 LRESULT DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
2233 DWORD dwParam1, DWORD dwParam2)
2234 {
2235 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
2236 }
2237
2238
2239 #endif /* #ifdef WINELIB */
2240
Windows API implementation