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