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