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