?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980301
[wine/hacks.git] / multimedia / mmsystem.c
blob35e94e7a65edbb9c7e1e204a1d4b033123ab25ea
1 /*
2 * MMSYTEM functions
3 *
4 * Copyright 1993 Martin Ayotte
5 */
6 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
7 * and long term pointers to 16 bit space in here
8 */
9
10 #include <unistd.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <fcntl.h>
15 #include <errno.h>
16 #include <sys/ioctl.h>
17 #include "windows.h"
18 #include "win.h"
19 #include "heap.h"
20 #include "ldt.h"
21 #include "user.h"
22 #include "driver.h"
23 #include "file.h"
24 #include "mmsystem.h"
25 #include "debug.h"
26 #include "xmalloc.h"
27 #include "callback.h"
28
29 static int InstalledCount;
30 static int InstalledListLen;
31 static LPSTR lpInstallNames = NULL;
32
33 struct LINUX_MCIDRIVER mciDrv[MAXMCIDRIVERS];
34
35 UINT16 midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
36 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
37 LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
38 DWORD dwParam1, DWORD dwParam2);
39
40 LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
41 DWORD dwParam1, DWORD dwParam2);
42 LONG MIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
43 DWORD dwParam1, DWORD dwParam2);
44 LONG CDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
45 DWORD dwParam1, DWORD dwParam2);
46 LONG ANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
47 DWORD dwParam1, DWORD dwParam2);
48
49
50 #define GetDrv(wDevID) (&mciDrv[MMSYSTEM_DevIDToIndex(wDevID)])
51 #define GetOpenDrv(wDevID) (&(GetDrv(wDevID)->mop))
52
53 /* The wDevID's returned by wine were originally in the range
54 * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices.
55 * Unfortunately, ms-windows uses wDevID of zero to indicate
56 * errors. Now, multimedia drivers must pass the wDevID through
57 * MMSYSTEM_DevIDToIndex to get an index in that range. An
58 * aribtrary value, MMSYSTEM_MAGIC is added to the wDevID seen
59 * by the windows programs.
60 */
61
62 #define MMSYSTEM_MAGIC 0x0F00
63
64 /**************************************************************************
65 * MMSYSTEM_DevIDToIndex [internal]
66 */
67 int MMSYSTEM_DevIDToIndex(UINT16 wDevID) {
68 return wDevID - MMSYSTEM_MAGIC;
69 }
70
71 /**************************************************************************
72 * MMSYSTEM_FirstDevId [internal]
73 */
74 UINT16 MMSYSTEM_FirstDevID(void)
75 {
76 return MMSYSTEM_MAGIC;
77 }
78
79 /**************************************************************************
80 * MMSYSTEM_NextDevId [internal]
81 */
82 UINT16 MMSYSTEM_NextDevID(UINT16 wDevID) {
83 return wDevID + 1;
84 }
85
86 /**************************************************************************
87 * MMSYSTEM_DevIdValid [internal]
88 */
89 BOOL32 MMSYSTEM_DevIDValid(UINT16 wDevID) {
90 return wDevID >= 0x0F00 && wDevID < (0x0F00 + MAXMCIDRIVERS);
91 }
92
93 /**************************************************************************
94 * MMSYSTEM_WEP [MMSYSTEM.1]
95 */
96 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
97 WORD cbHeapSize, LPSTR lpCmdLine)
98 {
99 fprintf(stderr, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance);
100 return(TRUE);
101 }
102
103 void
104 MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16,LPMMTIME32 mmt32) {
105 mmt16->wType = mmt32->wType;
106 /* layout of rest is the same for 32/16 */
107 memcpy(&(mmt32->u),&(mmt16->u),sizeof(mmt16->u));
108 }
109
110 void
111 MMSYSTEM_MMTIME16to32(LPMMTIME32 mmt32,LPMMTIME16 mmt16) {
112 mmt32->wType = mmt16->wType;
113 /* layout of rest is the same for 32/16,
114 * Note: mmt16->u is 2 bytes smaller than mmt32->u
115 */
116 memcpy(&(mmt16->u),&(mmt32->u),sizeof(mmt16->u));
117 }
118
119 /**************************************************************************
120 * PlaySoundA [WINMM.1]
121 */
122 BOOL32 WINAPI PlaySound32A(LPCSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
123 {
124 dprintf_info(mmsys, "PlaySoundA: pszSound='%p' hmod=%04X fdwSound=%08lX\n",
125 pszSound, hmod, fdwSound);
126 if(hmod != 0 || !(fdwSound & SND_FILENAME)) {
127 fprintf(stderr, "PlaySoundA: only disk sound files are supported\n");
128 return FALSE;
129 } else
130 return sndPlaySound(pszSound, (UINT16) fdwSound);
131 }
132
133 /**************************************************************************
134 * PlaySoundW [WINMM.18]
135 */
136 BOOL32 WINAPI PlaySound32W(LPCWSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
137 {
138 LPSTR pszSoundA = HEAP_strdupWtoA(GetProcessHeap(),0,pszSound);
139 BOOL32 bSound;
140
141 bSound = PlaySound32A(pszSoundA, hmod, fdwSound);
142 HeapFree(GetProcessHeap(),0,pszSoundA);
143 return bSound;
144 }
145
146 /**************************************************************************
147 * sndPlaySound [MMSYSTEM.2]
148 */
149 BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags)
150 {
151 BOOL16 bRet = FALSE;
152 HMMIO16 hmmio;
153 MMCKINFO ckMainRIFF;
154 char str[128];
155 LPSTR ptr;
156
157 dprintf_info(mmsys, "sndPlaySound // SoundName='%s' uFlags=%04X !\n",
158 lpszSoundName, uFlags);
159 if (lpszSoundName == NULL) {
160 dprintf_info(mmsys, "sndPlaySound // Stop !\n");
161 return FALSE;
162 }
163 hmmio = mmioOpen16((LPSTR)lpszSoundName, NULL,
164 MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
165
166 if (uFlags & SND_MEMORY) {
167 dprintf_fixme(mmsys, "sndPlaySound // SND_MEMORY flag not implemented!\n");
168 return FALSE;
169 }
170
171 if (hmmio == 0)
172 {
173 dprintf_info(mmsys, "sndPlaySound // searching in SystemSound List !\n");
174 GetProfileString32A("Sounds", (LPSTR)lpszSoundName, "", str, sizeof(str));
175 if (strlen(str) == 0) return FALSE;
176 if ( (ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0';
177 hmmio = mmioOpen16(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
178 if (hmmio == 0)
179 {
180 dprintf_warn(mmsys, "sndPlaySound // can't find SystemSound='%s' !\n", str);
181 return FALSE;
182 }
183 }
184
185 if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0)
186 {
187 dprintf_info(mmsys, "sndPlaySound // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
188 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
189
190 if ((ckMainRIFF.ckid == FOURCC_RIFF) &&
191 (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E')))
192 {
193 MMCKINFO mmckInfo;
194
195 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
196
197 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0)
198 {
199 PCMWAVEFORMAT pcmWaveFormat;
200
201 dprintf_info(mmsys, "sndPlaySound // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
202 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
203
204 if (mmioRead(hmmio, (HPSTR) &pcmWaveFormat,
205 (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT))
206 {
207
208 dprintf_info(mmsys, "sndPlaySound // wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag);
209 dprintf_info(mmsys, "sndPlaySound // nChannels=%d \n", pcmWaveFormat.wf.nChannels);
210 dprintf_info(mmsys, "sndPlaySound // nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec);
211 dprintf_info(mmsys, "sndPlaySound // nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec);
212 dprintf_info(mmsys, "sndPlaySound // nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign);
213 dprintf_info(mmsys, "sndPlaySound // wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample);
214
215 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
216 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0)
217 {
218 WAVEOPENDESC waveDesc;
219 DWORD dwRet;
220
221 dprintf_info(mmsys, "sndPlaySound // Chunk Found \
222 ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
223
224 pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec *
225 pcmWaveFormat.wf.nBlockAlign;
226 waveDesc.hWave = 0;
227 waveDesc.lpFormat = (LPWAVEFORMAT)&pcmWaveFormat;
228
229 dwRet = wodMessage( 0, WODM_OPEN, 0, (DWORD)&waveDesc, CALLBACK_NULL);
230 if (dwRet == MMSYSERR_NOERROR)
231 {
232 WAVEHDR waveHdr;
233 HGLOBAL16 hData;
234 INT32 count, bufsize;
235
236 bufsize = 64000;
237 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
238 waveHdr.lpData = (LPSTR)GlobalLock16(hData);
239 waveHdr.dwBufferLength = bufsize;
240 waveHdr.dwUser = 0L;
241 waveHdr.dwFlags = 0L;
242 waveHdr.dwLoops = 0L;
243
244 dwRet = wodMessage(0,WODM_PREPARE,0,(DWORD)&waveHdr,sizeof(WAVEHDR));
245 if (dwRet == MMSYSERR_NOERROR)
246 {
247 while( TRUE )
248 {
249 count = mmioRead(hmmio, waveHdr.lpData, bufsize);
250 if (count < 1) break;
251 waveHdr.dwBufferLength = count;
252 /* waveHdr.dwBytesRecorded = count; */
253 /* FIXME: doesn't expect async ops */
254 wodMessage( 0, WODM_WRITE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
255 }
256 wodMessage( 0, WODM_UNPREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
257 wodMessage( 0, WODM_CLOSE, 0, 0L, 0L);
258
259 bRet = TRUE;
260 }
261 else dprintf_warn(mmsys, "sndPlaySound // can't prepare WaveOut device !\n");
262
263 GlobalUnlock16(hData);
264 GlobalFree16(hData);
265 }
266 }
267 }
268 }
269 }
270 }
271
272 if (hmmio != 0) mmioClose(hmmio, 0);
273 return bRet;
274 }
275
276 /**************************************************************************
277 * mmsystemGetVersion [WINMM.134]
278 */
279 UINT32 WINAPI mmsystemGetVersion32()
280 {
281 return mmsystemGetVersion16();
282 }
283
284 /**************************************************************************
285 * mmsystemGetVersion [MMSYSTEM.5]
286 * return value borrowed from Win95 winmm.dll ;)
287 */
288 UINT16 WINAPI mmsystemGetVersion16()
289 {
290 dprintf_info(mmsys, "mmsystemGetVersion // 3.10 (Win95?)\n");
291 return 0x030a;
292 }
293
294 /**************************************************************************
295 * DriverProc [MMSYSTEM.6]
296 */
297 LRESULT WINAPI DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
298 DWORD dwParam1, DWORD dwParam2)
299 {
300 return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
301 }
302
303 /**************************************************************************
304 * DriverCallback [MMSYSTEM.31]
305 */
306 BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
307 WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
308 {
309 LPWAVEOPENDESC lpDesc;
310
311 dprintf_info(mmsys, "DriverCallback(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
312 dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
313 switch(uFlags & DCB_TYPEMASK) {
314 case DCB_NULL:
315 dprintf_info(mmsys, "DriverCallback() // CALLBACK_NULL !\n");
316 break;
317 case DCB_WINDOW:
318 dprintf_info(mmsys, "DriverCallback() // CALLBACK_WINDOW = %04lX handle = %04X!\n",dwCallBack,hDev);
319 if (!IsWindow32(dwCallBack)) return FALSE;
320 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hDev);
321 if (lpDesc == NULL) return FALSE;
322
323 PostMessage16((HWND16)dwCallBack, wMsg, hDev, dwParam1);
324 break;
325 case DCB_TASK:
326 dprintf_info(mmsys, "DriverCallback() // CALLBACK_TASK !\n");
327 return FALSE;
328 case DCB_FUNCTION:
329 dprintf_info(mmsys, "DriverCallback() // CALLBACK_FUNCTION !\n");
330 Callbacks->CallDriverCallback( (FARPROC16)dwCallBack,
331 hDev, wMsg, dwUser,
332 dwParam1, dwParam2 );
333 break;
334 }
335 return TRUE;
336 }
337
338 /**************************************************************************
339 * Mixer devices. New to Win95
340 */
341 /**************************************************************************
342 * find out the real mixer ID depending on hmix (depends on dwFlags)
343 * FIXME: also fix dwInstance passing to mixMessage
344 */
345 static UINT32 _get_mixerID_from_handle(HMIXEROBJ32 hmix,DWORD dwFlags) {
346 /* FIXME: Check dwFlags for MIXER_OBJECTF_xxxx entries and modify hmix
347 * accordingly. For now we always use mixerdevice 0.
348 */
349 return 0;
350 }
351 /**************************************************************************
352 * mixerGetNumDevs [WINMM.108]
353 */
354 UINT32 WINAPI mixerGetNumDevs32()
355 {
356 return mixerGetNumDevs16();
357 }
358
359 /**************************************************************************
360 * mixerGetNumDevs
361 */
362 UINT16 WINAPI mixerGetNumDevs16()
363 {
364 UINT16 count;
365
366 count = mixMessage(0,MXDM_GETNUMDEVS,0L,0L,0L);
367 dprintf_info(mmaux,"mixerGetNumDevs returns %d\n",count);
368 return count;
369 }
370
371 /**************************************************************************
372 * mixerGetDevCapsW [WINMM.102]
373 */
374 UINT32 WINAPI mixerGetDevCaps32W(UINT32 devid,LPMIXERCAPS32W mixcaps,UINT32 size)
375 {
376 MIXERCAPS16 mic16;
377 UINT32 ret = mixerGetDevCaps16(devid,&mic16,sizeof(mic16));
378
379 mixcaps->wMid = mic16.wMid;
380 mixcaps->wPid = mic16.wPid;
381 mixcaps->vDriverVersion = mic16.vDriverVersion;
382 lstrcpyAtoW(mixcaps->szPname,mic16.szPname);
383 mixcaps->fdwSupport = mic16.fdwSupport;
384 mixcaps->cDestinations = mic16.cDestinations;
385 return ret;
386 }
387 /**************************************************************************
388 * mixerGetDevCaps [WINMM.101]
389 */
390 UINT32 WINAPI mixerGetDevCaps32A(UINT32 devid,LPMIXERCAPS32A mixcaps,UINT32 size)
391 {
392 MIXERCAPS16 mic16;
393 UINT32 ret = mixerGetDevCaps16(devid,&mic16,sizeof(mic16));
394
395 mixcaps->wMid = mic16.wMid;
396 mixcaps->wPid = mic16.wPid;
397 mixcaps->vDriverVersion = mic16.vDriverVersion;
398 strcpy(mixcaps->szPname,mic16.szPname);
399 mixcaps->fdwSupport = mic16.fdwSupport;
400 mixcaps->cDestinations = mic16.cDestinations;
401 return ret;
402 }
403
404 /**************************************************************************
405 * mixerGetDevCaps
406 */
407 UINT16 WINAPI mixerGetDevCaps16(UINT16 devid,LPMIXERCAPS16 mixcaps,UINT16 size)
408 {
409 fprintf(stderr,"mixerGetDevCaps!\n");
410 return mixMessage(devid,MXDM_GETDEVCAPS,0L,(DWORD)mixcaps,(DWORD)size);
411 }
412
413 /**************************************************************************
414 * mixerOpen [WINMM.110]
415 */
416 UINT32 WINAPI mixerOpen32(LPHMIXER32 lphmix,UINT32 uDeviceID,DWORD dwCallback,
417 DWORD dwInstance,DWORD fdwOpen)
418 {
419 HMIXER16 hmix16;
420 UINT32 ret;
421
422 fprintf(stderr,"mixerOpen32(%p,%d,%08lx,%08lx,%08lx)\n",
423 lphmix,uDeviceID,dwCallback,dwInstance,fdwOpen
424 );
425 ret = mixerOpen16(&hmix16,uDeviceID,dwCallback,dwInstance,fdwOpen);
426 if (lphmix) *lphmix = hmix16;
427 return ret;
428 }
429
430 /**************************************************************************
431 * mixerOpen
432 */
433 UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix,UINT16 uDeviceID,DWORD dwCallback,
434 DWORD dwInstance,DWORD fdwOpen)
435 {
436 HMIXER16 hmix;
437 LPMIXEROPENDESC lpmod;
438 BOOL32 mapperflag = (uDeviceID==0);
439 DWORD dwRet;
440
441 fprintf(stderr,"mixerOpen(%p,%d,%08lx,%08lx,%08lx)\n",
442 lphmix,uDeviceID,dwCallback,dwInstance,fdwOpen
443 );
444 hmix = USER_HEAP_ALLOC(sizeof(MIXEROPENDESC));
445 if (lphmix) *lphmix = hmix;
446 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
447 lpmod->hmx = hmix;
448 lpmod->dwCallback = dwCallback;
449 lpmod->dwInstance = dwInstance;
450 if (uDeviceID >= MAXMIXERDRIVERS)
451 uDeviceID = 0;
452 while(uDeviceID < MAXMIXERDRIVERS) {
453 dwRet=mixMessage(uDeviceID,MXDM_OPEN,dwInstance,(DWORD)lpmod,fdwOpen);
454 if (dwRet == MMSYSERR_NOERROR) break;
455 if (!mapperflag) break;
456 uDeviceID++;
457 }
458 lpmod->uDeviceID = uDeviceID;
459 return dwRet;
460 }
461
462 /**************************************************************************
463 * mixerClose [WINMM.98]
464 */
465 UINT32 WINAPI mixerClose32(HMIXER32 hmix) {
466 return mixerClose16(hmix);
467 }
468
469 /**************************************************************************
470 * mixerClose
471 */
472 UINT16 WINAPI mixerClose16(HMIXER16 hmix) {
473 LPMIXEROPENDESC lpmod;
474
475 fprintf(stderr,"mixerClose(%04x)\n",hmix);
476 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
477 return mixMessage(lpmod->uDeviceID,MXDM_CLOSE,lpmod->dwInstance,0L,0L);
478 }
479
480 /**************************************************************************
481 * mixerGetID [WINMM.103]
482 */
483 UINT32 WINAPI mixerGetID32(HMIXEROBJ32 hmix,LPUINT32 lpid,DWORD fdwID) {
484 UINT16 xid;
485
486 UINT32 ret = mixerGetID16(hmix,&xid,fdwID);
487 if (*lpid) *lpid = xid;
488 return ret;
489 }
490
491 /**************************************************************************
492 * mixerGetID
493 */
494 UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix,LPUINT16 lpid,DWORD fdwID) {
495 fprintf(stderr,"mixerGetID(%04x)\n",hmix);
496 return _get_mixerID_from_handle(hmix,fdwID);
497 }
498
499 /**************************************************************************
500 * mixerGetControlDetailsA [WINMM.99]
501 */
502 UINT32 mixerGetControlDetails32A(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails) {
503 fprintf(stderr,"mixerGetControlDetails(%04x,%p,%08lx),stub!\n",
504 hmix,lpmcd,fdwDetails
505 );
506 return MMSYSERR_NOTENABLED;
507 }
508
509 /**************************************************************************
510 * mixerGetControlDetailsW [WINMM.100]
511 */
512 UINT32 mixerGetControlDetails32W(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails) {
513 fprintf(stderr,"mixerGetControlDetails(%04x,%p,%08lx),stub!\n",
514 hmix,lpmcd,fdwDetails
515 );
516 return MMSYSERR_NOTENABLED;
517 }
518
519 /**************************************************************************
520 * mixerGetControlDetails [MMSYSTEM.808]
521 */
522 UINT16 mixerGetControlDetails16(HMIXEROBJ16 hmix,LPMIXERCONTROLDETAILS16 lpmcd,DWORD fdwDetails) {
523 fprintf(stderr,"mixerGetControlDetails(%04x,%p,%08lx),stub!\n",
524 hmix,lpmcd,fdwDetails
525 );
526 return MMSYSERR_NOTENABLED;
527 }
528
529 /**************************************************************************
530 * mixerGetLineControlsA [WINMM.104]
531 */
532 UINT32 WINAPI mixerGetLineControls32A(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32A lpmlc,DWORD fdwControls) {
533 fprintf(stderr,"mixerGetLineControlsA(%04x,%p,%08lx),stub!\n",
534 hmix,lpmlc,fdwControls
535 );
536 return MMSYSERR_NOTENABLED;
537 }
538
539 /**************************************************************************
540 * mixerGetLineControlsW [WINMM.105]
541 */
542 UINT32 WINAPI mixerGetLineControls32W(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32W lpmlc,DWORD fdwControls) {
543 fprintf(stderr,"mixerGetLineControlsA(%04x,%p,%08lx),stub!\n",
544 hmix,lpmlc,fdwControls
545 );
546 return MMSYSERR_NOTENABLED;
547 }
548
549 /**************************************************************************
550 * mixerGetLineControls [MMSYSTEM.807]
551 */
552 UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,LPMIXERLINECONTROLS16 lpmlc,DWORD fdwControls) {
553 fprintf(stderr,"mixerGetLineControls(%04x,%p,%08lx),stub!\n",
554 hmix,lpmlc,fdwControls
555 );
556 return MMSYSERR_NOTENABLED;
557 }
558
559 /**************************************************************************
560 * mixerGetLineInfoA [WINMM.106]
561 */
562 UINT32 WINAPI mixerGetLineInfo32A(HMIXEROBJ32 hmix,LPMIXERLINE32A lpml,DWORD fdwInfo) {
563 MIXERLINE16 ml16;
564 UINT32 ret;
565
566 ml16.dwDestination = lpml->dwDestination;
567 fprintf(stderr,"mixerGetLineInfoA(%04x,%p,%08lx),stub!\n",
568 hmix,lpml,fdwInfo
569 );
570 ret = mixerGetLineInfo16(hmix,&ml16,fdwInfo);
571 lpml->cbStruct = sizeof(*lpml);
572 lpml->dwSource = ml16.dwSource;
573 lpml->dwLineID = ml16.dwLineID;
574 lpml->fdwLine = ml16.fdwLine;
575 lpml->dwUser = ml16.dwUser;
576 lpml->dwComponentType = ml16.dwComponentType;
577 lpml->cChannels = ml16.cChannels;
578 lpml->cConnections = ml16.cConnections;
579 lpml->cControls = ml16.cControls;
580 strcpy(lpml->szShortName,ml16.szShortName);
581 strcpy(lpml->szName,ml16.szName);
582 lpml->Target.dwType = ml16.Target.dwType;
583 lpml->Target.dwDeviceID = ml16.Target.dwDeviceID;
584 lpml->Target.wMid = ml16.Target.wMid;
585 lpml->Target.wPid = ml16.Target.wPid;
586 lpml->Target.vDriverVersion = ml16.Target.vDriverVersion;
587 strcpy(lpml->Target.szPname,ml16.Target.szPname);
588 return ret;
589 }
590
591 /**************************************************************************
592 * mixerGetLineInfoW [WINMM.107]
593 */
594 UINT32 WINAPI mixerGetLineInfo32W(HMIXEROBJ32 hmix,LPMIXERLINE32W lpml,DWORD fdwInfo) {
595 MIXERLINE16 ml16;
596 UINT32 ret;
597
598 ml16.dwDestination = lpml->dwDestination;
599 fprintf(stderr,"mixerGetLineInfoW(%04x,%p,%08lx),stub!\n",
600 hmix,lpml,fdwInfo
601 );
602 ret = mixerGetLineInfo16(hmix,&ml16,fdwInfo);
603 lpml->cbStruct = sizeof(*lpml);
604 lpml->dwSource = ml16.dwSource;
605 lpml->dwLineID = ml16.dwLineID;
606 lpml->fdwLine = ml16.fdwLine;
607 lpml->dwUser = ml16.dwUser;
608 lpml->dwComponentType = ml16.dwComponentType;
609 lpml->cChannels = ml16.cChannels;
610 lpml->cConnections = ml16.cConnections;
611 lpml->cControls = ml16.cControls;
612 lstrcpyAtoW(lpml->szShortName,ml16.szShortName);
613 lstrcpyAtoW(lpml->szName,ml16.szName);
614 lpml->Target.dwType = ml16.Target.dwType;
615 lpml->Target.dwDeviceID = ml16.Target.dwDeviceID;
616 lpml->Target.wMid = ml16.Target.wMid;
617 lpml->Target.wPid = ml16.Target.wPid;
618 lpml->Target.vDriverVersion = ml16.Target.vDriverVersion;
619 /*lstrcpyAtoW(lpml->Target.szPname,ml16.Target.szPname);*/
620 return ret;
621 }
622
623 /**************************************************************************
624 * mixerGetLineInfo [MMSYSTEM.805]
625 */
626 UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix,LPMIXERLINE16 lpml,DWORD fdwInfo) {
627 UINT16 devid = _get_mixerID_from_handle(hmix,fdwInfo);
628
629 fprintf(stderr,"mixerGetLineInfo16(%04x,%p[line %08lx],%08lx)\n",
630 hmix,lpml,lpml->dwDestination,fdwInfo
631 );
632 return mixMessage(devid,MXDM_GETLINEINFO,0,(DWORD)lpml,fdwInfo);
633 }
634
635 /**************************************************************************
636 * mixerSetControlDetails [WINMM.111]
637 */
638 UINT32 WINAPI mixerSetControlDetails32(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails) {
639 fprintf(stderr,"mixerSetControlDetails32(%04x,%p,%08lx),stub!\n",
640 hmix,lpmcd,fdwDetails
641 );
642 return MMSYSERR_NOTENABLED;
643 }
644
645 /**************************************************************************
646 * mixerSetControlDetails [MMSYSTEM.809]
647 */
648 UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,LPMIXERCONTROLDETAILS16 lpmcd,DWORD fdwDetails) {
649 fprintf(stderr,"mixerSetControlDetails16(%04x,%p,%08lx),stub!\n",
650 hmix,lpmcd,fdwDetails
651 );
652 return MMSYSERR_NOTENABLED;
653 }
654
655 /**************************************************************************
656 * mixerMessage [WINMM.109]
657 */
658 UINT32 WINAPI mixerMessage32(HMIXER32 hmix,UINT32 uMsg,DWORD dwParam1,DWORD dwParam2) {
659 LPMIXEROPENDESC lpmod;
660 UINT16 uDeviceID;
661
662 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
663 if (lpmod)
664 uDeviceID = lpmod->uDeviceID;
665 else
666 uDeviceID = 0;
667 fprintf(stderr,"mixerMessage(%04lx,%d,%08lx,%08lx)\n",(DWORD)hmix,uMsg,dwParam1,dwParam2);
668 return mixMessage(uDeviceID,uMsg,0L,dwParam1,dwParam2);
669 }
670
671 /**************************************************************************
672 * mixerMessage [MMSYSTEM.804]
673 */
674 UINT16 WINAPI mixerMessage16(HMIXER16 hmix,UINT16 uMsg,DWORD dwParam1,DWORD dwParam2) {
675 LPMIXEROPENDESC lpmod;
676 UINT16 uDeviceID;
677
678 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
679 if (lpmod)
680 uDeviceID = lpmod->uDeviceID;
681 else
682 uDeviceID = 0;
683 fprintf(stderr,"mixerMessage(%04x,%d,%08lx,%08lx)\n",hmix,uMsg,dwParam1,dwParam2);
684 return mixMessage(uDeviceID,uMsg,0L,dwParam1,dwParam2);
685 }
686
687 /**************************************************************************
688 * auxGetNumDevs [WINMM.22]
689 */
690 UINT32 WINAPI auxGetNumDevs32()
691 {
692 return auxGetNumDevs16();
693 }
694
695 /**************************************************************************
696 * auxGetNumDevs [MMSYSTEM.350]
697 */
698 UINT16 WINAPI auxGetNumDevs16()
699 {
700 UINT16 count = 0;
701 dprintf_info(mmsys, "auxGetNumDevs !\n");
702 count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
703 dprintf_info(mmsys, "auxGetNumDevs return %u \n", count);
704 return count;
705 }
706
707 /**************************************************************************
708 * auxGetDevCaps [WINMM.20]
709 */
710 UINT32 WINAPI auxGetDevCaps32W(UINT32 uDeviceID,LPAUXCAPS32W lpCaps,UINT32 uSize)
711 {
712 AUXCAPS16 ac16;
713 UINT32 ret = auxGetDevCaps16(uDeviceID,&ac16,sizeof(ac16));
714
715 lpCaps->wMid = ac16.wMid;
716 lpCaps->wPid = ac16.wPid;
717 lpCaps->vDriverVersion = ac16.vDriverVersion;
718 lstrcpyAtoW(lpCaps->szPname,ac16.szPname);
719 lpCaps->wTechnology = ac16.wTechnology;
720 lpCaps->dwSupport = ac16.dwSupport;
721 return ret;
722 }
723
724 /**************************************************************************
725 * auxGetDevCaps [WINMM.21]
726 */
727 UINT32 WINAPI auxGetDevCaps32A(UINT32 uDeviceID,LPAUXCAPS32A lpCaps,UINT32 uSize)
728 {
729 AUXCAPS16 ac16;
730 UINT32 ret = auxGetDevCaps16(uDeviceID,&ac16,sizeof(ac16));
731
732 lpCaps->wMid = ac16.wMid;
733 lpCaps->wPid = ac16.wPid;
734 lpCaps->vDriverVersion = ac16.vDriverVersion;
735 strcpy(lpCaps->szPname,ac16.szPname);
736 lpCaps->wTechnology = ac16.wTechnology;
737 lpCaps->dwSupport = ac16.dwSupport;
738 return ret;
739 }
740
741 /**************************************************************************
742 * auxGetDevCaps [MMSYSTEM.351]
743 */
744 UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID,LPAUXCAPS16 lpCaps, UINT16 uSize)
745 {
746 dprintf_info(mmsys, "auxGetDevCaps(%04X, %p, %d) !\n",
747 uDeviceID, lpCaps, uSize);
748 return auxMessage(uDeviceID, AUXDM_GETDEVCAPS,
749 0L, (DWORD)lpCaps, (DWORD)uSize);
750 }
751
752 /**************************************************************************
753 * auxGetVolume [WINM.23]
754 */
755 UINT32 WINAPI auxGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
756 {
757 return auxGetVolume16(uDeviceID,lpdwVolume);
758 }
759
760 /**************************************************************************
761 * auxGetVolume [MMSYSTEM.352]
762 */
763 UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
764 {
765 dprintf_info(mmsys, "auxGetVolume(%04X, %p) !\n", uDeviceID, lpdwVolume);
766 return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
767 }
768
769 /**************************************************************************
770 * auxSetVolume [WINMM.25]
771 */
772 UINT32 WINAPI auxSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
773 {
774 return auxSetVolume16(uDeviceID,dwVolume);
775 }
776
777 /**************************************************************************
778 * auxSetVolume [MMSYSTEM.353]
779 */
780 UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
781 {
782 dprintf_info(mmsys, "auxSetVolume(%04X, %08lX) !\n", uDeviceID, dwVolume);
783 return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L);
784 }
785
786 /**************************************************************************
787 * auxOutMessage [MMSYSTEM.354]
788 */
789 DWORD WINAPI auxOutMessage32(UINT32 uDeviceID,UINT32 uMessage,DWORD dw1,DWORD dw2)
790 {
791 switch (uMessage) {
792 case AUXDM_GETNUMDEVS:
793 case AUXDM_GETVOLUME:
794 case AUXDM_SETVOLUME:
795 /* no argument conversion needed */
796 break;
797 case AUXDM_GETDEVCAPS:
798 return auxGetDevCaps32A(uDeviceID,(LPAUXCAPS32A)dw1,dw2);
799 default:
800 fprintf(stderr,"unhandled auxMessage32(%04x,%04x,%08lx,%08lx)\n",
801 uDeviceID,uMessage,dw1,dw2
802 );
803 break;
804 }
805 return auxMessage(uDeviceID,uMessage,0L,dw1,dw2);
806 }
807
808 /**************************************************************************
809 * auxOutMessage [MMSYSTEM.354]
810 */
811 DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
812 {
813 dprintf_info(mmsys, "auxOutMessage(%04X, %04X, %08lX, %08lX)\n",
814 uDeviceID, uMessage, dw1, dw2);
815 switch (uMessage) {
816 case AUXDM_GETNUMDEVS:
817 case AUXDM_SETVOLUME:
818 /* no argument conversion needed */
819 break;
820 case AUXDM_GETVOLUME:
821 return auxGetVolume16(uDeviceID,(LPDWORD)PTR_SEG_TO_LIN(dw1));
822 case AUXDM_GETDEVCAPS:
823 return auxGetDevCaps16(uDeviceID,(LPAUXCAPS16)PTR_SEG_TO_LIN(dw1),dw2);
824 default:
825 fprintf(stderr,"unhandled auxMessage32(%04x,%04x,%08lx,%08lx)\n",
826 uDeviceID,uMessage,dw1,dw2
827 );
828 break;
829 }
830 return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2);
831 }
832
833 /**************************************************************************
834 * mciGetErrorStringW [WINMM.46]
835 */
836 BOOL32 WINAPI mciGetErrorString32W(DWORD wError,LPWSTR lpstrBuffer,UINT32 uLength)
837 {
838 LPSTR bufstr = HeapAlloc(GetProcessHeap(),0,uLength);
839 BOOL32 ret = mciGetErrorString32A(wError,bufstr,uLength);
840
841 lstrcpyAtoW(lpstrBuffer,bufstr);
842 HeapFree(GetProcessHeap(),0,bufstr);
843 return ret;
844 }
845
846 /**************************************************************************
847 * mciGetErrorStringA [WINMM.45]
848 */
849 BOOL32 WINAPI mciGetErrorString32A(DWORD wError,LPSTR lpstrBuffer,UINT32 uLength)
850 {
851 return mciGetErrorString16(wError,lpstrBuffer,uLength);
852 }
853
854 /**************************************************************************
855 * mciGetErrorString [MMSYSTEM.706]
856 */
857 BOOL16 WINAPI mciGetErrorString16(DWORD wError,LPSTR lpstrBuffer,UINT16 uLength)
858 {
859 LPSTR msgptr;
860 dprintf_info(mmsys, "mciGetErrorString(%08lX, %p, %d);\n",
861 wError, lpstrBuffer, uLength);
862 if ((lpstrBuffer == NULL) || (uLength < 1)) return(FALSE);
863 lpstrBuffer[0] = '\0';
864 switch(wError) {
865 case MCIERR_INVALID_DEVICE_ID:
866 msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device.";
867 break;
868 case MCIERR_UNRECOGNIZED_KEYWORD:
869 msgptr = "The driver cannot recognize the specified command parameter.";
870 break;
871 case MCIERR_UNRECOGNIZED_COMMAND:
872 msgptr = "The driver cannot recognize the specified command.";
873 break;
874 case MCIERR_HARDWARE:
875 msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer.";
876 break;
877 case MCIERR_INVALID_DEVICE_NAME:
878 msgptr = "The specified device is not open or is not recognized by MCI.";
879 break;
880 case MCIERR_OUT_OF_MEMORY:
881 msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again.";
882 break;
883 case MCIERR_DEVICE_OPEN:
884 msgptr = "The device name is already being used as an alias by this application. Use a unique alias.";
885 break;
886 case MCIERR_CANNOT_LOAD_DRIVER:
887 msgptr = "There is an undetectable problem in loading the specified device driver.";
888 break;
889 case MCIERR_MISSING_COMMAND_STRING:
890 msgptr = "No command was specified.";
891 break;
892 case MCIERR_PARAM_OVERFLOW:
893 msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer.";
894 break;
895 case MCIERR_MISSING_STRING_ARGUMENT:
896 msgptr = "The specified command requires a character-string parameter. Please provide one.";
897 break;
898 case MCIERR_BAD_INTEGER:
899 msgptr = "The specified integer is invalid for this command.";
900 break;
901 case MCIERR_PARSER_INTERNAL:
902 msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver.";
903 break;
904 case MCIERR_DRIVER_INTERNAL:
905 msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver.";
906 break;
907 case MCIERR_MISSING_PARAMETER:
908 msgptr = "The specified command requires a parameter. Please supply one.";
909 break;
910 case MCIERR_UNSUPPORTED_FUNCTION:
911 msgptr = "The MCI device you are using does not support the specified command.";
912 break;
913 case MCIERR_FILE_NOT_FOUND:
914 msgptr = "Cannot find the specified file. Make sure the path and filename are correct.";
915 break;
916 case MCIERR_DEVICE_NOT_READY:
917 msgptr = "The device driver is not ready.";
918 break;
919 case MCIERR_INTERNAL:
920 msgptr = "A problem occurred in initializing MCI. Try restarting Windows.";
921 break;
922 case MCIERR_DRIVER:
923 msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error.";
924 break;
925 case MCIERR_CANNOT_USE_ALL:
926 msgptr = "Cannot use 'all' as the device name with the specified command.";
927 break;
928 case MCIERR_MULTIPLE:
929 msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error";
930 break;
931 case MCIERR_EXTENSION_NOT_FOUND:
932 msgptr = "Cannot determine the device type from the given filename extension.";
933 break;
934 case MCIERR_OUTOFRANGE:
935 msgptr = "The specified parameter is out of range for the specified command.";
936 break;
937 case MCIERR_FLAGS_NOT_COMPATIBLE:
938 msgptr = "The specified parameters cannot be used together.";
939 break;
940 case MCIERR_FILE_NOT_SAVED:
941 msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network.";
942 break;
943 case MCIERR_DEVICE_TYPE_REQUIRED:
944 msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly.";
945 break;
946 case MCIERR_DEVICE_LOCKED:
947 msgptr = "The specified device is now being closed. Wait a few seconds, and then try again.";
948 break;
949 case MCIERR_DUPLICATE_ALIAS:
950 msgptr = "The specified alias is already being used in this application. Use a unique alias.";
951 break;
952 case MCIERR_BAD_CONSTANT:
953 msgptr = "The specified parameter is invalid for this command.";
954 break;
955 case MCIERR_MUST_USE_SHAREABLE:
956 msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command.";
957 break;
958 case MCIERR_MISSING_DEVICE_NAME:
959 msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one.";
960 break;
961 case MCIERR_BAD_TIME_FORMAT:
962 msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats.";
963 break;
964 case MCIERR_NO_CLOSING_QUOTE:
965 msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one.";
966 break;
967 case MCIERR_DUPLICATE_FLAGS:
968 msgptr = "A parameter or value was specified twice. Only specify it once.";
969 break;
970 case MCIERR_INVALID_FILE:
971 msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format.";
972 break;
973 case MCIERR_NULL_PARAMETER_BLOCK:
974 msgptr = "A null parameter block was passed to MCI.";
975 break;
976 case MCIERR_UNNAMED_RESOURCE:
977 msgptr = "Cannot save an unnamed file. Supply a filename.";
978 break;
979 case MCIERR_NEW_REQUIRES_ALIAS:
980 msgptr = "You must specify an alias when using the 'new' parameter.";
981 break;
982 case MCIERR_NOTIFY_ON_AUTO_OPEN:
983 msgptr = "Cannot use the 'notify' flag with auto-opened devices.";
984 break;
985 case MCIERR_NO_ELEMENT_ALLOWED:
986 msgptr = "Cannot use a filename with the specified device.";
987 break;
988 case MCIERR_NONAPPLICABLE_FUNCTION:
989 msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again.";
990 break;
991 case MCIERR_ILLEGAL_FOR_AUTO_OPEN:
992 msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again.";
993 break;
994 case MCIERR_FILENAME_REQUIRED:
995 msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension.";
996 break;
997 case MCIERR_EXTRA_CHARACTERS:
998 msgptr = "Cannot specify extra characters after a string enclosed in quotation marks.";
999 break;
1000 case MCIERR_DEVICE_NOT_INSTALLED:
1001 msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device.";
1002 break;
1003 case MCIERR_GET_CD:
1004 msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer.";
1005 break;
1006 case MCIERR_SET_CD:
1007 msgptr = "Cannot access the specified file or MCI device because the application cannot change directories.";
1008 break;
1009 case MCIERR_SET_DRIVE:
1010 msgptr = "Cannot access specified file or MCI device because the application cannot change drives.";
1011 break;
1012 case MCIERR_DEVICE_LENGTH:
1013 msgptr = "Specify a device or driver name that is less than 79 characters.";
1014 break;
1015 case MCIERR_DEVICE_ORD_LENGTH:
1016 msgptr = "Specify a device or driver name that is less than 69 characters.";
1017 break;
1018 case MCIERR_NO_INTEGER:
1019 msgptr = "The specified command requires an integer parameter. Please provide one.";
1020 break;
1021 case MCIERR_WAVE_OUTPUTSINUSE:
1022 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.";
1023 break;
1024 case MCIERR_WAVE_SETOUTPUTINUSE:
1025 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.";
1026 break;
1027 case MCIERR_WAVE_INPUTSINUSE:
1028 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.";
1029 break;
1030 case MCIERR_WAVE_SETINPUTINUSE:
1031 msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again.";
1032 break;
1033 case MCIERR_WAVE_OUTPUTUNSPECIFIED:
1034 msgptr = "Any compatible waveform playback device may be used.";
1035 break;
1036 case MCIERR_WAVE_INPUTUNSPECIFIED:
1037 msgptr = "Any compatible waveform recording device may be used.";
1038 break;
1039 case MCIERR_WAVE_OUTPUTSUNSUITABLE:
1040 msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device.";
1041 break;
1042 case MCIERR_WAVE_SETOUTPUTUNSUITABLE:
1043 msgptr = "The device you are trying to play to cannot recognize the current file format.";
1044 break;
1045 case MCIERR_WAVE_INPUTSUNSUITABLE:
1046 msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device.";
1047 break;
1048 case MCIERR_WAVE_SETINPUTUNSUITABLE:
1049 msgptr = "The device you are trying to record from cannot recognize the current file format.";
1050 break;
1051 case MCIERR_NO_WINDOW:
1052 msgptr = "There is no display window.";
1053 break;
1054 case MCIERR_CREATEWINDOW:
1055 msgptr = "Could not create or use window.";
1056 break;
1057 case MCIERR_FILE_READ:
1058 msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection.";
1059 break;
1060 case MCIERR_FILE_WRITE:
1061 msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network.";
1062 break;
1063 case MCIERR_SEQ_DIV_INCOMPATIBLE:
1064 msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together.";
1065 break;
1066 case MCIERR_SEQ_NOMIDIPRESENT:
1067 msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver.";
1068 break;
1069 case MCIERR_SEQ_PORT_INUSE:
1070 msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again.";
1071 break;
1072 case MCIERR_SEQ_PORT_MAPNODEVICE:
1073 msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup.";
1074 break;
1075 case MCIERR_SEQ_PORT_MISCERROR:
1076 msgptr = "An error occurred with the specified port.";
1077 break;
1078 case MCIERR_SEQ_PORT_NONEXISTENT:
1079 msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device.";
1080 break;
1081 case MCIERR_SEQ_PORTUNSPECIFIED:
1082 msgptr = "The system doesnot have a current MIDI port specified.";
1083 break;
1084 case MCIERR_SEQ_TIMER:
1085 msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again.";
1086 break;
1087
1088 /*
1089 msg# 513 : vcr
1090 msg# 514 : videodisc
1091 msg# 515 : overlay
1092 msg# 516 : cdaudio
1093 msg# 517 : dat
1094 msg# 518 : scanner
1095 msg# 519 : animation
1096 msg# 520 : digitalvideo
1097 msg# 521 : other
1098 msg# 522 : waveaudio
1099 msg# 523 : sequencer
1100 msg# 524 : not ready
1101 msg# 525 : stopped
1102 msg# 526 : playing
1103 msg# 527 : recording
1104 msg# 528 : seeking
1105 msg# 529 : paused
1106 msg# 530 : open
1107 msg# 531 : false
1108 msg# 532 : true
1109 msg# 533 : milliseconds
1110 msg# 534 : hms
1111 msg# 535 : msf
1112 msg# 536 : frames
1113 msg# 537 : smpte 24
1114 msg# 538 : smpte 25
1115 msg# 539 : smpte 30
1116 msg# 540 : smpte 30 drop
1117 msg# 541 : bytes
1118 msg# 542 : samples
1119 msg# 543 : tmsf
1120 */
1121 default:
1122 msgptr = "Unknown MCI Error !\n";
1123 break;
1124 }
1125 lstrcpyn32A(lpstrBuffer, msgptr, uLength);
1126 dprintf_info(mmsys, "mciGetErrorString // msg = %s;\n", msgptr);
1127 return TRUE;
1128 }
1129
1130
1131 /**************************************************************************
1132 * mciDriverNotify [MMSYSTEM.711]
1133 */
1134 BOOL16 WINAPI mciDriverNotify(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
1135 {
1136 dprintf_info(mmsys, "mciDriverNotify(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
1137 if (!IsWindow32(hWndCallBack)) return FALSE;
1138 dprintf_info(mmsys, "mciDriverNotify // before PostMessage\n");
1139 PostMessage16( hWndCallBack, MM_MCINOTIFY, wStatus,
1140 MAKELONG(wDevID, 0));
1141 return TRUE;
1142 }
1143
1144 /**************************************************************************
1145 * mciOpen [internal]
1146 */
1147
1148 DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS16 lp16Parms)
1149 {
1150 char str[128];
1151 LPMCI_OPEN_PARMS16 lpParms;
1152 UINT16 uDevTyp = 0;
1153 UINT16 wDevID = MMSYSTEM_FirstDevID();
1154 DWORD dwret;
1155
1156 lpParms = PTR_SEG_TO_LIN(lp16Parms);
1157 dprintf_info(mmsys, "mciOpen(%08lX, %p (%p))\n", dwParam, lp16Parms, lpParms);
1158 if (lp16Parms == NULL) return MCIERR_INTERNAL;
1159
1160 while(GetDrv(wDevID)->modp.wType != 0) {
1161 wDevID = MMSYSTEM_NextDevID(wDevID);
1162 if (!MMSYSTEM_DevIDValid(wDevID)) {
1163 dprintf_info(mmsys, "MCI_OPEN // MAXMCIDRIVERS reached !\n");
1164 return MCIERR_INTERNAL;
1165 }
1166 }
1167 dprintf_info(mmsys, "mciOpen // wDevID=%04X \n", wDevID);
1168 memcpy(GetOpenDrv(wDevID),lpParms,sizeof(*lpParms));
1169
1170 if (dwParam & MCI_OPEN_ELEMENT) {
1171 char *s,*t;
1172
1173 dprintf_info(mmsys,"mciOpen // lpstrElementName='%s'\n",
1174 (char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName)
1175 );
1176 s=(char*)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
1177 t=strrchr(s,'.');
1178 if (t) {
1179 GetProfileString32A("mci extensions",t+1,"*",str,sizeof(str));
1180 CharUpper32A(str);
1181 dprintf_info(mmsys, "mciOpen // str = %s \n", str);
1182 if (strcmp(str, "CDAUDIO") == 0) {
1183 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
1184 } else
1185 if (strcmp(str, "WAVEAUDIO") == 0) {
1186 uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
1187 } else
1188 if (strcmp(str, "SEQUENCER") == 0) {
1189 uDevTyp = MCI_DEVTYPE_SEQUENCER;
1190 } else
1191 if (strcmp(str, "ANIMATION1") == 0) {
1192 uDevTyp = MCI_DEVTYPE_ANIMATION;
1193 } else
1194 if (strcmp(str, "AVIVIDEO") == 0) {
1195 uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
1196 } else
1197 if (strcmp(str,"*") == 0) {
1198 dprintf_info(mmsys,"No [mci extensions] entry for %s found.\n",t);
1199 return MCIERR_EXTENSION_NOT_FOUND;
1200 #if testing16
1201 } else {
1202 HDRVR16 hdrv = OpenDriver(str,"mci",NULL);
1203 if (hdrv) {
1204 HMODULE16 hmod;
1205
1206 hmod = GetDriverModuleHandle(hdrv);
1207 GetDrv(wDevID)->hdrv = hdrv;
1208 GetDrv(wDevID)->driverproc = GetProcAddress16(hmod,SEGPTR_GET(SEGPTR_STRDUP("DRIVERPROC")));
1209 uDevTyp = MCI_DEVTYPE_OTHER;
1210 } else {
1211 dprintf_fixme(mmsys, "[mci extensions] entry %s for %s not supported.\n",str,t);
1212 return MCIERR_DEVICE_NOT_INSTALLED;
1213 }
1214 #endif
1215 }
1216 } else
1217 return MCIERR_EXTENSION_NOT_FOUND;
1218 }
1219
1220 if (dwParam & MCI_OPEN_ALIAS) {
1221 dprintf_info(mmsys, "MCI_OPEN // Alias='%s' !\n",
1222 (char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias));
1223 GetOpenDrv(wDevID)->lpstrAlias = (LPSTR)SEGPTR_GET(
1224 SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrAlias)));
1225 /* mplayer does allocate alias to CDAUDIO */
1226 }
1227 if (dwParam & MCI_OPEN_TYPE) {
1228 if (dwParam & MCI_OPEN_TYPE_ID) {
1229 dprintf_info(mmsys, "MCI_OPEN // Dev=%08lx!\n", (DWORD)lpParms->lpstrDeviceType);
1230 uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType);
1231 GetOpenDrv(wDevID)->lpstrDeviceType=(LPSTR)lpParms->lpstrDeviceType;
1232 } else {
1233 if (lpParms->lpstrDeviceType == NULL) return MCIERR_INTERNAL;
1234 dprintf_info(mmsys, "MCI_OPEN // Dev='%s' !\n",
1235 (char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType));
1236 GetOpenDrv(wDevID)->lpstrDeviceType=(LPSTR)SEGPTR_GET(
1237 SEGPTR_STRDUP((char*)PTR_SEG_TO_LIN(lpParms->lpstrDeviceType)));
1238 strcpy(str, PTR_SEG_TO_LIN(lpParms->lpstrDeviceType));
1239 CharUpper32A(str);
1240 if (strcmp(str, "CDAUDIO") == 0) {
1241 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
1242 } else
1243 if (strcmp(str, "WAVEAUDIO") == 0) {
1244 uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
1245 } else
1246 if (strcmp(str, "SEQUENCER") == 0) {
1247 uDevTyp = MCI_DEVTYPE_SEQUENCER;
1248 } else
1249 if (strcmp(str, "ANIMATION1") == 0) {
1250 uDevTyp = MCI_DEVTYPE_ANIMATION;
1251 } else
1252 if (strcmp(str, "AVIVIDEO") == 0) {
1253 uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
1254 } else {
1255 #if testing16
1256 HDRVR16 hdrv;
1257 fprintf(stderr,"trying to load driver...\n");
1258 hdrv = OpenDriver(str,"mci",NULL);
1259 if (hdrv) {
1260 HMODULE16 hmod;
1261
1262 hmod = GetDriverModuleHandle(hdrv);
1263 GetDrv(wDevID)->hdrv = hdrv;
1264 GetDrv(wDevID)->driverproc = GetProcAddress16(hmod,SEGPTR_GET(SEGPTR_STRDUP("DRIVERPROC")));
1265 uDevTyp = MCI_DEVTYPE_OTHER;
1266 } else
1267 #endif
1268 return MCIERR_DEVICE_NOT_INSTALLED;
1269 }
1270 }
1271 }
1272 GetDrv(wDevID)->modp.wType = uDevTyp;
1273 GetDrv(wDevID)->modp.wDeviceID = 0; /* FIXME? for multiple devices */
1274 lpParms->wDeviceID = wDevID;
1275 dprintf_info(mmsys, "MCI_OPEN // mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
1276 wDevID, uDevTyp, lpParms->wDeviceID);
1277 switch(uDevTyp)
1278 {
1279 case MCI_DEVTYPE_CD_AUDIO:
1280 dwret = CDAUDIO_DriverProc( 0, 0, MCI_OPEN_DRIVER,
1281 dwParam, (DWORD)lp16Parms);
1282 break;
1283 case MCI_DEVTYPE_WAVEFORM_AUDIO:
1284 dwret = WAVE_DriverProc( 0, 0, MCI_OPEN_DRIVER,
1285 dwParam, (DWORD)lp16Parms);
1286 break;
1287 case MCI_DEVTYPE_SEQUENCER:
1288 dwret = MIDI_DriverProc( 0, 0, MCI_OPEN_DRIVER,
1289 dwParam, (DWORD)lp16Parms);
1290 break;
1291 case MCI_DEVTYPE_ANIMATION:
1292 dwret = ANIM_DriverProc( 0, 0, MCI_OPEN_DRIVER,
1293 dwParam, (DWORD)lp16Parms);
1294 break;
1295 case MCI_DEVTYPE_DIGITAL_VIDEO:
1296 dprintf_info(mmsys, "MCI_OPEN // No DIGITAL_VIDEO yet !\n");
1297 return MCIERR_DEVICE_NOT_INSTALLED;
1298 default:
1299 #if testing16
1300 dwret = Callbacks->CallDriverProc(GetDrv(wDevID)->driverproc,0,GetDrv(wDevID)->hdrv,MCI_OPEN_DRIVER,dwParam,(DWORD)lp16Parms);
1301 dprintf_warn(mmsys, "MCI_OPEN // Invalid Device Name '%08lx' !\n", (DWORD)lpParms->lpstrDeviceType);
1302 #endif
1303 return MCIERR_INVALID_DEVICE_NAME;
1304 }
1305
1306
1307 if (dwParam&MCI_NOTIFY)
1308 mciDriverNotify(lpParms->dwCallback,wDevID,
1309 (dwret==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
1310
1311 /* only handled devices fall through */
1312 dprintf_info(mmsys, "MCI_OPEN // wDevID = %04X wDeviceID = %d dwret = %ld\n",wDevID, lpParms->wDeviceID, dwret);
1313 return dwret;
1314 }
1315
1316 /**************************************************************************
1317 * mciGetDriverData [MMSYSTEM.708]
1318 */
1319 DWORD WINAPI mciGetDriverData16(HDRVR16 hdrv) {
1320 fprintf(stderr,"mciGetDriverData(%04x),stub!\n",hdrv);
1321 return 0x42;
1322 }
1323
1324 /**************************************************************************
1325 * mciSetDriverData [MMSYSTEM.707]
1326 */
1327 DWORD WINAPI mciSetDriverData16(HDRVR16 hdrv,DWORD data) {
1328 fprintf(stderr,"mciSetDriverData(%04x,%08lx),stub!\n",hdrv,data);
1329 return 0;
1330 }
1331
1332 /**************************************************************************
1333 * mciClose [internal]
1334 */
1335 DWORD mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
1336 {
1337 DWORD dwRet = MCIERR_INTERNAL;
1338
1339 dprintf_info(mmsys, "mciClose(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
1340 switch(GetDrv(wDevID)->modp.wType) {
1341 case MCI_DEVTYPE_CD_AUDIO:
1342 dwRet = CDAUDIO_DriverProc(GetDrv(wDevID)->modp.wDeviceID,0,
1343 MCI_CLOSE, dwParam, (DWORD)lpParms);
1344 break;
1345 case MCI_DEVTYPE_WAVEFORM_AUDIO:
1346 dwRet = WAVE_DriverProc(GetDrv(wDevID)->modp.wDeviceID, 0,
1347 MCI_CLOSE, dwParam,
1348 (DWORD)lpParms);
1349 break;
1350 case MCI_DEVTYPE_SEQUENCER:
1351 dwRet = MIDI_DriverProc(GetDrv(wDevID)->modp.wDeviceID, 0,
1352 MCI_CLOSE, dwParam,
1353 (DWORD)lpParms);
1354 break;
1355 /*
1356 case MCI_DEVTYPE_ANIMATION:
1357 dwRet = ANIM_DriverProc(GetDrv(wDevID)->modp.wDeviceID, 0,
1358 MCI_CLOSE, dwParam,
1359 (DWORD)lpParms);
1360 break;
1361 */
1362 default:
1363 dwRet = Callbacks->CallDriverProc(GetDrv(wDevID)->driverproc,GetDrv(wDevID)->modp.wDeviceID,GetDrv(wDevID)->hdrv,MCI_CLOSE,dwParam,(DWORD)lpParms);
1364 }
1365 GetDrv(wDevID)->modp.wType = 0;
1366
1367 if (dwParam&MCI_NOTIFY)
1368 mciDriverNotify(lpParms->dwCallback,wDevID,
1369 (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
1370
1371 dprintf_info(mmsys, "mciClose() // returns %ld\n",dwRet);
1372 return dwRet;
1373 }
1374
1375
1376 /**************************************************************************
1377 * mciSysinfo [internal]
1378 */
1379 DWORD mciSysInfo(DWORD dwFlags, LPMCI_SYSINFO_PARMS16 lpParms)
1380 {
1381 int len;
1382 LPSTR ptr;
1383 LPSTR lpstrReturn;
1384 DWORD *lpdwRet;
1385 LPSTR SysFile = "SYSTEM.INI";
1386 dprintf_info(mci, "mciSysInfo(%08lX, %08lX)\n", dwFlags, (DWORD)lpParms);
1387 lpstrReturn = PTR_SEG_TO_LIN(lpParms->lpstrReturn);
1388 switch(dwFlags) {
1389 case MCI_SYSINFO_QUANTITY:
1390 dprintf_info(mci, "mciSysInfo // MCI_SYSINFO_QUANTITY \n");
1391 lpdwRet = (DWORD *)lpstrReturn;
1392 *(lpdwRet) = InstalledCount;
1393 return 0;
1394 case MCI_SYSINFO_INSTALLNAME:
1395 dprintf_info(mci, "mciSysInfo // MCI_SYSINFO_INSTALLNAME \n");
1396 if (lpInstallNames == NULL) {
1397 InstalledCount = 0;
1398 InstalledListLen = 0;
1399 ptr = lpInstallNames = xmalloc(2048);
1400 GetPrivateProfileString32A("mci", NULL, "", lpInstallNames, 2000, SysFile);
1401 while(strlen(ptr) > 0) {
1402 dprintf_info(mci, "---> '%s' \n", ptr);
1403 len = strlen(ptr) + 1;
1404 ptr += len;
1405 InstalledListLen += len;
1406 InstalledCount++;
1407 }
1408 }
1409 if (lpParms->dwRetSize < InstalledListLen)
1410 lstrcpyn32A(lpstrReturn, lpInstallNames, lpParms->dwRetSize - 1);
1411 else
1412 strcpy(lpstrReturn, lpInstallNames);
1413 return 0;
1414 case MCI_SYSINFO_NAME:
1415 dprintf_info(mci, "mciSysInfo // MCI_SYSINFO_NAME \n");
1416 return 0;
1417 case MCI_SYSINFO_OPEN:
1418 dprintf_info(mci, "mciSysInfo // MCI_SYSINFO_OPEN \n");
1419 return 0;
1420 }
1421 return MMSYSERR_INVALPARAM;
1422 }
1423
1424 /**************************************************************************
1425 * mciLoadCommandResource
1426 */
1427 UINT16 mciLoadCommandResource16(HANDLE16 hinst,LPCSTR resname,UINT16 type)
1428 {
1429 char buf[200];
1430 OFSTRUCT ofs;
1431 HANDLE16 xhinst;
1432 HRSRC16 hrsrc;
1433 HGLOBAL16 hmem;
1434 LPSTR segstr;
1435 SEGPTR xmem;
1436 LPBYTE lmem;
1437 static mcidevtype = 0;
1438
1439 fprintf(stderr,"mciLoadCommandResource16(%04x,%s,%d),stub!\n",
1440 hinst,resname,type
1441 );
1442 if (!lstrcmpi32A(resname,"core")) {
1443 fprintf(stderr,"mciLoadCommandResource(...,\"core\",...), have to use internal tables... (not there yet)\n");
1444 return 0;
1445 }
1446 /* if file exists "resname.mci", then load resource "resname" from it
1447 * otherwise directly from driver
1448 */
1449 strcpy(buf,resname);
1450 strcat(buf,".mci");
1451 if (OpenFile32(buf,&ofs,OF_EXIST)!=HFILE_ERROR32) {
1452 xhinst = LoadLibrary16(buf);
1453 if (xhinst >32)
1454 hinst = xhinst;
1455 } /* else use passed hinst */
1456 segstr = SEGPTR_STRDUP(resname);
1457 hrsrc = FindResource16(hinst,SEGPTR_GET(segstr),type);
1458 SEGPTR_FREE(segstr);
1459 if (!hrsrc) {
1460 fprintf(stderr,"mciLoadCommandResource:no special commandlist found in resource\n");
1461 return MCI_NO_COMMAND_TABLE;
1462 }
1463 hmem = LoadResource16(hinst,hrsrc);
1464 if (!hmem) {
1465 fprintf(stderr,"mciLoadCommandResource:couldn't load resource??\n");
1466 return MCI_NO_COMMAND_TABLE;
1467 }
1468 xmem = WIN16_LockResource16(hmem);
1469 if (!xmem) {
1470 fprintf(stderr,"mciLoadCommandResource:couldn't lock resource??\n");
1471 FreeResource16(hmem);
1472 return MCI_NO_COMMAND_TABLE;
1473 }
1474 lmem = PTR_SEG_TO_LIN(xmem);
1475 fprintf(stderr,"first resource entry is %s\n",(char*)lmem);
1476 /* parse resource, register stuff, return unique id */
1477 return ++mcidevtype;
1478 }
1479
1480
1481 /**************************************************************************
1482 * mciSound [internal]
1483 * not used anymore ??
1484
1485 DWORD mciSound(UINT16 wDevID, DWORD dwParam, LPMCI_SOUND_PARMS lpParms)
1486 {
1487 if (lpParms == NULL) return MCIERR_INTERNAL;
1488 if (dwParam & MCI_SOUND_NAME)
1489 dprintf_info(mci, "MCI_SOUND // file='%s' !\n", lpParms->lpstrSoundName);
1490 return MCIERR_INVALID_DEVICE_ID;
1491 }
1492 *
1493 */
1494
1495 static const char *_mciCommandToString(UINT16 wMsg)
1496 {
1497 static char buffer[100];
1498
1499 #define CASE(s) case (s): return #s
1500
1501 switch (wMsg) {
1502 CASE(MCI_OPEN);
1503 CASE(MCI_CLOSE);
1504 CASE(MCI_ESCAPE);
1505 CASE(MCI_PLAY);
1506 CASE(MCI_SEEK);
1507 CASE(MCI_STOP);
1508 CASE(MCI_PAUSE);
1509 CASE(MCI_INFO);
1510 CASE(MCI_GETDEVCAPS);
1511 CASE(MCI_SPIN);
1512 CASE(MCI_SET);
1513 CASE(MCI_STEP);
1514 CASE(MCI_RECORD);
1515 CASE(MCI_SYSINFO);
1516 CASE(MCI_BREAK);
1517 CASE(MCI_SAVE);
1518 CASE(MCI_STATUS);
1519 CASE(MCI_CUE);
1520 CASE(MCI_REALIZE);
1521 CASE(MCI_WINDOW);
1522 CASE(MCI_PUT);
1523 CASE(MCI_WHERE);
1524 CASE(MCI_FREEZE);
1525 CASE(MCI_UNFREEZE);
1526 CASE(MCI_LOAD);
1527 CASE(MCI_CUT);
1528 CASE(MCI_COPY);
1529 CASE(MCI_PASTE);
1530 CASE(MCI_UPDATE);
1531 CASE(MCI_RESUME);
1532 CASE(MCI_DELETE);
1533 default:
1534 sprintf(buffer, "%04X", wMsg);
1535 return buffer;
1536
1537 }
1538 }
1539
1540 /**************************************************************************
1541 * mciSendCommandA [WINMM.49]
1542 */
1543 DWORD WINAPI mciSendCommand32A(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1,
1544 DWORD dwParam2)
1545 {
1546 fprintf(stderr,"mciSendCommand32A(%08x,%s,%08lx,%08lx),stub!\n",
1547 wDevID,_mciCommandToString(wMsg),dwParam1,dwParam2
1548 );
1549 switch (wMsg) {
1550 case MCI_OPEN: {
1551 LPMCI_OPEN_PARMS32A lpmop = (LPMCI_OPEN_PARMS32A)dwParam2;
1552 fprintf(stderr," MCI_OPEN(%s,%s,%s)\n",
1553 (dwParam1&MCI_OPEN_TYPE) ?lpmop->lpstrDeviceType:"<null>",
1554 (dwParam1&MCI_OPEN_ELEMENT)?(HIWORD(lpmop->lpstrElementName)?lpmop->lpstrElementName:"<id>"):"<null>",
1555 (dwParam1&MCI_OPEN_ALIAS) ?lpmop->lpstrAlias:"<null>"
1556 );
1557 break;
1558 }
1559 }
1560 return 0x1; /* !ok */
1561 }
1562 /**************************************************************************
1563 * mciSendCommand [MMSYSTEM.701]
1564 */
1565 DWORD WINAPI mciSendCommand(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1,
1566 DWORD dwParam2)
1567 {
1568 HDRVR16 hDrv = 0;
1569 dprintf_info(mci, "mciSendCommand(%04X, %s, %08lX, %08lX)\n",
1570 wDevID, _mciCommandToString(wMsg), dwParam1, dwParam2);
1571 switch(wMsg)
1572 {
1573 case MCI_OPEN:
1574 return mciOpen(dwParam1, (LPMCI_OPEN_PARMS16)dwParam2);
1575 case MCI_CLOSE:
1576 return mciClose( wDevID, dwParam1,
1577 (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
1578 case MCI_SYSINFO:
1579 return mciSysInfo( dwParam1,
1580 (LPMCI_SYSINFO_PARMS16)PTR_SEG_TO_LIN(dwParam2));
1581 default:
1582 switch(GetDrv(wDevID)->modp.wType)
1583 {
1584 case MCI_DEVTYPE_CD_AUDIO:
1585 return CDAUDIO_DriverProc(GetDrv(wDevID)->modp.wDeviceID, hDrv,
1586 wMsg, dwParam1, dwParam2);
1587 case MCI_DEVTYPE_WAVEFORM_AUDIO:
1588 return WAVE_DriverProc(GetDrv(wDevID)->modp.wDeviceID, hDrv,
1589 wMsg, dwParam1, dwParam2);
1590 case MCI_DEVTYPE_SEQUENCER:
1591 return MIDI_DriverProc(GetDrv(wDevID)->modp.wDeviceID, hDrv,
1592 wMsg, dwParam1, dwParam2);
1593 /*
1594 case MCI_DEVTYPE_ANIMATION:
1595 return ANIM_DriverProc(GetDrv(wDevID)->modp.wDeviceID, hDrv,
1596 wMsg, dwParam1, dwParam2);
1597 */
1598 default:
1599 return Callbacks->CallDriverProc(GetDrv(wDevID)->driverproc,GetDrv(wDevID)->modp.wDeviceID,GetDrv(wDevID)->hdrv,MCI_CLOSE,dwParam1,dwParam2);
1600
1601 dprintf_warn(mci,
1602 "mciSendCommand() // unknown device type=%04X !\n",
1603 GetDrv(wDevID)->modp.wType);
1604 }
1605 }
1606 return MMSYSERR_INVALPARAM;
1607 }
1608
1609 /**************************************************************************
1610 * mciGetDeviceID [MMSYSTEM.703]
1611 */
1612 UINT16 WINAPI mciGetDeviceID (LPCSTR lpstrName)
1613 {
1614 UINT16 wDevID;
1615
1616 dprintf_info(mci, "mciGetDeviceID(\"%s\")\n", lpstrName);
1617 if (lpstrName && !lstrcmpi32A(lpstrName, "ALL"))
1618 return MCI_ALL_DEVICE_ID;
1619
1620 if (!lpstrName)
1621 return 0;
1622
1623 wDevID = MMSYSTEM_FirstDevID();
1624 while(MMSYSTEM_DevIDValid(wDevID) && GetDrv(wDevID)->modp.wType) {
1625 if (GetOpenDrv(wDevID)->lpstrDeviceType &&
1626 strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrDeviceType), lpstrName) == 0)
1627 return wDevID;
1628
1629 if (GetOpenDrv(wDevID)->lpstrAlias &&
1630 strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrAlias), lpstrName) == 0)
1631 return wDevID;
1632
1633 wDevID = MMSYSTEM_NextDevID(wDevID);
1634 }
1635
1636 return 0;
1637 }
1638
1639 /**************************************************************************
1640 * mciSetYieldProc [MMSYSTEM.714]
1641 */
1642 BOOL16 WINAPI mciSetYieldProc (UINT16 uDeviceID,
1643 YIELDPROC fpYieldProc, DWORD dwYieldData)
1644 {
1645 return FALSE;
1646 }
1647
1648 /**************************************************************************
1649 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
1650 */
1651 UINT16 WINAPI mciGetDeviceIDFromElementID(DWORD dwElementID, LPCSTR lpstrType)
1652 {
1653 return 0;
1654 }
1655
1656 /**************************************************************************
1657 * mciGetYieldProc [MMSYSTEM.716]
1658 */
1659 YIELDPROC WINAPI mciGetYieldProc(UINT16 uDeviceID, DWORD * lpdwYieldData)
1660 {
1661 return NULL;
1662 }
1663
1664 /**************************************************************************
1665 * mciGetCreatorTask [MMSYSTEM.717]
1666 */
1667 HTASK16 WINAPI mciGetCreatorTask(UINT16 uDeviceID)
1668 {
1669 return 0;
1670 }
1671
1672 /**************************************************************************
1673 * midiOutGetNumDevs [WINMM.80]
1674 */
1675 UINT32 WINAPI midiOutGetNumDevs32(void)
1676 {
1677 return midiOutGetNumDevs16();
1678 }
1679 /**************************************************************************
1680 * midiOutGetNumDevs [MMSYSTEM.201]
1681 */
1682 UINT16 WINAPI midiOutGetNumDevs16(void)
1683 {
1684 UINT16 count = 0;
1685 dprintf_info(mmsys, "midiOutGetNumDevs\n");
1686 count += modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
1687 dprintf_info(mmsys, "midiOutGetNumDevs return %u \n", count);
1688 return count;
1689 }
1690
1691 /**************************************************************************
1692 * midiOutGetDevCapsW [WINMM.76]
1693 */
1694 UINT32 WINAPI midiOutGetDevCaps32W(UINT32 uDeviceID,LPMIDIOUTCAPS32W lpCaps, UINT32 uSize)
1695 {
1696 MIDIOUTCAPS16 moc16;
1697 UINT32 ret;
1698
1699 ret = midiOutGetDevCaps16(uDeviceID,&moc16,sizeof(moc16));
1700 lpCaps->wMid = moc16.wMid;
1701 lpCaps->wPid = moc16.wPid;
1702 lpCaps->vDriverVersion = moc16.vDriverVersion;
1703 lstrcpyAtoW(lpCaps->szPname,moc16.szPname);
1704 lpCaps->wTechnology = moc16.wTechnology;
1705 lpCaps->wVoices = moc16.wVoices;
1706 lpCaps->wNotes = moc16.wNotes;
1707 lpCaps->wChannelMask = moc16.wChannelMask;
1708 lpCaps->dwSupport = moc16.dwSupport;
1709 return ret;
1710 }
1711 /**************************************************************************
1712 * midiOutGetDevCapsA [WINMM.75]
1713 */
1714 UINT32 WINAPI midiOutGetDevCaps32A(UINT32 uDeviceID,LPMIDIOUTCAPS32A lpCaps, UINT32 uSize)
1715 {
1716 MIDIOUTCAPS16 moc16;
1717 UINT32 ret;
1718
1719 ret = midiOutGetDevCaps16(uDeviceID,&moc16,sizeof(moc16));
1720 lpCaps->wMid = moc16.wMid;
1721 lpCaps->wPid = moc16.wPid;
1722 lpCaps->vDriverVersion = moc16.vDriverVersion;
1723 strcpy(lpCaps->szPname,moc16.szPname);
1724 lpCaps->wTechnology = moc16.wTechnology;
1725 lpCaps->wVoices = moc16.wVoices;
1726 lpCaps->wNotes = moc16.wNotes;
1727 lpCaps->wChannelMask = moc16.wChannelMask;
1728 lpCaps->dwSupport = moc16.dwSupport;
1729 return ret;
1730 }
1731
1732 /**************************************************************************
1733 * midiOutGetDevCaps [MMSYSTEM.202]
1734 */
1735 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID,LPMIDIOUTCAPS16 lpCaps, UINT16 uSize)
1736 {
1737 dprintf_info(mmsys, "midiOutGetDevCaps\n");
1738 return modMessage(uDeviceID,MODM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);
1739 }
1740
1741 /**************************************************************************
1742 * midiOutGetErrorTextA [WINMM.77]
1743 */
1744 UINT32 WINAPI midiOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
1745 {
1746 dprintf_info(mmsys, "midiOutGetErrorText\n");
1747 return midiGetErrorText(uError, lpText, uSize);
1748 }
1749
1750 /**************************************************************************
1751 * midiOutGetErrorTextW [WINMM.78]
1752 */
1753 UINT32 WINAPI midiOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
1754 {
1755 LPSTR xstr = HeapAlloc(GetProcessHeap(),0,uSize);
1756 UINT32 ret;
1757
1758 dprintf_info(mmsys, "midiOutGetErrorText\n");
1759 ret = midiGetErrorText(uError, xstr, uSize);
1760 lstrcpyAtoW(lpText,xstr);
1761 HeapFree(GetProcessHeap(),0,xstr);
1762 return ret;
1763 }
1764 /**************************************************************************
1765 * midiOutGetErrorText [MMSYSTEM.203]
1766 */
1767 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
1768 {
1769 dprintf_info(mmsys, "midiOutGetErrorText\n");
1770 return midiGetErrorText(uError, lpText, uSize);
1771 }
1772
1773 /**************************************************************************
1774 * midiGetErrorText [internal]
1775 */
1776 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1777 {
1778 LPSTR msgptr;
1779 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1780 lpText[0] = '\0';
1781 switch(uError) {
1782 case MIDIERR_UNPREPARED:
1783 msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1784 break;
1785 case MIDIERR_STILLPLAYING:
1786 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1787 break;
1788 case MIDIERR_NOMAP:
1789 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.";
1790 break;
1791 case MIDIERR_NOTREADY:
1792 msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
1793 break;
1794 case MIDIERR_NODEVICE:
1795 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.";
1796 break;
1797 case MIDIERR_INVALIDSETUP:
1798 msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
1799 break;
1800 /*
1801 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
1802 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
1803 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
1804 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.
1805 msg# 340 : An error occurred using the specified port.
1806 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
1807 msg# 342 : There is no current MIDI port.
1808 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
1809 */
1810 default:
1811 msgptr = "Unknown MIDI Error !\n";
1812 break;
1813 }
1814 lstrcpyn32A(lpText, msgptr, uSize);
1815 return TRUE;
1816 }
1817
1818 /**************************************************************************
1819 * midiOutOpen [WINM.84]
1820 */
1821 UINT32 WINAPI midiOutOpen32(HMIDIOUT32 * lphMidiOut, UINT32 uDeviceID,
1822 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1823 {
1824 HMIDIOUT16 hmo16;
1825 UINT32 ret;
1826
1827 ret = midiOutOpen16(&hmo16,uDeviceID,dwCallback,dwInstance,dwFlags);
1828 if (lphMidiOut) *lphMidiOut = hmo16;
1829 return ret;
1830 }
1831 /**************************************************************************
1832 * midiOutOpen [MMSYSTEM.204]
1833 */
1834 UINT16 WINAPI midiOutOpen16(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
1835 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1836 {
1837 HMIDI16 hMidiOut;
1838 LPMIDIOPENDESC lpDesc;
1839 DWORD dwRet = 0;
1840 BOOL32 bMapperFlg = FALSE;
1841 if (lphMidiOut != NULL) *lphMidiOut = 0;
1842 dprintf_info(mmsys, "midiOutOpen(%p, %d, %08lX, %08lX, %08lX);\n",
1843 lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
1844 if (uDeviceID == (UINT16)MIDI_MAPPER) {
1845 dprintf_info(mmsys, "midiOutOpen // MIDI_MAPPER mode requested !\n");
1846 bMapperFlg = TRUE;
1847 uDeviceID = 0;
1848 }
1849 hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1850 if (lphMidiOut != NULL) *lphMidiOut = hMidiOut;
1851 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1852 if (lpDesc == NULL)
1853 return MMSYSERR_NOMEM;
1854 lpDesc->hMidi = hMidiOut;
1855 lpDesc->dwCallback = dwCallback;
1856 lpDesc->dwInstance = dwInstance;
1857 while(uDeviceID < MAXMIDIDRIVERS) {
1858 dwRet = modMessage(uDeviceID, MODM_OPEN,
1859 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
1860 if (dwRet == MMSYSERR_NOERROR) break;
1861 if (!bMapperFlg) break;
1862 uDeviceID++;
1863 dprintf_info(mmsys, "midiOutOpen // MIDI_MAPPER mode ! try next driver...\n");
1864 }
1865 return dwRet;
1866 }
1867
1868 /**************************************************************************
1869 * midiOutClose [WINMM.74]
1870 */
1871 UINT32 WINAPI midiOutClose32(HMIDIOUT32 hMidiOut)
1872 {
1873 return midiOutClose16(hMidiOut);
1874 }
1875
1876 /**************************************************************************
1877 * midiOutClose [MMSYSTEM.205]
1878 */
1879 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
1880 {
1881 LPMIDIOPENDESC lpDesc;
1882 dprintf_info(mmsys, "midiOutClose(%04X)\n", hMidiOut);
1883 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1884 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1885 return modMessage(0, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1886 }
1887
1888 /**************************************************************************
1889 * midiOutPrepareHeader [WINMM.85]
1890 */
1891 UINT32 WINAPI midiOutPrepareHeader32(HMIDIOUT32 hMidiOut,
1892 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
1893 {
1894 return midiOutPrepareHeader16(hMidiOut,lpMidiOutHdr,uSize);
1895 }
1896
1897 /**************************************************************************
1898 * midiOutPrepareHeader [MMSYSTEM.206]
1899 */
1900 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,
1901 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1902 {
1903 LPMIDIOPENDESC lpDesc;
1904 dprintf_info(mmsys, "midiOutPrepareHeader(%04X, %p, %d)\n",
1905 hMidiOut, lpMidiOutHdr, uSize);
1906 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1907 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1908 return modMessage(0, MODM_PREPARE, lpDesc->dwInstance,
1909 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1910 }
1911
1912 /**************************************************************************
1913 * midiOutUnprepareHeader [WINMM.89]
1914 */
1915 UINT32 WINAPI midiOutUnprepareHeader32(HMIDIOUT32 hMidiOut,
1916 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
1917 {
1918 return midiOutUnprepareHeader16(hMidiOut,lpMidiOutHdr,uSize);
1919 }
1920 /**************************************************************************
1921 * midiOutUnprepareHeader [MMSYSTEM.207]
1922 */
1923 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,
1924 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1925 {
1926 LPMIDIOPENDESC lpDesc;
1927 dprintf_info(mmsys, "midiOutUnprepareHeader(%04X, %p, %d)\n",
1928 hMidiOut, lpMidiOutHdr, uSize);
1929 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1930 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1931 return modMessage(0, MODM_UNPREPARE, lpDesc->dwInstance,
1932 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1933 }
1934
1935 /**************************************************************************
1936 * midiOutShortMsg [WINMM.88]
1937 */
1938 UINT32 WINAPI midiOutShortMsg32(HMIDIOUT32 hMidiOut, DWORD dwMsg)
1939 {
1940 return midiOutShortMsg16(hMidiOut,dwMsg);
1941 }
1942 /**************************************************************************
1943 * midiOutShortMsg [MMSYSTEM.208]
1944 */
1945 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
1946 {
1947 LPMIDIOPENDESC lpDesc;
1948 dprintf_info(mmsys, "midiOutShortMsg(%04X, %08lX)\n", hMidiOut, dwMsg);
1949 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1950 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1951 return modMessage(0, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
1952 }
1953
1954 /**************************************************************************
1955 * midiOutLongMsg [WINMM.82]
1956 */
1957 UINT32 WINAPI midiOutLongMsg32(HMIDIOUT32 hMidiOut,
1958 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
1959 {
1960 return midiOutLongMsg16(hMidiOut,lpMidiOutHdr,uSize);
1961 }
1962
1963 /**************************************************************************
1964 * midiOutLongMsg [MMSYSTEM.209]
1965 */
1966 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,
1967 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1968 {
1969 LPMIDIOPENDESC lpDesc;
1970 dprintf_info(mmsys, "midiOutLongMsg(%04X, %p, %d)\n",
1971 hMidiOut, lpMidiOutHdr, uSize);
1972 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1973 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1974 return modMessage(0, MODM_LONGDATA, lpDesc->dwInstance,
1975 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1976 }
1977
1978 /**************************************************************************
1979 * midiOutReset [WINMM.86]
1980 */
1981 UINT32 WINAPI midiOutReset32(HMIDIOUT32 hMidiOut)
1982 {
1983 return midiOutReset16(hMidiOut);
1984 }
1985
1986 /**************************************************************************
1987 * midiOutReset [MMSYSTEM.210]
1988 */
1989 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
1990 {
1991 LPMIDIOPENDESC lpDesc;
1992 dprintf_info(mmsys, "midiOutReset(%04X)\n", hMidiOut);
1993 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1994 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1995 return modMessage(0, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
1996 }
1997
1998 /**************************************************************************
1999 * midiOutGetVolume [WINM.81]
2000 */
2001 UINT32 WINAPI midiOutGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
2002 {
2003 return midiOutGetVolume16(uDeviceID,lpdwVolume);
2004 }
2005 /**************************************************************************
2006 * midiOutGetVolume [MMSYSTEM.211]
2007 */
2008 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
2009 {
2010 dprintf_info(mmsys, "midiOutGetVolume(%04X, %p);\n", uDeviceID, lpdwVolume);
2011 return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
2012 }
2013
2014 /**************************************************************************
2015 * midiOutSetVolume [WINMM.87]
2016 */
2017 UINT32 WINAPI midiOutSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
2018 {
2019 return midiOutSetVolume16(uDeviceID,dwVolume);
2020 }
2021
2022 /**************************************************************************
2023 * midiOutSetVolume [MMSYSTEM.212]
2024 */
2025 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
2026 {
2027 dprintf_info(mmsys, "midiOutSetVolume(%04X, %08lX);\n", uDeviceID, dwVolume);
2028 return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
2029 }
2030
2031 /**************************************************************************
2032 * midiOutCachePatches [WINMM.73]
2033 */
2034 UINT32 WINAPI midiOutCachePatches32(HMIDIOUT32 hMidiOut, UINT32 uBank,
2035 WORD * lpwPatchArray, UINT32 uFlags)
2036 {
2037 return midiOutCachePatches16(hMidiOut,uBank,lpwPatchArray,uFlags);
2038 }
2039
2040 /**************************************************************************
2041 * midiOutCachePatches [MMSYSTEM.213]
2042 */
2043 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
2044 WORD * lpwPatchArray, UINT16 uFlags)
2045 {
2046 /* not really necessary to support this */
2047 fprintf(stdnimp, "midiOutCachePatches: not supported yet\n");
2048 return MMSYSERR_NOTSUPPORTED;
2049 }
2050
2051 /**************************************************************************
2052 * midiOutCacheDrumPatches [WINMM.72]
2053 */
2054 UINT32 WINAPI midiOutCacheDrumPatches32(HMIDIOUT32 hMidiOut, UINT32 uPatch,
2055 WORD * lpwKeyArray, UINT32 uFlags)
2056 {
2057 return midiOutCacheDrumPatches16(hMidiOut,uPatch,lpwKeyArray,uFlags);
2058 }
2059
2060 /**************************************************************************
2061 * midiOutCacheDrumPatches [MMSYSTEM.214]
2062 */
2063 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
2064 WORD * lpwKeyArray, UINT16 uFlags)
2065 {
2066 fprintf(stdnimp, "midiOutCacheDrumPatchesi: not supported yet\n");
2067 return MMSYSERR_NOTSUPPORTED;
2068 }
2069
2070 /**************************************************************************
2071 * midiOutGetID [WINMM.79]
2072 */
2073 UINT32 WINAPI midiOutGetID32(HMIDIOUT32 hMidiOut, UINT32 * lpuDeviceID)
2074 {
2075 UINT16 xid;
2076 UINT32 ret;
2077
2078 ret = midiOutGetID16(hMidiOut,&xid);
2079 *lpuDeviceID = xid;
2080 return ret;
2081 }
2082
2083 /**************************************************************************
2084 * midiOutGetID [MMSYSTEM.215]
2085 */
2086 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID)
2087 {
2088 dprintf_info(mmsys, "midiOutGetID\n");
2089 return 0;
2090 }
2091
2092 /**************************************************************************
2093 * midiOutMessage [WINMM.83]
2094 */
2095 DWORD WINAPI midiOutMessage32(HMIDIOUT32 hMidiOut, UINT32 uMessage,
2096 DWORD dwParam1, DWORD dwParam2)
2097 {
2098 LPMIDIOPENDESC lpDesc;
2099
2100 dprintf_info(mmsys, "midiOutMessage(%04X, %04X, %08lX, %08lX)\n",
2101 hMidiOut, uMessage, dwParam1, dwParam2);
2102 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2103 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2104 switch (uMessage) {
2105 case MODM_OPEN:
2106 fprintf(stderr,"midiOutMessage32: can't handle MODM_OPEN!\n");
2107 return 0;
2108 case MODM_GETDEVCAPS:
2109 return midiOutGetDevCaps32A(hMidiOut,(LPMIDIOUTCAPS32A)dwParam1,dwParam2);
2110 case MODM_GETNUMDEVS:
2111 case MODM_RESET:
2112 case MODM_CLOSE:
2113 case MODM_GETVOLUME:
2114 case MODM_SETVOLUME:
2115 case MODM_LONGDATA:
2116 case MODM_PREPARE:
2117 case MODM_UNPREPARE:
2118 /* no argument conversion needed */
2119 break;
2120 default:
2121 fprintf(stderr,"unhandled midiOutMessage32(%04x,%04x,%08lx,%08lx)\n",
2122 hMidiOut,uMessage,dwParam1,dwParam2
2123 );
2124 break;
2125 }
2126 return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2127 }
2128
2129 /**************************************************************************
2130 * midiOutMessage [MMSYSTEM.216]
2131 */
2132 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
2133 DWORD dwParam1, DWORD dwParam2)
2134 {
2135 LPMIDIOPENDESC lpDesc;
2136
2137 dprintf_info(mmsys, "midiOutMessage(%04X, %04X, %08lX, %08lX)\n",
2138 hMidiOut, uMessage, dwParam1, dwParam2);
2139 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2140 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2141 switch (uMessage) {
2142 case MODM_OPEN:
2143 fprintf(stderr,"midiOutMessage16: can't handle MODM_OPEN!\n");
2144 return 0;
2145 case MODM_GETNUMDEVS:
2146 case MODM_RESET:
2147 case MODM_CLOSE:
2148 case MODM_SETVOLUME:
2149 /* no argument conversion needed */
2150 break;
2151 case MODM_GETVOLUME:
2152 return midiOutGetVolume16(hMidiOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
2153 case MODM_LONGDATA:
2154 return midiOutLongMsg16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2155 case MODM_PREPARE:
2156 return midiOutPrepareHeader16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2157 case MODM_UNPREPARE:
2158 return midiOutUnprepareHeader16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2159 default:
2160 fprintf(stderr,"unhandled midiOutMessage16(%04x,%04x,%08lx,%08lx)\n",
2161 hMidiOut,uMessage,dwParam1,dwParam2
2162 );
2163 break;
2164 }
2165 return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2166 }
2167
2168 /**************************************************************************
2169 * midiInGetNumDevs [WINMM.64]
2170 */
2171 UINT32 WINAPI midiInGetNumDevs32(void)
2172 {
2173 return midiInGetNumDevs16();
2174 }
2175
2176 /**************************************************************************
2177 * midiInGetNumDevs [MMSYSTEM.301]
2178 */
2179 UINT16 WINAPI midiInGetNumDevs16(void)
2180 {
2181 UINT16 count = 0;
2182 dprintf_info(mmsys, "midiInGetNumDevs\n");
2183 count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
2184 dprintf_info(mmsys, "midiInGetNumDevs return %u \n", count);
2185 return count;
2186 }
2187
2188 /**************************************************************************
2189 * midiInGetDevCaps [WINMM.60]
2190 */
2191 UINT32 WINAPI midiInGetDevCaps32W(UINT32 uDeviceID,
2192 LPMIDIINCAPS32W lpCaps, UINT32 uSize)
2193 {
2194 MIDIINCAPS16 mic16;
2195 UINT32 ret = midiInGetDevCaps16(uDeviceID,&mic16,uSize);
2196
2197 lpCaps->wMid = mic16.wMid;
2198 lpCaps->wPid = mic16.wPid;
2199 lpCaps->vDriverVersion = mic16.vDriverVersion;
2200 lstrcpyAtoW(lpCaps->szPname,mic16.szPname);
2201 lpCaps->dwSupport = mic16.dwSupport;
2202 return ret;
2203 }
2204
2205 /**************************************************************************
2206 * midiInGetDevCaps [WINMM.59]
2207 */
2208 UINT32 WINAPI midiInGetDevCaps32A(UINT32 uDeviceID,
2209 LPMIDIINCAPS32A lpCaps, UINT32 uSize)
2210 {
2211 MIDIINCAPS16 mic16;
2212 UINT32 ret = midiInGetDevCaps16(uDeviceID,&mic16,uSize);
2213
2214 lpCaps->wMid = mic16.wMid;
2215 lpCaps->wPid = mic16.wPid;
2216 lpCaps->vDriverVersion = mic16.vDriverVersion;
2217 strcpy(lpCaps->szPname,mic16.szPname);
2218 lpCaps->dwSupport = mic16.dwSupport;
2219 return ret;
2220 }
2221
2222 /**************************************************************************
2223 * midiInGetDevCaps [MMSYSTEM.302]
2224 */
2225 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID,
2226 LPMIDIINCAPS16 lpCaps, UINT16 uSize)
2227 {
2228 dprintf_info(mmsys, "midiInGetDevCaps\n");
2229 return midMessage(uDeviceID,MIDM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);;
2230 }
2231
2232 /**************************************************************************
2233 * midiInGetErrorText [WINMM.62]
2234 */
2235 UINT32 WINAPI midiInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2236 {
2237 LPSTR xstr = HeapAlloc(GetProcessHeap(),0,uSize);
2238 UINT32 ret = midiInGetErrorText16(uError,xstr,uSize);
2239 lstrcpyAtoW(lpText,xstr);
2240 HeapFree(GetProcessHeap(),0,xstr);
2241 return ret;
2242 }
2243 /**************************************************************************
2244 * midiInGetErrorText [WINMM.61]
2245 */
2246 UINT32 WINAPI midiInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2247 {
2248 return midiInGetErrorText16(uError,lpText,uSize);
2249 }
2250
2251 /**************************************************************************
2252 * midiInGetErrorText [MMSYSTEM.303]
2253 */
2254 UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2255 {
2256 dprintf_info(mmsys, "midiInGetErrorText\n");
2257 return (midiGetErrorText(uError, lpText, uSize));
2258 }
2259
2260 /**************************************************************************
2261 * midiInOpen [WINMM.66]
2262 */
2263 UINT32 WINAPI midiInOpen32(HMIDIIN32 * lphMidiIn, UINT32 uDeviceID,
2264 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2265 {
2266 HMIDIIN16 xhmid16;
2267 UINT32 ret = midiInOpen16(&xhmid16,uDeviceID,dwCallback,dwInstance,dwFlags);
2268 if (lphMidiIn) *lphMidiIn = xhmid16;
2269 return ret;
2270 }
2271
2272 /**************************************************************************
2273 * midiInOpen [MMSYSTEM.304]
2274 */
2275 UINT16 WINAPI midiInOpen16(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
2276 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2277 {
2278 HMIDI16 hMidiIn;
2279 LPMIDIOPENDESC lpDesc;
2280 DWORD dwRet = 0;
2281 BOOL32 bMapperFlg = FALSE;
2282
2283 if (lphMidiIn != NULL) *lphMidiIn = 0;
2284 dprintf_info(mmsys, "midiInOpen(%p, %d, %08lX, %08lX, %08lX);\n",
2285 lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
2286 if (uDeviceID == (UINT16)MIDI_MAPPER) {
2287 dprintf_info(mmsys, "midiInOpen // MIDI_MAPPER mode requested !\n");
2288 bMapperFlg = TRUE;
2289 uDeviceID = 0;
2290 }
2291 hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
2292 if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
2293 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2294 if (lpDesc == NULL) return MMSYSERR_NOMEM;
2295 lpDesc->hMidi = hMidiIn;
2296 lpDesc->dwCallback = dwCallback;
2297 lpDesc->dwInstance = dwInstance;
2298 while(uDeviceID < MAXMIDIDRIVERS) {
2299 dwRet = midMessage(uDeviceID, MIDM_OPEN,
2300 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
2301 if (dwRet == MMSYSERR_NOERROR) break;
2302 if (!bMapperFlg) break;
2303 uDeviceID++;
2304 dprintf_info(mmsys, "midiInOpen // MIDI_MAPPER mode ! try next driver...\n");
2305 }
2306 return dwRet;
2307 }
2308
2309 /**************************************************************************
2310 * midiInClose [WINMM.58]
2311 */
2312 UINT32 WINAPI midiInClose32(HMIDIIN32 hMidiIn)
2313 {
2314 return midiInClose16(hMidiIn);
2315 }
2316
2317 /**************************************************************************
2318 * midiInClose [MMSYSTEM.305]
2319 */
2320 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
2321 {
2322 LPMIDIOPENDESC lpDesc;
2323 dprintf_info(mmsys, "midiInClose(%04X)\n", hMidiIn);
2324 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2325 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2326 return midMessage(0, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2327 }
2328
2329 /**************************************************************************
2330 * midiInPrepareHeader [WINMM.67]
2331 */
2332 UINT32 WINAPI midiInPrepareHeader32(HMIDIIN32 hMidiIn,
2333 MIDIHDR * lpMidiInHdr, UINT32 uSize)
2334 {
2335 return midiInPrepareHeader16(hMidiIn,lpMidiInHdr,uSize);
2336 }
2337
2338 /**************************************************************************
2339 * midiInPrepareHeader [MMSYSTEM.306]
2340 */
2341 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,
2342 MIDIHDR * lpMidiInHdr, UINT16 uSize)
2343 {
2344 LPMIDIOPENDESC lpDesc;
2345 dprintf_info(mmsys, "midiInPrepareHeader(%04X, %p, %d)\n",
2346 hMidiIn, lpMidiInHdr, uSize);
2347 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2348 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2349 return midMessage(0, MIDM_PREPARE, lpDesc->dwInstance,
2350 (DWORD)lpMidiInHdr, (DWORD)uSize);
2351 }
2352
2353 /**************************************************************************
2354 * midiInUnprepareHeader [WINMM.71]
2355 */
2356 UINT32 WINAPI midiInUnprepareHeader32(HMIDIIN32 hMidiIn,
2357 MIDIHDR * lpMidiInHdr, UINT32 uSize)
2358 {
2359 return midiInUnprepareHeader16(hMidiIn,lpMidiInHdr,uSize);
2360 }
2361
2362 /**************************************************************************
2363 * midiInUnprepareHeader [MMSYSTEM.307]
2364 */
2365 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,
2366 MIDIHDR * lpMidiInHdr, UINT16 uSize)
2367 {
2368 LPMIDIOPENDESC lpDesc;
2369 dprintf_info(mmsys, "midiInUnprepareHeader(%04X, %p, %d)\n",
2370 hMidiIn, lpMidiInHdr, uSize);
2371 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2372 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2373 return midMessage(0, MIDM_UNPREPARE, lpDesc->dwInstance,
2374 (DWORD)lpMidiInHdr, (DWORD)uSize);
2375 }
2376
2377 /**************************************************************************
2378 * midiInAddBuffer [WINMM.57]
2379 */
2380 UINT32 WINAPI midiInAddBuffer32(HMIDIIN32 hMidiIn,
2381 MIDIHDR * lpMidiInHdr, UINT32 uSize)
2382 {
2383 return midiInAddBuffer16(hMidiIn,lpMidiInHdr,uSize);
2384 }
2385
2386 /**************************************************************************
2387 * midiInAddBuffer [MMSYSTEM.308]
2388 */
2389 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,
2390 MIDIHDR * lpMidiInHdr, UINT16 uSize)
2391 {
2392 dprintf_info(mmsys, "midiInAddBuffer\n");
2393 return 0;
2394 }
2395
2396 /**************************************************************************
2397 * midiInStart [WINMM.69]
2398 */
2399 UINT32 WINAPI midiInStart32(HMIDIIN32 hMidiIn)
2400 {
2401 return midiInStart16(hMidiIn);
2402 }
2403
2404 /**************************************************************************
2405 * midiInStart [MMSYSTEM.309]
2406 */
2407 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
2408 {
2409 dprintf_info(mmsys, "midiInStart\n");
2410 return 0;
2411 }
2412
2413 /**************************************************************************
2414 * midiInStop [WINMM.70]
2415 */
2416 UINT32 WINAPI midiInStop32(HMIDIIN32 hMidiIn)
2417 {
2418 return midiInStop16(hMidiIn);
2419 }
2420
2421 /**************************************************************************
2422 * midiInStop [MMSYSTEM.310]
2423 */
2424 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
2425 {
2426 dprintf_info(mmsys, "midiInStop\n");
2427 return 0;
2428 }
2429
2430 /**************************************************************************
2431 * midiInReset [WINMM.68]
2432 */
2433 UINT32 WINAPI midiInReset32(HMIDIIN32 hMidiIn)
2434 {
2435 return midiInReset16(hMidiIn);
2436 }
2437
2438 /**************************************************************************
2439 * midiInReset [MMSYSTEM.311]
2440 */
2441 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
2442 {
2443 dprintf_info(mmsys, "midiInReset\n");
2444 return 0;
2445 }
2446
2447 /**************************************************************************
2448 * midiInGetID [WINMM.63]
2449 */
2450 UINT32 WINAPI midiInGetID32(HMIDIIN32 hMidiIn, UINT32 * lpuDeviceID)
2451 {
2452 dprintf_info(mmsys, "midiInGetID\n");
2453 return 0;
2454 }
2455
2456 /**************************************************************************
2457 * midiInGetID [MMSYSTEM.312]
2458 */
2459 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16 * lpuDeviceID)
2460 {
2461 dprintf_info(mmsys, "midiInGetID\n");
2462 return 0;
2463 }
2464
2465 /**************************************************************************
2466 * midiInMessage [WINMM.65]
2467 */
2468 DWORD WINAPI midiInMessage32(HMIDIIN32 hMidiIn, UINT32 uMessage,
2469 DWORD dwParam1, DWORD dwParam2)
2470 {
2471 LPMIDIOPENDESC lpDesc;
2472 dprintf_info(mmsys, "midiInMessage(%04X, %04X, %08lX, %08lX)\n",
2473 hMidiIn, uMessage, dwParam1, dwParam2);
2474 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2475 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2476 switch (uMessage) {
2477 case MIDM_OPEN:
2478 fprintf(stderr,"midiInMessage32: can't handle MIDM_OPEN!\n");
2479 return 0;
2480 case MIDM_GETDEVCAPS:
2481 return midiInGetDevCaps32A(hMidiIn,(LPMIDIINCAPS32A)dwParam1,dwParam2);
2482 case MIDM_GETNUMDEVS:
2483 case MIDM_RESET:
2484 case MIDM_STOP:
2485 case MIDM_START:
2486 case MIDM_CLOSE:
2487 /* no argument conversion needed */
2488 break;
2489 case MIDM_PREPARE:
2490 return midiInPrepareHeader32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
2491 case MIDM_UNPREPARE:
2492 return midiInUnprepareHeader32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
2493 case MIDM_ADDBUFFER:
2494 return midiInAddBuffer32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
2495 default:
2496 fprintf(stderr,"unhandled midiInMessage32(%04x,%04x,%08lx,%08lx)\n",
2497 hMidiIn,uMessage,dwParam1,dwParam2
2498 );
2499 break;
2500 }
2501 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2502 }
2503
2504 /**************************************************************************
2505 * midiInMessage [MMSYSTEM.313]
2506 */
2507 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
2508 DWORD dwParam1, DWORD dwParam2)
2509 {
2510 LPMIDIOPENDESC lpDesc;
2511 dprintf_info(mmsys, "midiInMessage(%04X, %04X, %08lX, %08lX)\n",
2512 hMidiIn, uMessage, dwParam1, dwParam2);
2513 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2514 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2515 switch (uMessage) {
2516 case MIDM_OPEN:
2517 fprintf(stderr,"midiInMessage16: can't handle MIDM_OPEN!\n");
2518 return 0;
2519 case MIDM_GETDEVCAPS:
2520 return midiInGetDevCaps16(hMidiIn,(LPMIDIINCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2521 case MIDM_GETNUMDEVS:
2522 case MIDM_RESET:
2523 case MIDM_STOP:
2524 case MIDM_START:
2525 case MIDM_CLOSE:
2526 /* no argument conversion needed */
2527 break;
2528 case MIDM_PREPARE:
2529 return midiInPrepareHeader16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2530 case MIDM_UNPREPARE:
2531 return midiInUnprepareHeader16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2532 case MIDM_ADDBUFFER:
2533 return midiInAddBuffer16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2534 default:
2535 fprintf(stderr,"unhandled midiInMessage16(%04x,%04x,%08lx,%08lx)\n",
2536 hMidiIn,uMessage,dwParam1,dwParam2
2537 );
2538 break;
2539 }
2540 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2541 }
2542
2543
2544 /**************************************************************************
2545 * waveOutGetNumDevs [MMSYSTEM.401]
2546 */
2547 UINT32 WINAPI waveOutGetNumDevs32() {
2548 return waveOutGetNumDevs16();
2549 }
2550
2551 /**************************************************************************
2552 * waveOutGetNumDevs [WINMM.167]
2553 */
2554 UINT16 WINAPI waveOutGetNumDevs16()
2555 {
2556 UINT16 count = 0;
2557 dprintf_info(mmsys, "waveOutGetNumDevs\n");
2558 count += wodMessage( MMSYSTEM_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L);
2559 dprintf_info(mmsys, "waveOutGetNumDevs return %u \n", count);
2560 return count;
2561 }
2562
2563 /**************************************************************************
2564 * waveOutGetDevCaps [MMSYSTEM.402]
2565 */
2566 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, WAVEOUTCAPS16 * lpCaps,
2567 UINT16 uSize)
2568 {
2569 if (uDeviceID > waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID;
2570 if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */
2571 dprintf_info(mmsys, "waveOutGetDevCaps\n");
2572 return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
2573 }
2574
2575 /**************************************************************************
2576 * waveOutGetDevCapsA [WINMM.162]
2577 */
2578 UINT32 WINAPI waveOutGetDevCaps32A(UINT32 uDeviceID, LPWAVEOUTCAPS32A lpCaps,
2579 UINT32 uSize)
2580 {
2581 WAVEOUTCAPS16 woc16;
2582 UINT16 ret = waveOutGetDevCaps16(uDeviceID,&woc16,sizeof(woc16));
2583
2584 lpCaps->wMid = woc16.wMid;
2585 lpCaps->wPid = woc16.wPid;
2586 lpCaps->vDriverVersion = woc16.vDriverVersion;
2587 strcpy(lpCaps->szPname,woc16.szPname);
2588 lpCaps->dwFormats = woc16.dwFormats;
2589 lpCaps->wChannels = woc16.wChannels;
2590 lpCaps->dwSupport = woc16.dwSupport;
2591 return ret;
2592 }
2593
2594 /**************************************************************************
2595 * waveOutGetDevCapsW [WINMM.163]
2596 */
2597 UINT32 WINAPI waveOutGetDevCaps32W(UINT32 uDeviceID, LPWAVEOUTCAPS32W lpCaps,
2598 UINT32 uSize)
2599 {
2600 WAVEOUTCAPS16 woc16;
2601 UINT32 ret = waveOutGetDevCaps16(uDeviceID,&woc16,sizeof(woc16));
2602
2603 lpCaps->wMid = woc16.wMid;
2604 lpCaps->wPid = woc16.wPid;
2605 lpCaps->vDriverVersion = woc16.vDriverVersion;
2606 lstrcpyAtoW(lpCaps->szPname,woc16.szPname);
2607 lpCaps->dwFormats = woc16.dwFormats;
2608 lpCaps->wChannels = woc16.wChannels;
2609 lpCaps->dwSupport = woc16.dwSupport;
2610 return ret;
2611 }
2612
2613 /**************************************************************************
2614 * waveOutGetErrorText [MMSYSTEM.403]
2615 */
2616 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2617 {
2618 dprintf_info(mmsys, "waveOutGetErrorText\n");
2619 return(waveGetErrorText(uError, lpText, uSize));
2620 }
2621
2622 /**************************************************************************
2623 * waveOutGetErrorTextA [WINMM.164]
2624 */
2625 UINT32 WINAPI waveOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2626 {
2627 return(waveOutGetErrorText16(uError, lpText, uSize));
2628 }
2629
2630 /**************************************************************************
2631 * waveOutGetErrorTextW [WINMM.165]
2632 */
2633 UINT32 WINAPI waveOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2634 {
2635 LPSTR xstr = HeapAlloc(GetProcessHeap(),0,uSize);
2636 UINT32 ret = waveOutGetErrorText32A(uError, xstr, uSize);
2637
2638 lstrcpyAtoW(lpText,xstr);
2639 HeapFree(GetProcessHeap(),0,xstr);
2640 return ret;
2641 }
2642
2643
2644 /**************************************************************************
2645 * waveGetErrorText [internal]
2646 */
2647 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
2648 {
2649 LPSTR msgptr;
2650 dprintf_info(mmsys, "waveGetErrorText(%04X, %p, %d);\n",
2651 uError, lpText, uSize);
2652 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
2653 lpText[0] = '\0';
2654 switch(uError) {
2655 case MMSYSERR_NOERROR:
2656 msgptr = "The specified command was carried out.";
2657 break;
2658 case MMSYSERR_ERROR:
2659 msgptr = "Undefined external error.";
2660 break;
2661 case MMSYSERR_BADDEVICEID:
2662 msgptr = "A device ID has been used that is out of range for your system.";
2663 break;
2664 case MMSYSERR_NOTENABLED:
2665 msgptr = "The driver was not enabled.";
2666 break;
2667 case MMSYSERR_ALLOCATED:
2668 msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
2669 break;
2670 case MMSYSERR_INVALHANDLE:
2671 msgptr = "The specified device handle is invalid.";
2672 break;
2673 case MMSYSERR_NODRIVER:
2674 msgptr = "There is no driver installed on your system !\n";
2675 break;
2676 case MMSYSERR_NOMEM:
2677 msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
2678 break;
2679 case MMSYSERR_NOTSUPPORTED:
2680 msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
2681 break;
2682 case MMSYSERR_BADERRNUM:
2683 msgptr = "An error number was specified that is not defined in the system.";
2684 break;
2685 case MMSYSERR_INVALFLAG:
2686 msgptr = "An invalid flag was passed to a system function.";
2687 break;
2688 case MMSYSERR_INVALPARAM:
2689 msgptr = "An invalid parameter was passed to a system function.";
2690 break;
2691 case WAVERR_BADFORMAT:
2692 msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
2693 break;
2694 case WAVERR_STILLPLAYING:
2695 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
2696 break;
2697 case WAVERR_UNPREPARED:
2698 msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
2699 break;
2700 case WAVERR_SYNC:
2701 msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
2702 break;
2703 default:
2704 msgptr = "Unknown MMSYSTEM Error !\n";
2705 break;
2706 }
2707 lstrcpyn32A(lpText, msgptr, uSize);
2708 return TRUE;
2709 }
2710
2711 /**************************************************************************
2712 * waveOutOpen [WINMM.173]
2713 * All the args/structs have the same layout as the win16 equivalents
2714 */
2715 UINT32 WINAPI waveOutOpen32(HWAVEOUT32 * lphWaveOut, UINT32 uDeviceID,
2716 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
2717 DWORD dwInstance, DWORD dwFlags)
2718 {
2719 HWAVEOUT16 hwo16;
2720 UINT32 ret=waveOutOpen16(&hwo16,uDeviceID,lpFormat,dwCallback,dwInstance,dwFlags);
2721 if (lphWaveOut) *lphWaveOut=hwo16;
2722 return ret;
2723 }
2724 /**************************************************************************
2725 * waveOutOpen [MMSYSTEM.404]
2726 */
2727 UINT16 WINAPI waveOutOpen16(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
2728 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
2729 DWORD dwInstance, DWORD dwFlags)
2730 {
2731 HWAVEOUT16 hWaveOut;
2732 LPWAVEOPENDESC lpDesc;
2733 DWORD dwRet = 0;
2734 BOOL32 bMapperFlg = FALSE;
2735
2736 dprintf_info(mmsys, "waveOutOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
2737 lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
2738 if (dwFlags & WAVE_FORMAT_QUERY)
2739 dprintf_info(mmsys, "waveOutOpen // WAVE_FORMAT_QUERY requested !\n");
2740 if (uDeviceID == (UINT16)WAVE_MAPPER) {
2741 dprintf_info(mmsys, "waveOutOpen // WAVE_MAPPER mode requested !\n");
2742 bMapperFlg = TRUE;
2743 uDeviceID = 0;
2744 }
2745 if (lpFormat == NULL) return WAVERR_BADFORMAT;
2746
2747 hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
2748 if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
2749 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2750 if (lpDesc == NULL) return MMSYSERR_NOMEM;
2751 lpDesc->hWave = hWaveOut;
2752 lpDesc->lpFormat = (LPWAVEFORMAT)lpFormat; /* should the struct be copied iso pointer? */
2753 lpDesc->dwCallBack = dwCallback;
2754 lpDesc->dwInstance = dwInstance;
2755 if (uDeviceID >= MAXWAVEDRIVERS)
2756 uDeviceID = 0;
2757 while(uDeviceID < MAXWAVEDRIVERS) {
2758 dwRet = wodMessage(uDeviceID, WODM_OPEN,
2759 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
2760 if (dwRet == MMSYSERR_NOERROR) break;
2761 if (!bMapperFlg) break;
2762 uDeviceID++;
2763 dprintf_info(mmsys, "waveOutOpen // WAVE_MAPPER mode ! try next driver...\n");
2764 }
2765 lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */
2766 if (dwFlags & WAVE_FORMAT_QUERY) {
2767 dprintf_info(mmsys, "waveOutOpen // End of WAVE_FORMAT_QUERY !\n");
2768 dwRet = waveOutClose32(hWaveOut);
2769 }
2770 return dwRet;
2771 }
2772
2773 /**************************************************************************
2774 * waveOutClose [WINMM.161]
2775 */
2776 UINT32 WINAPI waveOutClose32(HWAVEOUT32 hWaveOut)
2777 {
2778 return waveOutClose16(hWaveOut);
2779 }
2780 /**************************************************************************
2781 * waveOutClose [MMSYSTEM.405]
2782 */
2783 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
2784 {
2785 LPWAVEOPENDESC lpDesc;
2786
2787 dprintf_info(mmsys, "waveOutClose(%04X)\n", hWaveOut);
2788 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2789 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2790 return wodMessage( lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2791 }
2792
2793 /**************************************************************************
2794 * waveOutPrepareHeader [WINMM.175]
2795 */
2796 UINT32 WINAPI waveOutPrepareHeader32(HWAVEOUT32 hWaveOut,
2797 WAVEHDR * lpWaveOutHdr, UINT32 uSize)
2798 {
2799 LPWAVEOPENDESC lpDesc;
2800
2801 dprintf_info(mmsys, "waveOutPrepareHeader(%04X, %p, %u);\n",
2802 hWaveOut, lpWaveOutHdr, uSize);
2803 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2804 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2805 return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
2806 (DWORD)lpWaveOutHdr,uSize);
2807 }
2808 /**************************************************************************
2809 * waveOutPrepareHeader [MMSYSTEM.406]
2810 */
2811 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,
2812 WAVEHDR * lpWaveOutHdr, UINT16 uSize)
2813 {
2814 LPWAVEOPENDESC lpDesc;
2815 LPBYTE saveddata = lpWaveOutHdr->lpData;
2816 UINT16 ret;
2817
2818 dprintf_info(mmsys, "waveOutPrepareHeader(%04X, %p, %u);\n",
2819 hWaveOut, lpWaveOutHdr, uSize);
2820 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2821 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2822 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
2823 ret = wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
2824 (DWORD)lpWaveOutHdr,uSize);
2825 lpWaveOutHdr->lpData = saveddata;
2826 return ret;
2827 }
2828
2829 /**************************************************************************
2830 * waveOutUnprepareHeader [WINMM.181]
2831 */
2832 UINT32 WINAPI waveOutUnprepareHeader32(HWAVEOUT32 hWaveOut,
2833 WAVEHDR * lpWaveOutHdr, UINT32 uSize)
2834 {
2835 LPWAVEOPENDESC lpDesc;
2836
2837 dprintf_info(mmsys, "waveOutUnprepareHeader(%04X, %p, %u);\n",
2838 hWaveOut, lpWaveOutHdr, uSize);
2839 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2840 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2841 return wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
2842 (DWORD)lpWaveOutHdr, uSize);
2843 }
2844 /**************************************************************************
2845 * waveOutUnprepareHeader [MMSYSTEM.407]
2846 */
2847 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,
2848 WAVEHDR * lpWaveOutHdr, UINT16 uSize)
2849 {
2850 LPWAVEOPENDESC lpDesc;
2851 LPBYTE saveddata = lpWaveOutHdr->lpData;
2852 UINT16 ret;
2853
2854 dprintf_info(mmsys, "waveOutUnprepareHeader(%04X, %p, %u);\n",
2855 hWaveOut, lpWaveOutHdr, uSize);
2856 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2857 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2858 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
2859 ret = wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
2860 (DWORD)lpWaveOutHdr, uSize);
2861 lpWaveOutHdr->lpData = saveddata;
2862 return ret;
2863 }
2864
2865 /**************************************************************************
2866 * waveOutWrite [MMSYSTEM.408]
2867 */
2868 UINT32 WINAPI waveOutWrite32(HWAVEOUT32 hWaveOut, WAVEHDR * lpWaveOutHdr,
2869 UINT32 uSize)
2870 {
2871 LPWAVEOPENDESC lpDesc;
2872 dprintf_info(mmsys, "waveOutWrite(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2873 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2874 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2875 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
2876 return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
2877 }
2878 /**************************************************************************
2879 * waveOutWrite [MMSYSTEM.408]
2880 */
2881 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
2882 UINT16 uSize)
2883 {
2884 LPWAVEOPENDESC lpDesc;
2885 UINT16 ret;
2886
2887 dprintf_info(mmsys, "waveOutWrite(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2888 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2889 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2890 lpWaveOutHdr->reserved=(DWORD)lpWaveOutHdr->lpData;/*save original ptr*/
2891 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
2892 ret = wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
2893 lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved;
2894 return ret;
2895 }
2896
2897 /**************************************************************************
2898 * waveOutPause [WINMM.174]
2899 */
2900 UINT32 WINAPI waveOutPause32(HWAVEOUT32 hWaveOut)
2901 {
2902 return waveOutPause16(hWaveOut);
2903 }
2904
2905 /**************************************************************************
2906 * waveOutPause [MMSYSTEM.409]
2907 */
2908 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut)
2909 {
2910 LPWAVEOPENDESC lpDesc;
2911
2912 dprintf_info(mmsys, "waveOutPause(%04X)\n", hWaveOut);
2913 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2914 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2915 return wodMessage( lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
2916 }
2917
2918 /**************************************************************************
2919 * waveOutRestart [WINMM.177]
2920 */
2921 UINT32 WINAPI waveOutRestart32(HWAVEOUT32 hWaveOut)
2922 {
2923 return waveOutRestart16(hWaveOut);
2924 }
2925 /**************************************************************************
2926 * waveOutRestart [MMSYSTEM.410]
2927 */
2928 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut)
2929 {
2930 LPWAVEOPENDESC lpDesc;
2931
2932 dprintf_info(mmsys, "waveOutRestart(%04X)\n", hWaveOut);
2933 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2934 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2935 return wodMessage( lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
2936 }
2937
2938 /**************************************************************************
2939 * waveOutReset [WINMM.176]
2940 */
2941 UINT32 WINAPI waveOutReset32(HWAVEOUT32 hWaveOut)
2942 {
2943 return waveOutReset16(hWaveOut);
2944 }
2945
2946 /**************************************************************************
2947 * waveOutReset [MMSYSTEM.411]
2948 */
2949 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut)
2950 {
2951 LPWAVEOPENDESC lpDesc;
2952 dprintf_info(mmsys, "waveOutReset(%04X)\n", hWaveOut);
2953 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2954 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2955 return wodMessage( lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
2956 }
2957
2958 /**************************************************************************
2959 * waveOutGetPosition [WINMM.170]
2960 */
2961 UINT32 WINAPI waveOutGetPosition32(HWAVEOUT32 hWaveOut, LPMMTIME32 lpTime,
2962 UINT32 uSize)
2963 {
2964 MMTIME16 mmt16;
2965 UINT32 ret = waveOutGetPosition16(hWaveOut,&mmt16,sizeof(mmt16));
2966 MMSYSTEM_MMTIME16to32(lpTime,&mmt16);
2967 return ret;
2968 }
2969 /**************************************************************************
2970 * waveOutGetPosition [MMSYSTEM.412]
2971 */
2972 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut,LPMMTIME16 lpTime,
2973 UINT16 uSize)
2974 {
2975 LPWAVEOPENDESC lpDesc;
2976 dprintf_info(mmsys, "waveOutGetPosition(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
2977 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2978 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2979 return wodMessage( lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance,
2980 (DWORD)lpTime, (DWORD)uSize);
2981 }
2982
2983 #define WAVEOUT_SHORTCUT_1(xx,XX,atype) \
2984 UINT32 WINAPI waveOut##xx##32(HWAVEOUT32 hWaveOut, atype x) \
2985 { \
2986 return waveOut##xx##16(hWaveOut,x); \
2987 } \
2988 UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \
2989 { \
2990 LPWAVEOPENDESC lpDesc; \
2991 dprintf_info(mmsys, "waveOut"#xx"(%04X, %08lx);\n", hWaveOut,(DWORD)x);\
2992 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \
2993 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \
2994 return wodMessage(lpDesc->uDeviceID, WODM_##XX, lpDesc->dwInstance,\
2995 (DWORD)x, 0L); \
2996 }
2997
2998 WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH,DWORD*)
2999 WAVEOUT_SHORTCUT_1(SetPitch,SETPITCH,DWORD)
3000 WAVEOUT_SHORTCUT_1(GetPlaybackRate,GETPLAYBACKRATE,DWORD*)
3001 WAVEOUT_SHORTCUT_1(SetPlaybackRate,SETPLAYBACKRATE,DWORD)
3002
3003 #define WAVEOUT_SHORTCUT_2(xx,XX,atype) \
3004 UINT32 WINAPI waveOut##xx##32(UINT32 devid, atype x) \
3005 { \
3006 return waveOut##xx##16(devid,x); \
3007 } \
3008 UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \
3009 { \
3010 dprintf_info(mmsys, "waveOut"#xx"(%04X, %08lx);\n", devid,(DWORD)x); \
3011 return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \
3012 }
3013
3014
3015 WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME,DWORD*)
3016 WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME,DWORD)
3017
3018
3019 /**************************************************************************
3020 * waveOutBreakLoop [MMSYSTEM.419]
3021 */
3022 UINT32 WINAPI waveOutBreakLoop32(HWAVEOUT32 hWaveOut)
3023 {
3024 return waveOutBreakLoop16(hWaveOut);
3025 }
3026 /**************************************************************************
3027 * waveOutBreakLoop [MMSYSTEM.419]
3028 */
3029 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut)
3030 {
3031 dprintf_info(mmsys, "waveOutBreakLoop(%04X)\n", hWaveOut);
3032 return MMSYSERR_INVALHANDLE;
3033 }
3034
3035 /**************************************************************************
3036 * waveOutGetID [MMSYSTEM.420]
3037 */
3038 UINT32 WINAPI waveOutGetID32(HWAVEOUT32 hWaveOut, UINT32 * lpuDeviceID)
3039 {
3040 LPWAVEOPENDESC lpDesc;
3041 dprintf_info(mmsys, "waveOutGetID(%04X, %p);\n", hWaveOut, lpuDeviceID);
3042 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3043 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3044 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3045 *lpuDeviceID = lpDesc->uDeviceID;
3046 return 0;
3047 }
3048 /**************************************************************************
3049 * waveOutGetID [MMSYSTEM.420]
3050 */
3051 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID)
3052 {
3053 LPWAVEOPENDESC lpDesc;
3054 dprintf_info(mmsys, "waveOutGetID(%04X, %p);\n", hWaveOut, lpuDeviceID);
3055 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3056 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3057 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3058 *lpuDeviceID = lpDesc->uDeviceID;
3059 return 0;
3060 }
3061
3062 /**************************************************************************
3063 * waveOutMessage [MMSYSTEM.421]
3064 */
3065 DWORD WINAPI waveOutMessage32(HWAVEOUT32 hWaveOut, UINT32 uMessage,
3066 DWORD dwParam1, DWORD dwParam2)
3067 {
3068 LPWAVEOPENDESC lpDesc;
3069
3070 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3071 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3072 switch (uMessage) {
3073 case WODM_GETNUMDEVS:
3074 case WODM_GETPOS:
3075 case WODM_GETVOLUME:
3076 case WODM_GETPITCH:
3077 case WODM_GETPLAYBACKRATE:
3078 case WODM_SETVOLUME:
3079 case WODM_SETPITCH:
3080 case WODM_SETPLAYBACKRATE:
3081 case WODM_RESET:
3082 case WODM_PAUSE:
3083 case WODM_PREPARE:
3084 case WODM_UNPREPARE:
3085 case WODM_STOP:
3086 case WODM_CLOSE:
3087 /* no argument conversion needed */
3088 break;
3089 case WODM_WRITE:
3090 return waveOutWrite32(hWaveOut,(LPWAVEHDR)dwParam1,dwParam2);
3091 case WODM_GETDEVCAPS:
3092 /* FIXME: UNICODE/ANSI? */
3093 return waveOutGetDevCaps32A(hWaveOut,(LPWAVEOUTCAPS32A)dwParam1,dwParam2);
3094 case WODM_OPEN:
3095 fprintf(stderr,"waveOutMessage32 can't handle WODM_OPEN, please report.\n");
3096 break;
3097 default:
3098 fprintf(stderr,"unhandled waveOutMessage32(0x%04x,0x%04x,%08lx,%08lx)\n",
3099 hWaveOut,uMessage,dwParam1,dwParam2
3100 );
3101 break;
3102 }
3103 return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3104 }
3105
3106 /**************************************************************************
3107 * waveOutMessage [MMSYSTEM.421]
3108 */
3109 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
3110 DWORD dwParam1, DWORD dwParam2)
3111 {
3112 LPWAVEOPENDESC lpDesc;
3113
3114 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3115 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3116 switch (uMessage) {
3117 case WODM_GETNUMDEVS:
3118 case WODM_SETVOLUME:
3119 case WODM_SETPITCH:
3120 case WODM_SETPLAYBACKRATE:
3121 case WODM_RESET:
3122 case WODM_PAUSE:
3123 case WODM_STOP:
3124 case WODM_CLOSE:
3125 /* no argument conversion needed */
3126 break;
3127 case WODM_GETPOS:
3128 return waveOutGetPosition16(hWaveOut,(LPMMTIME16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3129 case WODM_GETVOLUME:
3130 return waveOutGetVolume16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3131 case WODM_GETPITCH:
3132 return waveOutGetPitch16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3133 case WODM_GETPLAYBACKRATE:
3134 return waveOutGetPlaybackRate16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3135 case WODM_GETDEVCAPS:
3136 return waveOutGetDevCaps16(hWaveOut,(LPWAVEOUTCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3137 case WODM_PREPARE:
3138 return waveOutPrepareHeader16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3139 case WODM_UNPREPARE:
3140 return waveOutUnprepareHeader16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3141 case WODM_WRITE:
3142 return waveOutWrite16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3143 case WODM_OPEN:
3144 fprintf(stderr,"waveOutMessage16 can't handle WODM_OPEN, please report.\n");
3145 break;
3146 default:
3147 fprintf(stderr,"unhandled waveOutMessage16(0x%04x,0x%04x,%08lx,%08lx)\n",
3148 hWaveOut,uMessage,dwParam1,dwParam2
3149 );
3150 }
3151 return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3152 }
3153
3154 /**************************************************************************
3155 * waveInGetNumDevs [WINMM.151]
3156 */
3157 UINT32 WINAPI waveInGetNumDevs32()
3158 {
3159 return waveInGetNumDevs16();
3160 }
3161
3162 /**************************************************************************
3163 * waveInGetNumDevs [MMSYSTEM.501]
3164 */
3165 UINT16 WINAPI waveInGetNumDevs16()
3166 {
3167 UINT16 count = 0;
3168 dprintf_info(mmsys, "waveInGetNumDevs\n");
3169 count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
3170 dprintf_info(mmsys, "waveInGetNumDevs return %u \n", count);
3171 return count;
3172 }
3173
3174 /**************************************************************************
3175 * waveInGetDevCapsA [WINMM.147]
3176 */
3177 UINT32 WINAPI waveInGetDevCaps32W(UINT32 uDeviceID, LPWAVEINCAPS32W lpCaps, UINT32 uSize)
3178 {
3179 WAVEINCAPS16 wic16;
3180 UINT32 ret = waveInGetDevCaps16(uDeviceID,&wic16,uSize);
3181
3182 lpCaps->wMid = wic16.wMid;
3183 lpCaps->wPid = wic16.wPid;
3184 lpCaps->vDriverVersion = wic16.vDriverVersion;
3185 lstrcpyAtoW(lpCaps->szPname,wic16.szPname);
3186 lpCaps->dwFormats = wic16.dwFormats;
3187 lpCaps->wChannels = wic16.wChannels;
3188
3189 return ret;
3190 }
3191 /**************************************************************************
3192 * waveInGetDevCapsA [WINMM.146]
3193 */
3194 UINT32 WINAPI waveInGetDevCaps32A(UINT32 uDeviceID, LPWAVEINCAPS32A lpCaps, UINT32 uSize)
3195 {
3196 WAVEINCAPS16 wic16;
3197 UINT32 ret = waveInGetDevCaps16(uDeviceID,&wic16,uSize);
3198
3199 lpCaps->wMid = wic16.wMid;
3200 lpCaps->wPid = wic16.wPid;
3201 lpCaps->vDriverVersion = wic16.vDriverVersion;
3202 strcpy(lpCaps->szPname,wic16.szPname);
3203 lpCaps->dwFormats = wic16.dwFormats;
3204 lpCaps->wChannels = wic16.wChannels;
3205 return ret;
3206 }
3207 /**************************************************************************
3208 * waveInGetDevCaps [MMSYSTEM.502]
3209 */
3210 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize)
3211 {
3212 dprintf_info(mmsys, "waveInGetDevCaps\n");
3213 return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
3214 }
3215
3216 /**************************************************************************
3217 * waveInGetErrorTextA [WINMM.148]
3218 */
3219 UINT32 WINAPI waveInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
3220 {
3221 dprintf_info(mmsys, "waveInGetErrorText\n");
3222 return(waveGetErrorText(uError, lpText, uSize));
3223 }
3224
3225 /**************************************************************************
3226 * waveInGetErrorTextW [WINMM.149]
3227 */
3228 UINT32 WINAPI waveInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
3229 {
3230 LPSTR txt = HeapAlloc(GetProcessHeap(),0,uSize);
3231 UINT32 ret = waveGetErrorText(uError, txt, uSize);
3232
3233 lstrcpyAtoW(lpText,txt);
3234 HeapFree(GetProcessHeap(),0,txt);
3235 return ret;
3236 }
3237
3238 /**************************************************************************
3239 * waveInGetErrorText [MMSYSTEM.503]
3240 */
3241 UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
3242 {
3243 dprintf_info(mmsys, "waveInGetErrorText\n");
3244 return(waveGetErrorText(uError, lpText, uSize));
3245 }
3246
3247
3248 /**************************************************************************
3249 * waveInOpen [WINMM.154]
3250 */
3251 UINT32 WINAPI waveInOpen32(HWAVEIN32 * lphWaveIn, UINT32 uDeviceID,
3252 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
3253 DWORD dwInstance, DWORD dwFlags)
3254 {
3255 HWAVEIN16 hwin16;
3256 UINT32 ret=waveInOpen16(&hwin16,uDeviceID,lpFormat,dwCallback,dwInstance,dwFlags);
3257 if (lphWaveIn) *lphWaveIn = hwin16;
3258 return ret;
3259 }
3260
3261 /**************************************************************************
3262 * waveInOpen [MMSYSTEM.504]
3263 */
3264 UINT16 WINAPI waveInOpen16(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
3265 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
3266 DWORD dwInstance, DWORD dwFlags)
3267 {
3268 HWAVEIN16 hWaveIn;
3269 LPWAVEOPENDESC lpDesc;
3270 DWORD dwRet = 0;
3271 BOOL32 bMapperFlg = FALSE;
3272 dprintf_info(mmsys, "waveInOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3273 lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
3274 if (dwFlags & WAVE_FORMAT_QUERY)
3275 dprintf_info(mmsys, "waveInOpen // WAVE_FORMAT_QUERY requested !\n");
3276 if (uDeviceID == (UINT16)WAVE_MAPPER) {
3277 dprintf_info(mmsys, "waveInOpen // WAVE_MAPPER mode requested !\n");
3278 bMapperFlg = TRUE;
3279 uDeviceID = 0;
3280 }
3281 if (lpFormat == NULL) return WAVERR_BADFORMAT;
3282 hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
3283 if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
3284 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3285 if (lpDesc == NULL) return MMSYSERR_NOMEM;
3286 lpDesc->hWave = hWaveIn;
3287 lpDesc->lpFormat = lpFormat;
3288 lpDesc->dwCallBack = dwCallback;
3289 lpDesc->dwInstance = dwInstance;
3290 while(uDeviceID < MAXWAVEDRIVERS) {
3291 dwRet = widMessage(uDeviceID, WIDM_OPEN,
3292 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
3293 if (dwRet == MMSYSERR_NOERROR) break;
3294 if (!bMapperFlg) break;
3295 uDeviceID++;
3296 dprintf_info(mmsys, "waveInOpen // WAVE_MAPPER mode ! try next driver...\n");
3297 }
3298 lpDesc->uDeviceID = uDeviceID;
3299 if (dwFlags & WAVE_FORMAT_QUERY) {
3300 dprintf_info(mmsys, "waveInOpen // End of WAVE_FORMAT_QUERY !\n");
3301 dwRet = waveInClose16(hWaveIn);
3302 }
3303 return dwRet;
3304 }
3305
3306 /**************************************************************************
3307 * waveInClose [WINMM.145]
3308 */
3309 UINT32 WINAPI waveInClose32(HWAVEIN32 hWaveIn)
3310 {
3311 return waveInClose16(hWaveIn);
3312 }
3313 /**************************************************************************
3314 * waveInClose [MMSYSTEM.505]
3315 */
3316 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
3317 {
3318 LPWAVEOPENDESC lpDesc;
3319
3320 dprintf_info(mmsys, "waveInClose(%04X)\n", hWaveIn);
3321 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3322 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3323 return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3324 }
3325
3326 /**************************************************************************
3327 * waveInPrepareHeader [WINMM.155]
3328 */
3329 UINT32 WINAPI waveInPrepareHeader32(HWAVEIN32 hWaveIn,
3330 WAVEHDR * lpWaveInHdr, UINT32 uSize)
3331 {
3332 LPWAVEOPENDESC lpDesc;
3333
3334 dprintf_info(mmsys, "waveInPrepareHeader(%04X, %p, %u);\n",
3335 hWaveIn, lpWaveInHdr, uSize);
3336 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3337 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3338 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3339 lpWaveInHdr = lpWaveInHdr;
3340 lpWaveInHdr->lpNext = NULL;
3341 lpWaveInHdr->dwBytesRecorded = 0;
3342 dprintf_info(mmsys, "waveInPrepareHeader // lpData=%p size=%lu \n",
3343 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3344 return widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance,
3345 (DWORD)lpWaveInHdr, uSize);
3346 }
3347 /**************************************************************************
3348 * waveInPrepareHeader [MMSYSTEM.506]
3349 */
3350 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,
3351 WAVEHDR * lpWaveInHdr, UINT16 uSize)
3352 {
3353 LPWAVEOPENDESC lpDesc;
3354 LPBYTE saveddata = lpWaveInHdr->lpData;
3355 UINT16 ret;
3356
3357 dprintf_info(mmsys, "waveInPrepareHeader(%04X, %p, %u);\n",
3358 hWaveIn, lpWaveInHdr, uSize);
3359 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3360 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3361 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3362 lpWaveInHdr = lpWaveInHdr;
3363 lpWaveInHdr->lpNext = NULL;
3364 lpWaveInHdr->dwBytesRecorded = 0;
3365
3366 dprintf_info(mmsys, "waveInPrepareHeader // lpData=%p size=%lu \n",
3367 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3368 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
3369 ret = widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance,
3370 (DWORD)lpWaveInHdr,uSize);
3371 lpWaveInHdr->lpData = saveddata;
3372 return ret;
3373 }
3374
3375
3376 /**************************************************************************
3377 * waveInUnprepareHeader [WINMM.159]
3378 */
3379 UINT32 WINAPI waveInUnprepareHeader32(HWAVEIN32 hWaveIn,
3380 WAVEHDR * lpWaveInHdr, UINT32 uSize)
3381 {
3382 LPWAVEOPENDESC lpDesc;
3383
3384 dprintf_info(mmsys, "waveInUnprepareHeader(%04X, %p, %u);\n",
3385 hWaveIn, lpWaveInHdr, uSize);
3386 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3387 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3388 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3389 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
3390 lpWaveInHdr->lpData = NULL;
3391 lpWaveInHdr->lpNext = NULL;
3392 return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance,
3393 (DWORD)lpWaveInHdr, uSize);
3394 }
3395 /**************************************************************************
3396 * waveInUnprepareHeader [MMSYSTEM.507]
3397 */
3398 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,
3399 WAVEHDR * lpWaveInHdr, UINT16 uSize)
3400 {
3401 LPWAVEOPENDESC lpDesc;
3402
3403 dprintf_info(mmsys, "waveInUnprepareHeader(%04X, %p, %u);\n",
3404 hWaveIn, lpWaveInHdr, uSize);
3405 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3406 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3407 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3408 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
3409 lpWaveInHdr->lpData = NULL;
3410 lpWaveInHdr->lpNext = NULL;
3411 return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance,
3412 (DWORD)lpWaveInHdr, uSize);
3413 }
3414
3415 /**************************************************************************
3416 * waveInAddBuffer [WINMM.144]
3417 */
3418 UINT32 WINAPI waveInAddBuffer32(HWAVEIN32 hWaveIn,
3419 WAVEHDR * lpWaveInHdr, UINT32 uSize)
3420 {
3421 LPWAVEOPENDESC lpDesc;
3422
3423 dprintf_info(mmsys, "waveInAddBuffer(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
3424 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3425 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3426 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3427 lpWaveInHdr->lpNext = NULL;
3428 lpWaveInHdr->dwBytesRecorded = 0;
3429 dprintf_info(mmsys, "waveInAddBuffer // lpData=%p size=%lu \n",
3430 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3431 return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
3432 (DWORD)lpWaveInHdr, uSize);
3433
3434 }
3435
3436 /**************************************************************************
3437 * waveInAddBuffer [MMSYSTEM.508]
3438 */
3439 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,
3440 WAVEHDR * lpWaveInHdr, UINT16 uSize)
3441 {
3442 LPWAVEOPENDESC lpDesc;
3443 UINT16 ret;
3444
3445 dprintf_info(mmsys, "waveInAddBuffer(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
3446 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3447 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3448 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3449 lpWaveInHdr->lpNext = NULL;
3450 lpWaveInHdr->dwBytesRecorded = 0;
3451 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
3452 dprintf_info(mmsys, "waveInAddBuffer // lpData=%p size=%lu \n",
3453 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3454 ret = widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
3455 (DWORD)lpWaveInHdr, uSize);
3456 /*lpWaveInHdr->lpData = saveddata;*/
3457 return ret;
3458 }
3459
3460 /**************************************************************************
3461 * waveInStart [WINMM.157]
3462 */
3463 UINT32 WINAPI waveInStart32(HWAVEIN32 hWaveIn)
3464 {
3465 return waveInStart16(hWaveIn);
3466 }
3467
3468 /**************************************************************************
3469 * waveInStart [MMSYSTEM.509]
3470 */
3471 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn)
3472 {
3473 LPWAVEOPENDESC lpDesc;
3474
3475 dprintf_info(mmsys, "waveInStart(%04X)\n", hWaveIn);
3476 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3477 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3478 return widMessage(lpDesc->uDeviceID,WIDM_START,lpDesc->dwInstance,0,0);
3479 }
3480
3481 /**************************************************************************
3482 * waveInStop [WINMM.158]
3483 */
3484 UINT32 WINAPI waveInStop32(HWAVEIN32 hWaveIn)
3485 {
3486 return waveInStop16(hWaveIn);
3487 }
3488
3489 /**************************************************************************
3490 * waveInStop [MMSYSTEM.510]
3491 */
3492 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn)
3493 {
3494 LPWAVEOPENDESC lpDesc;
3495
3496 dprintf_info(mmsys, "waveInStop(%04X)\n", hWaveIn);
3497 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3498 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3499 return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
3500 }
3501
3502 /**************************************************************************
3503 * waveInReset [WINMM.156]
3504 */
3505 UINT32 WINAPI waveInReset32(HWAVEIN32 hWaveIn)
3506 {
3507 return waveInReset16(hWaveIn);
3508 }
3509
3510 /**************************************************************************
3511 * waveInReset [MMSYSTEM.511]
3512 */
3513 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn)
3514 {
3515 LPWAVEOPENDESC lpDesc;
3516
3517 dprintf_info(mmsys, "waveInReset(%04X)\n", hWaveIn);
3518 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3519 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3520 return widMessage(lpDesc->uDeviceID,WIDM_RESET,lpDesc->dwInstance,0,0);
3521 }
3522
3523 /**************************************************************************
3524 * waveInGetPosition [WINMM.152]
3525 */
3526 UINT32 WINAPI waveInGetPosition32(HWAVEIN32 hWaveIn, LPMMTIME32 lpTime,
3527 UINT32 uSize)
3528 {
3529 MMTIME16 mmt16;
3530 UINT32 ret = waveInGetPosition16(hWaveIn,&mmt16,uSize);
3531
3532 MMSYSTEM_MMTIME16to32(lpTime,&mmt16);
3533 return ret;
3534 }
3535
3536 /**************************************************************************
3537 * waveInGetPosition [MMSYSTEM.512]
3538 */
3539 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn,LPMMTIME16 lpTime,
3540 UINT16 uSize)
3541 {
3542 LPWAVEOPENDESC lpDesc;
3543
3544 dprintf_info(mmsys, "waveInGetPosition(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
3545 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3546 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3547 return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance,
3548 (DWORD)lpTime, (DWORD)uSize);
3549 }
3550
3551 /**************************************************************************
3552 * waveInGetID [WINMM.150]
3553 */
3554 UINT32 WINAPI waveInGetID32(HWAVEIN32 hWaveIn, UINT32 * lpuDeviceID)
3555 {
3556 LPWAVEOPENDESC lpDesc;
3557
3558 dprintf_info(mmsys, "waveInGetID\n");
3559 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3560 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3561 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3562 *lpuDeviceID = lpDesc->uDeviceID;
3563 return 0;
3564 }
3565
3566
3567 /**************************************************************************
3568 * waveInGetID [MMSYSTEM.513]
3569 */
3570 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID)
3571 {
3572 LPWAVEOPENDESC lpDesc;
3573
3574 dprintf_info(mmsys, "waveInGetID\n");
3575 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3576 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3577 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3578 *lpuDeviceID = lpDesc->uDeviceID;
3579 return 0;
3580 }
3581
3582 /**************************************************************************
3583 * waveInMessage [WINMM.153]
3584 */
3585 DWORD WINAPI waveInMessage32(HWAVEIN32 hWaveIn, UINT32 uMessage,
3586 DWORD dwParam1, DWORD dwParam2)
3587 {
3588 LPWAVEOPENDESC lpDesc;
3589
3590 fprintf(stderr, "waveInMessage32(%04X, %04X, %08lX, %08lX),FIXME!\n",
3591 hWaveIn, uMessage, dwParam1, dwParam2);
3592 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3593 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3594 switch (uMessage) {
3595 case WIDM_OPEN:
3596 fprintf(stderr,"waveInMessage32: cannot handle WIDM_OPEN, please report.\n");
3597 break;
3598 case WIDM_GETNUMDEVS:
3599 case WIDM_GETPOS:
3600 case WIDM_CLOSE:
3601 case WIDM_STOP :
3602 case WIDM_RESET:
3603 case WIDM_START:
3604 case WIDM_PREPARE:
3605 case WIDM_UNPREPARE:
3606 case WIDM_ADDBUFFER:
3607 case WIDM_PAUSE:
3608 /* no argument conversion needed */
3609 break;
3610 case WIDM_GETDEVCAPS:
3611 /*FIXME: ANSI/UNICODE */
3612 return waveInGetDevCaps32A(hWaveIn,(LPWAVEINCAPS32A)dwParam1,dwParam2);
3613 default:
3614 fprintf(stderr,"unhandled waveInMessage32(%04x,%04x,%08lx,%08lx)\n",hWaveIn,uMessage,dwParam1,dwParam2);
3615 break;
3616 }
3617 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3618 }
3619
3620 /**************************************************************************
3621 * waveInMessage [MMSYSTEM.514]
3622 */
3623 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
3624 DWORD dwParam1, DWORD dwParam2)
3625 {
3626 LPWAVEOPENDESC lpDesc;
3627
3628 fprintf(stderr, "waveInMessage(%04X, %04X, %08lX, %08lX),FIXME!\n",
3629 hWaveIn, uMessage, dwParam1, dwParam2);
3630 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3631 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3632 switch (uMessage) {
3633 case WIDM_OPEN:
3634 fprintf(stderr,"waveInMessage16: cannot handle WIDM_OPEN, please report.\n");
3635 break;
3636 case WIDM_GETNUMDEVS:
3637 case WIDM_CLOSE:
3638 case WIDM_STOP :
3639 case WIDM_RESET:
3640 case WIDM_START:
3641 case WIDM_PAUSE:
3642 /* no argument conversion needed */
3643 break;
3644 case WIDM_GETDEVCAPS:
3645 return waveInGetDevCaps16(hWaveIn,(LPWAVEINCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3646 case WIDM_GETPOS:
3647 return waveInGetPosition16(hWaveIn,(LPMMTIME16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3648 case WIDM_PREPARE:
3649 return waveInPrepareHeader16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3650 case WIDM_UNPREPARE:
3651 return waveInUnprepareHeader16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3652 case WIDM_ADDBUFFER:
3653 return waveInAddBuffer16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3654 default:
3655 fprintf(stderr,"unhandled waveInMessage16(%04x,%04x,%08lx,%08lx)\n",hWaveIn,uMessage,dwParam1,dwParam2);
3656 break;
3657 }
3658 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3659 }
3660
3661 /**************************************************************************
3662 * DrvOpen [MMSYSTEM.1100]
3663 */
3664 HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
3665 {
3666 dprintf_info(mmsys, "DrvOpen('%s', '%s', %08lX);\n",
3667 lpDriverName, lpSectionName, lParam);
3668 return OpenDriver(lpDriverName, lpSectionName, lParam);
3669 }
3670
3671
3672 /**************************************************************************
3673 * DrvClose [MMSYSTEM.1101]
3674 */
3675 LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
3676 {
3677 dprintf_info(mmsys, "DrvClose(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
3678 return CloseDriver(hDrvr, lParam1, lParam2);
3679 }
3680
3681
3682 /**************************************************************************
3683 * DrvSendMessage [MMSYSTEM.1102]
3684 */
3685 LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1,
3686 LPARAM lParam2)
3687 {
3688 DWORD dwDriverID = 0;
3689 dprintf_info(mmsys, "DrvSendMessage(%04X, %04X, %08lX, %08lX);\n",
3690 hDriver, msg, lParam1, lParam2);
3691 return CDAUDIO_DriverProc(dwDriverID, hDriver, msg, lParam1, lParam2);
3692 }
3693
3694 /**************************************************************************
3695 * DrvGetModuleHandle [MMSYSTEM.1103]
3696 */
3697 HANDLE16 WINAPI DrvGetModuleHandle(HDRVR16 hDrvr)
3698 {
3699 dprintf_info(mmsys, "DrvGetModuleHandle(%04X);\n", hDrvr);
3700 return 0;
3701 }
3702
3703
3704 /**************************************************************************
3705 * DrvDefDriverProc [MMSYSTEM.1104]
3706 */
3707 LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg,
3708 DWORD dwParam1, DWORD dwParam2)
3709 {
3710 return DefDriverProc(dwDriverID, hDriv, wMsg, dwParam1, dwParam2);
3711 }
3712
3713 /**************************************************************************
3714 * mmThreadCreate [MMSYSTEM.1120]
3715 */
3716 LRESULT WINAPI mmThreadCreate16(LPVOID x1, LPWORD x2, DWORD x3, DWORD x4) {
3717 fprintf(stderr,"mmThreadCreate16(%p,%p,%08lx,%08lx),stub!\n",
3718 x1,x2,x3,x4
3719 );
3720 *x2 = 0xbabe;
3721 return 0;
3722 }
3723
3724 /**************************************************************************
3725 * mmThreadGetTask [MMSYSTEM.1125]
3726 */
3727 LRESULT WINAPI mmThreadGetTask16(WORD hnd) {
3728 fprintf(stderr,"mmThreadGetTask16(%04x),stub!\n",hnd);
3729 return GetCurrentTask();
3730 }
3731
3732 /**************************************************************************
3733 * mmThreadSignal [MMSYSTEM.1121]
3734 */
3735 LRESULT WINAPI mmThreadSignal16(WORD hnd) {
3736 fprintf(stderr,"mmThreadSignal16(%04x), stub!\n",hnd);
3737 return 0;
3738 }
3739
3740 /**************************************************************************
3741 * mmTaskCreate [MMSYSTEM.900]
3742 */
3743 LRESULT WINAPI mmTaskCreate16(LPWORD lphnd,DWORD x1,DWORD x2) {
3744 fprintf(stderr,"mmTaskCreate16(%p,%08lx,%08lx),stub!\n",lphnd,x1,x2);
3745 *lphnd = 0xcafe;
3746 return 0;
3747 }
3748
3749 /**************************************************************************
3750 * mmTaskSignal [MMSYSTEM.903]
3751 */
3752 LRESULT WINAPI mmTaskSignal16(HTASK16 ht) {
3753 fprintf(stderr,"mmTaskSignal(%04x),stub!\n",ht);
3754 return PostAppMessage16(ht,0x400,0,0);
3755 }
3756
3757 /**************************************************************************
3758 * mciDriverYield [MMSYSTEM.710]
3759 */
3760 LRESULT WINAPI mciDriverYield16(HANDLE16 hnd) {
3761 fprintf(stderr,"mciDriverYield16(%04x),stub!\n",hnd);
3762 return 0;
3763 }
3764
useful hacks and other patches not (yet) suitable for mainline