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