?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980315
[wine/gsoc_dplay.git] / multimedia / mmsystem.c
blob12e55d76c7ee753e6e00ae199ae74b975aebb2e4
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 TRACE(mmsys, "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 TRACE(mmsys, "SoundName='%s' uFlags=%04X !\n",
158 lpszSoundName, uFlags);
159 if (lpszSoundName == NULL) {
160 TRACE(mmsys, "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 FIXME(mmsys, "SND_MEMORY flag not implemented!\n");
168 return FALSE;
169 }
170
171 if (hmmio == 0)
172 {
173 TRACE(mmsys, "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 WARN(mmsys, "can't find SystemSound='%s' !\n", str);
181 return FALSE;
182 }
183 }
184
185 if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0)
186 {
187 TRACE(mmsys, "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 TRACE(mmsys, "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 TRACE(mmsys, "wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag);
209 TRACE(mmsys, "nChannels=%d \n", pcmWaveFormat.wf.nChannels);
210 TRACE(mmsys, "nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec);
211 TRACE(mmsys, "nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec);
212 TRACE(mmsys, "nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign);
213 TRACE(mmsys, "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 TRACE(mmsys, "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 WARN(mmsys, "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 TRACE(mmsys, "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 TRACE(mmsys, "(%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 TRACE(mmsys, "CALLBACK_NULL !\n");
316 break;
317 case DCB_WINDOW:
318 TRACE(mmsys, "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 TRACE(mmsys, "CALLBACK_TASK !\n");
327 return FALSE;
328 case DCB_FUNCTION:
329 TRACE(mmsys, "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 TRACE(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 TRACE(mmsys, "auxGetNumDevs !\n");
702 count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
703 TRACE(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 TRACE(mmsys, "(%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 TRACE(mmsys, "(%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 TRACE(mmsys, "(%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 TRACE(mmsys, "(%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 TRACE(mmsys, "(%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 TRACE(mmsys, "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 TRACE(mmsys, "(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
1137 if (!IsWindow32(hWndCallBack)) return FALSE;
1138 TRACE(mmsys, "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 TRACE(mmsys, "(%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 TRACE(mmsys, "MAXMCIDRIVERS reached !\n");
1164 return MCIERR_INTERNAL;
1165 }
1166 }
1167 TRACE(mmsys, "wDevID=%04X \n", wDevID);
1168 memcpy(GetOpenDrv(wDevID),lpParms,sizeof(*lpParms));
1169
1170 if (dwParam & MCI_OPEN_ELEMENT) {
1171 char *s,*t;
1172
1173 TRACE(mmsys,"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 TRACE(mmsys, "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 TRACE(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 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 TRACE(mmsys, "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 TRACE(mmsys, "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 TRACE(mmsys, "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 TRACE(mmsys, "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 TRACE(mmsys, "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 WARN(mmsys, "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 TRACE(mmsys, "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 TRACE(mmsys, "(%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 TRACE(mmsys, "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 TRACE(mci, "(%08lX, %08lX)\n", dwFlags, (DWORD)lpParms);
1387 lpstrReturn = PTR_SEG_TO_LIN(lpParms->lpstrReturn);
1388 switch(dwFlags) {
1389 case MCI_SYSINFO_QUANTITY:
1390 TRACE(mci, "MCI_SYSINFO_QUANTITY \n");
1391 lpdwRet = (DWORD *)lpstrReturn;
1392 *(lpdwRet) = InstalledCount;
1393 return 0;
1394 case MCI_SYSINFO_INSTALLNAME:
1395 TRACE(mci, "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 TRACE(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 TRACE(mci, "MCI_SYSINFO_NAME \n");
1416 return 0;
1417 case MCI_SYSINFO_OPEN:
1418 TRACE(mci, "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 TRACE(mci, "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 TRACE(mci, "(%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 WARN(mci, "unknown device type=%04X !\n",
1602 GetDrv(wDevID)->modp.wType);
1603 }
1604 }
1605 return MMSYSERR_INVALPARAM;
1606 }
1607
1608 /**************************************************************************
1609 * mciGetDeviceID [MMSYSTEM.703]
1610 */
1611 UINT16 WINAPI mciGetDeviceID (LPCSTR lpstrName)
1612 {
1613 UINT16 wDevID;
1614
1615 TRACE(mci, "(\"%s\")\n", lpstrName);
1616 if (lpstrName && !lstrcmpi32A(lpstrName, "ALL"))
1617 return MCI_ALL_DEVICE_ID;
1618
1619 if (!lpstrName)
1620 return 0;
1621
1622 wDevID = MMSYSTEM_FirstDevID();
1623 while(MMSYSTEM_DevIDValid(wDevID) && GetDrv(wDevID)->modp.wType) {
1624 if (GetOpenDrv(wDevID)->lpstrDeviceType &&
1625 strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrDeviceType), lpstrName) == 0)
1626 return wDevID;
1627
1628 if (GetOpenDrv(wDevID)->lpstrAlias &&
1629 strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrAlias), lpstrName) == 0)
1630 return wDevID;
1631
1632 wDevID = MMSYSTEM_NextDevID(wDevID);
1633 }
1634
1635 return 0;
1636 }
1637
1638 /**************************************************************************
1639 * mciSetYieldProc [MMSYSTEM.714]
1640 */
1641 BOOL16 WINAPI mciSetYieldProc (UINT16 uDeviceID,
1642 YIELDPROC fpYieldProc, DWORD dwYieldData)
1643 {
1644 return FALSE;
1645 }
1646
1647 /**************************************************************************
1648 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
1649 */
1650 UINT16 WINAPI mciGetDeviceIDFromElementID(DWORD dwElementID, LPCSTR lpstrType)
1651 {
1652 return 0;
1653 }
1654
1655 /**************************************************************************
1656 * mciGetYieldProc [MMSYSTEM.716]
1657 */
1658 YIELDPROC WINAPI mciGetYieldProc(UINT16 uDeviceID, DWORD * lpdwYieldData)
1659 {
1660 return NULL;
1661 }
1662
1663 /**************************************************************************
1664 * mciGetCreatorTask [MMSYSTEM.717]
1665 */
1666 HTASK16 WINAPI mciGetCreatorTask(UINT16 uDeviceID)
1667 {
1668 return 0;
1669 }
1670
1671 /**************************************************************************
1672 * midiOutGetNumDevs [WINMM.80]
1673 */
1674 UINT32 WINAPI midiOutGetNumDevs32(void)
1675 {
1676 return midiOutGetNumDevs16();
1677 }
1678 /**************************************************************************
1679 * midiOutGetNumDevs [MMSYSTEM.201]
1680 */
1681 UINT16 WINAPI midiOutGetNumDevs16(void)
1682 {
1683 UINT16 count = 0;
1684 TRACE(mmsys, "midiOutGetNumDevs\n");
1685 count += modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
1686 TRACE(mmsys, "midiOutGetNumDevs return %u \n", count);
1687 return count;
1688 }
1689
1690 /**************************************************************************
1691 * midiOutGetDevCapsW [WINMM.76]
1692 */
1693 UINT32 WINAPI midiOutGetDevCaps32W(UINT32 uDeviceID,LPMIDIOUTCAPS32W lpCaps, UINT32 uSize)
1694 {
1695 MIDIOUTCAPS16 moc16;
1696 UINT32 ret;
1697
1698 ret = midiOutGetDevCaps16(uDeviceID,&moc16,sizeof(moc16));
1699 lpCaps->wMid = moc16.wMid;
1700 lpCaps->wPid = moc16.wPid;
1701 lpCaps->vDriverVersion = moc16.vDriverVersion;
1702 lstrcpyAtoW(lpCaps->szPname,moc16.szPname);
1703 lpCaps->wTechnology = moc16.wTechnology;
1704 lpCaps->wVoices = moc16.wVoices;
1705 lpCaps->wNotes = moc16.wNotes;
1706 lpCaps->wChannelMask = moc16.wChannelMask;
1707 lpCaps->dwSupport = moc16.dwSupport;
1708 return ret;
1709 }
1710 /**************************************************************************
1711 * midiOutGetDevCapsA [WINMM.75]
1712 */
1713 UINT32 WINAPI midiOutGetDevCaps32A(UINT32 uDeviceID,LPMIDIOUTCAPS32A lpCaps, UINT32 uSize)
1714 {
1715 MIDIOUTCAPS16 moc16;
1716 UINT32 ret;
1717
1718 ret = midiOutGetDevCaps16(uDeviceID,&moc16,sizeof(moc16));
1719 lpCaps->wMid = moc16.wMid;
1720 lpCaps->wPid = moc16.wPid;
1721 lpCaps->vDriverVersion = moc16.vDriverVersion;
1722 strcpy(lpCaps->szPname,moc16.szPname);
1723 lpCaps->wTechnology = moc16.wTechnology;
1724 lpCaps->wVoices = moc16.wVoices;
1725 lpCaps->wNotes = moc16.wNotes;
1726 lpCaps->wChannelMask = moc16.wChannelMask;
1727 lpCaps->dwSupport = moc16.dwSupport;
1728 return ret;
1729 }
1730
1731 /**************************************************************************
1732 * midiOutGetDevCaps [MMSYSTEM.202]
1733 */
1734 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID,LPMIDIOUTCAPS16 lpCaps, UINT16 uSize)
1735 {
1736 TRACE(mmsys, "midiOutGetDevCaps\n");
1737 return modMessage(uDeviceID,MODM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);
1738 }
1739
1740 /**************************************************************************
1741 * midiOutGetErrorTextA [WINMM.77]
1742 */
1743 UINT32 WINAPI midiOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
1744 {
1745 TRACE(mmsys, "midiOutGetErrorText\n");
1746 return midiGetErrorText(uError, lpText, uSize);
1747 }
1748
1749 /**************************************************************************
1750 * midiOutGetErrorTextW [WINMM.78]
1751 */
1752 UINT32 WINAPI midiOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
1753 {
1754 LPSTR xstr = HeapAlloc(GetProcessHeap(),0,uSize);
1755 UINT32 ret;
1756
1757 TRACE(mmsys, "midiOutGetErrorText\n");
1758 ret = midiGetErrorText(uError, xstr, uSize);
1759 lstrcpyAtoW(lpText,xstr);
1760 HeapFree(GetProcessHeap(),0,xstr);
1761 return ret;
1762 }
1763 /**************************************************************************
1764 * midiOutGetErrorText [MMSYSTEM.203]
1765 */
1766 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
1767 {
1768 TRACE(mmsys, "midiOutGetErrorText\n");
1769 return midiGetErrorText(uError, lpText, uSize);
1770 }
1771
1772 /**************************************************************************
1773 * midiGetErrorText [internal]
1774 */
1775 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1776 {
1777 LPSTR msgptr;
1778 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1779 lpText[0] = '\0';
1780 switch(uError) {
1781 case MIDIERR_UNPREPARED:
1782 msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1783 break;
1784 case MIDIERR_STILLPLAYING:
1785 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1786 break;
1787 case MIDIERR_NOMAP:
1788 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.";
1789 break;
1790 case MIDIERR_NOTREADY:
1791 msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
1792 break;
1793 case MIDIERR_NODEVICE:
1794 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.";
1795 break;
1796 case MIDIERR_INVALIDSETUP:
1797 msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
1798 break;
1799 /*
1800 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
1801 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
1802 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
1803 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.
1804 msg# 340 : An error occurred using the specified port.
1805 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
1806 msg# 342 : There is no current MIDI port.
1807 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
1808 */
1809 default:
1810 msgptr = "Unknown MIDI Error !\n";
1811 break;
1812 }
1813 lstrcpyn32A(lpText, msgptr, uSize);
1814 return TRUE;
1815 }
1816
1817 /**************************************************************************
1818 * midiOutOpen [WINM.84]
1819 */
1820 UINT32 WINAPI midiOutOpen32(HMIDIOUT32 * lphMidiOut, UINT32 uDeviceID,
1821 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1822 {
1823 HMIDIOUT16 hmo16;
1824 UINT32 ret;
1825
1826 ret = midiOutOpen16(&hmo16,uDeviceID,dwCallback,dwInstance,dwFlags);
1827 if (lphMidiOut) *lphMidiOut = hmo16;
1828 return ret;
1829 }
1830 /**************************************************************************
1831 * midiOutOpen [MMSYSTEM.204]
1832 */
1833 UINT16 WINAPI midiOutOpen16(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
1834 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1835 {
1836 HMIDI16 hMidiOut;
1837 LPMIDIOPENDESC lpDesc;
1838 DWORD dwRet = 0;
1839 BOOL32 bMapperFlg = FALSE;
1840 if (lphMidiOut != NULL) *lphMidiOut = 0;
1841 TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
1842 lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
1843 if (uDeviceID == (UINT16)MIDI_MAPPER) {
1844 TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
1845 bMapperFlg = TRUE;
1846 uDeviceID = 0;
1847 }
1848 hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1849 if (lphMidiOut != NULL) *lphMidiOut = hMidiOut;
1850 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1851 if (lpDesc == NULL)
1852 return MMSYSERR_NOMEM;
1853 lpDesc->hMidi = hMidiOut;
1854 lpDesc->dwCallback = dwCallback;
1855 lpDesc->dwInstance = dwInstance;
1856 while(uDeviceID < MAXMIDIDRIVERS) {
1857 dwRet = modMessage(uDeviceID, MODM_OPEN,
1858 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
1859 if (dwRet == MMSYSERR_NOERROR) break;
1860 if (!bMapperFlg) break;
1861 uDeviceID++;
1862 TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
1863 }
1864 return dwRet;
1865 }
1866
1867 /**************************************************************************
1868 * midiOutClose [WINMM.74]
1869 */
1870 UINT32 WINAPI midiOutClose32(HMIDIOUT32 hMidiOut)
1871 {
1872 return midiOutClose16(hMidiOut);
1873 }
1874
1875 /**************************************************************************
1876 * midiOutClose [MMSYSTEM.205]
1877 */
1878 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
1879 {
1880 LPMIDIOPENDESC lpDesc;
1881 TRACE(mmsys, "(%04X)\n", hMidiOut);
1882 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1883 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1884 return modMessage(0, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
1885 }
1886
1887 /**************************************************************************
1888 * midiOutPrepareHeader [WINMM.85]
1889 */
1890 UINT32 WINAPI midiOutPrepareHeader32(HMIDIOUT32 hMidiOut,
1891 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
1892 {
1893 return midiOutPrepareHeader16(hMidiOut,lpMidiOutHdr,uSize);
1894 }
1895
1896 /**************************************************************************
1897 * midiOutPrepareHeader [MMSYSTEM.206]
1898 */
1899 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,
1900 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1901 {
1902 LPMIDIOPENDESC lpDesc;
1903 TRACE(mmsys, "(%04X, %p, %d)\n",
1904 hMidiOut, lpMidiOutHdr, uSize);
1905 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1906 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1907 return modMessage(0, MODM_PREPARE, lpDesc->dwInstance,
1908 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1909 }
1910
1911 /**************************************************************************
1912 * midiOutUnprepareHeader [WINMM.89]
1913 */
1914 UINT32 WINAPI midiOutUnprepareHeader32(HMIDIOUT32 hMidiOut,
1915 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
1916 {
1917 return midiOutUnprepareHeader16(hMidiOut,lpMidiOutHdr,uSize);
1918 }
1919 /**************************************************************************
1920 * midiOutUnprepareHeader [MMSYSTEM.207]
1921 */
1922 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,
1923 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1924 {
1925 LPMIDIOPENDESC lpDesc;
1926 TRACE(mmsys, "(%04X, %p, %d)\n",
1927 hMidiOut, lpMidiOutHdr, uSize);
1928 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1929 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1930 return modMessage(0, MODM_UNPREPARE, lpDesc->dwInstance,
1931 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1932 }
1933
1934 /**************************************************************************
1935 * midiOutShortMsg [WINMM.88]
1936 */
1937 UINT32 WINAPI midiOutShortMsg32(HMIDIOUT32 hMidiOut, DWORD dwMsg)
1938 {
1939 return midiOutShortMsg16(hMidiOut,dwMsg);
1940 }
1941 /**************************************************************************
1942 * midiOutShortMsg [MMSYSTEM.208]
1943 */
1944 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
1945 {
1946 LPMIDIOPENDESC lpDesc;
1947 TRACE(mmsys, "(%04X, %08lX)\n", hMidiOut, dwMsg);
1948 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1949 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1950 return modMessage(0, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
1951 }
1952
1953 /**************************************************************************
1954 * midiOutLongMsg [WINMM.82]
1955 */
1956 UINT32 WINAPI midiOutLongMsg32(HMIDIOUT32 hMidiOut,
1957 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
1958 {
1959 return midiOutLongMsg16(hMidiOut,lpMidiOutHdr,uSize);
1960 }
1961
1962 /**************************************************************************
1963 * midiOutLongMsg [MMSYSTEM.209]
1964 */
1965 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,
1966 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
1967 {
1968 LPMIDIOPENDESC lpDesc;
1969 TRACE(mmsys, "(%04X, %p, %d)\n",
1970 hMidiOut, lpMidiOutHdr, uSize);
1971 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1972 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1973 return modMessage(0, MODM_LONGDATA, lpDesc->dwInstance,
1974 (DWORD)lpMidiOutHdr, (DWORD)uSize);
1975 }
1976
1977 /**************************************************************************
1978 * midiOutReset [WINMM.86]
1979 */
1980 UINT32 WINAPI midiOutReset32(HMIDIOUT32 hMidiOut)
1981 {
1982 return midiOutReset16(hMidiOut);
1983 }
1984
1985 /**************************************************************************
1986 * midiOutReset [MMSYSTEM.210]
1987 */
1988 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
1989 {
1990 LPMIDIOPENDESC lpDesc;
1991 TRACE(mmsys, "(%04X)\n", hMidiOut);
1992 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1993 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
1994 return modMessage(0, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
1995 }
1996
1997 /**************************************************************************
1998 * midiOutGetVolume [WINM.81]
1999 */
2000 UINT32 WINAPI midiOutGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
2001 {
2002 return midiOutGetVolume16(uDeviceID,lpdwVolume);
2003 }
2004 /**************************************************************************
2005 * midiOutGetVolume [MMSYSTEM.211]
2006 */
2007 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
2008 {
2009 TRACE(mmsys, "(%04X, %p);\n", uDeviceID, lpdwVolume);
2010 return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
2011 }
2012
2013 /**************************************************************************
2014 * midiOutSetVolume [WINMM.87]
2015 */
2016 UINT32 WINAPI midiOutSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
2017 {
2018 return midiOutSetVolume16(uDeviceID,dwVolume);
2019 }
2020
2021 /**************************************************************************
2022 * midiOutSetVolume [MMSYSTEM.212]
2023 */
2024 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
2025 {
2026 TRACE(mmsys, "(%04X, %08lX);\n", uDeviceID, dwVolume);
2027 return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
2028 }
2029
2030 /**************************************************************************
2031 * midiOutCachePatches [WINMM.73]
2032 */
2033 UINT32 WINAPI midiOutCachePatches32(HMIDIOUT32 hMidiOut, UINT32 uBank,
2034 WORD * lpwPatchArray, UINT32 uFlags)
2035 {
2036 return midiOutCachePatches16(hMidiOut,uBank,lpwPatchArray,uFlags);
2037 }
2038
2039 /**************************************************************************
2040 * midiOutCachePatches [MMSYSTEM.213]
2041 */
2042 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
2043 WORD * lpwPatchArray, UINT16 uFlags)
2044 {
2045 /* not really necessary to support this */
2046 fprintf(stdnimp, "midiOutCachePatches: not supported yet\n");
2047 return MMSYSERR_NOTSUPPORTED;
2048 }
2049
2050 /**************************************************************************
2051 * midiOutCacheDrumPatches [WINMM.72]
2052 */
2053 UINT32 WINAPI midiOutCacheDrumPatches32(HMIDIOUT32 hMidiOut, UINT32 uPatch,
2054 WORD * lpwKeyArray, UINT32 uFlags)
2055 {
2056 return midiOutCacheDrumPatches16(hMidiOut,uPatch,lpwKeyArray,uFlags);
2057 }
2058
2059 /**************************************************************************
2060 * midiOutCacheDrumPatches [MMSYSTEM.214]
2061 */
2062 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
2063 WORD * lpwKeyArray, UINT16 uFlags)
2064 {
2065 fprintf(stdnimp, "midiOutCacheDrumPatchesi: not supported yet\n");
2066 return MMSYSERR_NOTSUPPORTED;
2067 }
2068
2069 /**************************************************************************
2070 * midiOutGetID [WINMM.79]
2071 */
2072 UINT32 WINAPI midiOutGetID32(HMIDIOUT32 hMidiOut, UINT32 * lpuDeviceID)
2073 {
2074 UINT16 xid;
2075 UINT32 ret;
2076
2077 ret = midiOutGetID16(hMidiOut,&xid);
2078 *lpuDeviceID = xid;
2079 return ret;
2080 }
2081
2082 /**************************************************************************
2083 * midiOutGetID [MMSYSTEM.215]
2084 */
2085 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID)
2086 {
2087 TRACE(mmsys, "midiOutGetID\n");
2088 return 0;
2089 }
2090
2091 /**************************************************************************
2092 * midiOutMessage [WINMM.83]
2093 */
2094 DWORD WINAPI midiOutMessage32(HMIDIOUT32 hMidiOut, UINT32 uMessage,
2095 DWORD dwParam1, DWORD dwParam2)
2096 {
2097 LPMIDIOPENDESC lpDesc;
2098
2099 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2100 hMidiOut, uMessage, dwParam1, dwParam2);
2101 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2102 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2103 switch (uMessage) {
2104 case MODM_OPEN:
2105 fprintf(stderr,"midiOutMessage32: can't handle MODM_OPEN!\n");
2106 return 0;
2107 case MODM_GETDEVCAPS:
2108 return midiOutGetDevCaps32A(hMidiOut,(LPMIDIOUTCAPS32A)dwParam1,dwParam2);
2109 case MODM_GETNUMDEVS:
2110 case MODM_RESET:
2111 case MODM_CLOSE:
2112 case MODM_GETVOLUME:
2113 case MODM_SETVOLUME:
2114 case MODM_LONGDATA:
2115 case MODM_PREPARE:
2116 case MODM_UNPREPARE:
2117 /* no argument conversion needed */
2118 break;
2119 default:
2120 fprintf(stderr,"unhandled midiOutMessage32(%04x,%04x,%08lx,%08lx)\n",
2121 hMidiOut,uMessage,dwParam1,dwParam2
2122 );
2123 break;
2124 }
2125 return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2126 }
2127
2128 /**************************************************************************
2129 * midiOutMessage [MMSYSTEM.216]
2130 */
2131 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
2132 DWORD dwParam1, DWORD dwParam2)
2133 {
2134 LPMIDIOPENDESC lpDesc;
2135
2136 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2137 hMidiOut, uMessage, dwParam1, dwParam2);
2138 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2139 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2140 switch (uMessage) {
2141 case MODM_OPEN:
2142 fprintf(stderr,"midiOutMessage16: can't handle MODM_OPEN!\n");
2143 return 0;
2144 case MODM_GETNUMDEVS:
2145 case MODM_RESET:
2146 case MODM_CLOSE:
2147 case MODM_SETVOLUME:
2148 /* no argument conversion needed */
2149 break;
2150 case MODM_GETVOLUME:
2151 return midiOutGetVolume16(hMidiOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
2152 case MODM_LONGDATA:
2153 return midiOutLongMsg16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2154 case MODM_PREPARE:
2155 return midiOutPrepareHeader16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2156 case MODM_UNPREPARE:
2157 return midiOutUnprepareHeader16(hMidiOut,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2158 default:
2159 fprintf(stderr,"unhandled midiOutMessage16(%04x,%04x,%08lx,%08lx)\n",
2160 hMidiOut,uMessage,dwParam1,dwParam2
2161 );
2162 break;
2163 }
2164 return modMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2165 }
2166
2167 /**************************************************************************
2168 * midiInGetNumDevs [WINMM.64]
2169 */
2170 UINT32 WINAPI midiInGetNumDevs32(void)
2171 {
2172 return midiInGetNumDevs16();
2173 }
2174
2175 /**************************************************************************
2176 * midiInGetNumDevs [MMSYSTEM.301]
2177 */
2178 UINT16 WINAPI midiInGetNumDevs16(void)
2179 {
2180 UINT16 count = 0;
2181 TRACE(mmsys, "midiInGetNumDevs\n");
2182 count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
2183 TRACE(mmsys, "midiInGetNumDevs return %u \n", count);
2184 return count;
2185 }
2186
2187 /**************************************************************************
2188 * midiInGetDevCaps [WINMM.60]
2189 */
2190 UINT32 WINAPI midiInGetDevCaps32W(UINT32 uDeviceID,
2191 LPMIDIINCAPS32W lpCaps, UINT32 uSize)
2192 {
2193 MIDIINCAPS16 mic16;
2194 UINT32 ret = midiInGetDevCaps16(uDeviceID,&mic16,uSize);
2195
2196 lpCaps->wMid = mic16.wMid;
2197 lpCaps->wPid = mic16.wPid;
2198 lpCaps->vDriverVersion = mic16.vDriverVersion;
2199 lstrcpyAtoW(lpCaps->szPname,mic16.szPname);
2200 lpCaps->dwSupport = mic16.dwSupport;
2201 return ret;
2202 }
2203
2204 /**************************************************************************
2205 * midiInGetDevCaps [WINMM.59]
2206 */
2207 UINT32 WINAPI midiInGetDevCaps32A(UINT32 uDeviceID,
2208 LPMIDIINCAPS32A lpCaps, UINT32 uSize)
2209 {
2210 MIDIINCAPS16 mic16;
2211 UINT32 ret = midiInGetDevCaps16(uDeviceID,&mic16,uSize);
2212
2213 lpCaps->wMid = mic16.wMid;
2214 lpCaps->wPid = mic16.wPid;
2215 lpCaps->vDriverVersion = mic16.vDriverVersion;
2216 strcpy(lpCaps->szPname,mic16.szPname);
2217 lpCaps->dwSupport = mic16.dwSupport;
2218 return ret;
2219 }
2220
2221 /**************************************************************************
2222 * midiInGetDevCaps [MMSYSTEM.302]
2223 */
2224 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID,
2225 LPMIDIINCAPS16 lpCaps, UINT16 uSize)
2226 {
2227 TRACE(mmsys, "midiInGetDevCaps\n");
2228 return midMessage(uDeviceID,MIDM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);;
2229 }
2230
2231 /**************************************************************************
2232 * midiInGetErrorText [WINMM.62]
2233 */
2234 UINT32 WINAPI midiInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2235 {
2236 LPSTR xstr = HeapAlloc(GetProcessHeap(),0,uSize);
2237 UINT32 ret = midiInGetErrorText16(uError,xstr,uSize);
2238 lstrcpyAtoW(lpText,xstr);
2239 HeapFree(GetProcessHeap(),0,xstr);
2240 return ret;
2241 }
2242 /**************************************************************************
2243 * midiInGetErrorText [WINMM.61]
2244 */
2245 UINT32 WINAPI midiInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2246 {
2247 return midiInGetErrorText16(uError,lpText,uSize);
2248 }
2249
2250 /**************************************************************************
2251 * midiInGetErrorText [MMSYSTEM.303]
2252 */
2253 UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2254 {
2255 TRACE(mmsys, "midiInGetErrorText\n");
2256 return (midiGetErrorText(uError, lpText, uSize));
2257 }
2258
2259 /**************************************************************************
2260 * midiInOpen [WINMM.66]
2261 */
2262 UINT32 WINAPI midiInOpen32(HMIDIIN32 * lphMidiIn, UINT32 uDeviceID,
2263 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2264 {
2265 HMIDIIN16 xhmid16;
2266 UINT32 ret = midiInOpen16(&xhmid16,uDeviceID,dwCallback,dwInstance,dwFlags);
2267 if (lphMidiIn) *lphMidiIn = xhmid16;
2268 return ret;
2269 }
2270
2271 /**************************************************************************
2272 * midiInOpen [MMSYSTEM.304]
2273 */
2274 UINT16 WINAPI midiInOpen16(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
2275 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2276 {
2277 HMIDI16 hMidiIn;
2278 LPMIDIOPENDESC lpDesc;
2279 DWORD dwRet = 0;
2280 BOOL32 bMapperFlg = FALSE;
2281
2282 if (lphMidiIn != NULL) *lphMidiIn = 0;
2283 TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
2284 lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
2285 if (uDeviceID == (UINT16)MIDI_MAPPER) {
2286 TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
2287 bMapperFlg = TRUE;
2288 uDeviceID = 0;
2289 }
2290 hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
2291 if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
2292 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2293 if (lpDesc == NULL) return MMSYSERR_NOMEM;
2294 lpDesc->hMidi = hMidiIn;
2295 lpDesc->dwCallback = dwCallback;
2296 lpDesc->dwInstance = dwInstance;
2297 while(uDeviceID < MAXMIDIDRIVERS) {
2298 dwRet = midMessage(uDeviceID, MIDM_OPEN,
2299 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
2300 if (dwRet == MMSYSERR_NOERROR) break;
2301 if (!bMapperFlg) break;
2302 uDeviceID++;
2303 TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
2304 }
2305 return dwRet;
2306 }
2307
2308 /**************************************************************************
2309 * midiInClose [WINMM.58]
2310 */
2311 UINT32 WINAPI midiInClose32(HMIDIIN32 hMidiIn)
2312 {
2313 return midiInClose16(hMidiIn);
2314 }
2315
2316 /**************************************************************************
2317 * midiInClose [MMSYSTEM.305]
2318 */
2319 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
2320 {
2321 LPMIDIOPENDESC lpDesc;
2322 TRACE(mmsys, "(%04X)\n", hMidiIn);
2323 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2324 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2325 return midMessage(0, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2326 }
2327
2328 /**************************************************************************
2329 * midiInPrepareHeader [WINMM.67]
2330 */
2331 UINT32 WINAPI midiInPrepareHeader32(HMIDIIN32 hMidiIn,
2332 MIDIHDR * lpMidiInHdr, UINT32 uSize)
2333 {
2334 return midiInPrepareHeader16(hMidiIn,lpMidiInHdr,uSize);
2335 }
2336
2337 /**************************************************************************
2338 * midiInPrepareHeader [MMSYSTEM.306]
2339 */
2340 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,
2341 MIDIHDR * lpMidiInHdr, UINT16 uSize)
2342 {
2343 LPMIDIOPENDESC lpDesc;
2344 TRACE(mmsys, "(%04X, %p, %d)\n",
2345 hMidiIn, lpMidiInHdr, uSize);
2346 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2347 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2348 return midMessage(0, MIDM_PREPARE, lpDesc->dwInstance,
2349 (DWORD)lpMidiInHdr, (DWORD)uSize);
2350 }
2351
2352 /**************************************************************************
2353 * midiInUnprepareHeader [WINMM.71]
2354 */
2355 UINT32 WINAPI midiInUnprepareHeader32(HMIDIIN32 hMidiIn,
2356 MIDIHDR * lpMidiInHdr, UINT32 uSize)
2357 {
2358 return midiInUnprepareHeader16(hMidiIn,lpMidiInHdr,uSize);
2359 }
2360
2361 /**************************************************************************
2362 * midiInUnprepareHeader [MMSYSTEM.307]
2363 */
2364 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,
2365 MIDIHDR * lpMidiInHdr, UINT16 uSize)
2366 {
2367 LPMIDIOPENDESC lpDesc;
2368 TRACE(mmsys, "(%04X, %p, %d)\n",
2369 hMidiIn, lpMidiInHdr, uSize);
2370 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2371 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2372 return midMessage(0, MIDM_UNPREPARE, lpDesc->dwInstance,
2373 (DWORD)lpMidiInHdr, (DWORD)uSize);
2374 }
2375
2376 /**************************************************************************
2377 * midiInAddBuffer [WINMM.57]
2378 */
2379 UINT32 WINAPI midiInAddBuffer32(HMIDIIN32 hMidiIn,
2380 MIDIHDR * lpMidiInHdr, UINT32 uSize)
2381 {
2382 return midiInAddBuffer16(hMidiIn,lpMidiInHdr,uSize);
2383 }
2384
2385 /**************************************************************************
2386 * midiInAddBuffer [MMSYSTEM.308]
2387 */
2388 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,
2389 MIDIHDR * lpMidiInHdr, UINT16 uSize)
2390 {
2391 TRACE(mmsys, "midiInAddBuffer\n");
2392 return 0;
2393 }
2394
2395 /**************************************************************************
2396 * midiInStart [WINMM.69]
2397 */
2398 UINT32 WINAPI midiInStart32(HMIDIIN32 hMidiIn)
2399 {
2400 return midiInStart16(hMidiIn);
2401 }
2402
2403 /**************************************************************************
2404 * midiInStart [MMSYSTEM.309]
2405 */
2406 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
2407 {
2408 TRACE(mmsys, "midiInStart\n");
2409 return 0;
2410 }
2411
2412 /**************************************************************************
2413 * midiInStop [WINMM.70]
2414 */
2415 UINT32 WINAPI midiInStop32(HMIDIIN32 hMidiIn)
2416 {
2417 return midiInStop16(hMidiIn);
2418 }
2419
2420 /**************************************************************************
2421 * midiInStop [MMSYSTEM.310]
2422 */
2423 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
2424 {
2425 TRACE(mmsys, "midiInStop\n");
2426 return 0;
2427 }
2428
2429 /**************************************************************************
2430 * midiInReset [WINMM.68]
2431 */
2432 UINT32 WINAPI midiInReset32(HMIDIIN32 hMidiIn)
2433 {
2434 return midiInReset16(hMidiIn);
2435 }
2436
2437 /**************************************************************************
2438 * midiInReset [MMSYSTEM.311]
2439 */
2440 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
2441 {
2442 TRACE(mmsys, "midiInReset\n");
2443 return 0;
2444 }
2445
2446 /**************************************************************************
2447 * midiInGetID [WINMM.63]
2448 */
2449 UINT32 WINAPI midiInGetID32(HMIDIIN32 hMidiIn, UINT32 * lpuDeviceID)
2450 {
2451 TRACE(mmsys, "midiInGetID\n");
2452 return 0;
2453 }
2454
2455 /**************************************************************************
2456 * midiInGetID [MMSYSTEM.312]
2457 */
2458 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16 * lpuDeviceID)
2459 {
2460 TRACE(mmsys, "midiInGetID\n");
2461 return 0;
2462 }
2463
2464 /**************************************************************************
2465 * midiInMessage [WINMM.65]
2466 */
2467 DWORD WINAPI midiInMessage32(HMIDIIN32 hMidiIn, UINT32 uMessage,
2468 DWORD dwParam1, DWORD dwParam2)
2469 {
2470 LPMIDIOPENDESC lpDesc;
2471 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2472 hMidiIn, uMessage, dwParam1, dwParam2);
2473 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2474 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2475 switch (uMessage) {
2476 case MIDM_OPEN:
2477 fprintf(stderr,"midiInMessage32: can't handle MIDM_OPEN!\n");
2478 return 0;
2479 case MIDM_GETDEVCAPS:
2480 return midiInGetDevCaps32A(hMidiIn,(LPMIDIINCAPS32A)dwParam1,dwParam2);
2481 case MIDM_GETNUMDEVS:
2482 case MIDM_RESET:
2483 case MIDM_STOP:
2484 case MIDM_START:
2485 case MIDM_CLOSE:
2486 /* no argument conversion needed */
2487 break;
2488 case MIDM_PREPARE:
2489 return midiInPrepareHeader32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
2490 case MIDM_UNPREPARE:
2491 return midiInUnprepareHeader32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
2492 case MIDM_ADDBUFFER:
2493 return midiInAddBuffer32(hMidiIn,(LPMIDIHDR)dwParam1,dwParam2);
2494 default:
2495 fprintf(stderr,"unhandled midiInMessage32(%04x,%04x,%08lx,%08lx)\n",
2496 hMidiIn,uMessage,dwParam1,dwParam2
2497 );
2498 break;
2499 }
2500 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2501 }
2502
2503 /**************************************************************************
2504 * midiInMessage [MMSYSTEM.313]
2505 */
2506 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
2507 DWORD dwParam1, DWORD dwParam2)
2508 {
2509 LPMIDIOPENDESC lpDesc;
2510 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2511 hMidiIn, uMessage, dwParam1, dwParam2);
2512 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2513 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2514 switch (uMessage) {
2515 case MIDM_OPEN:
2516 fprintf(stderr,"midiInMessage16: can't handle MIDM_OPEN!\n");
2517 return 0;
2518 case MIDM_GETDEVCAPS:
2519 return midiInGetDevCaps16(hMidiIn,(LPMIDIINCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2520 case MIDM_GETNUMDEVS:
2521 case MIDM_RESET:
2522 case MIDM_STOP:
2523 case MIDM_START:
2524 case MIDM_CLOSE:
2525 /* no argument conversion needed */
2526 break;
2527 case MIDM_PREPARE:
2528 return midiInPrepareHeader16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2529 case MIDM_UNPREPARE:
2530 return midiInUnprepareHeader16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2531 case MIDM_ADDBUFFER:
2532 return midiInAddBuffer16(hMidiIn,(LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
2533 default:
2534 fprintf(stderr,"unhandled midiInMessage16(%04x,%04x,%08lx,%08lx)\n",
2535 hMidiIn,uMessage,dwParam1,dwParam2
2536 );
2537 break;
2538 }
2539 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2540 }
2541
2542
2543 /**************************************************************************
2544 * waveOutGetNumDevs [MMSYSTEM.401]
2545 */
2546 UINT32 WINAPI waveOutGetNumDevs32() {
2547 return waveOutGetNumDevs16();
2548 }
2549
2550 /**************************************************************************
2551 * waveOutGetNumDevs [WINMM.167]
2552 */
2553 UINT16 WINAPI waveOutGetNumDevs16()
2554 {
2555 UINT16 count = 0;
2556 TRACE(mmsys, "waveOutGetNumDevs\n");
2557 count += wodMessage( MMSYSTEM_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L);
2558 TRACE(mmsys, "waveOutGetNumDevs return %u \n", count);
2559 return count;
2560 }
2561
2562 /**************************************************************************
2563 * waveOutGetDevCaps [MMSYSTEM.402]
2564 */
2565 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, WAVEOUTCAPS16 * lpCaps,
2566 UINT16 uSize)
2567 {
2568 if (uDeviceID > waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID;
2569 if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */
2570 TRACE(mmsys, "waveOutGetDevCaps\n");
2571 return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
2572 }
2573
2574 /**************************************************************************
2575 * waveOutGetDevCapsA [WINMM.162]
2576 */
2577 UINT32 WINAPI waveOutGetDevCaps32A(UINT32 uDeviceID, LPWAVEOUTCAPS32A lpCaps,
2578 UINT32 uSize)
2579 {
2580 WAVEOUTCAPS16 woc16;
2581 UINT16 ret = waveOutGetDevCaps16(uDeviceID,&woc16,sizeof(woc16));
2582
2583 lpCaps->wMid = woc16.wMid;
2584 lpCaps->wPid = woc16.wPid;
2585 lpCaps->vDriverVersion = woc16.vDriverVersion;
2586 strcpy(lpCaps->szPname,woc16.szPname);
2587 lpCaps->dwFormats = woc16.dwFormats;
2588 lpCaps->wChannels = woc16.wChannels;
2589 lpCaps->dwSupport = woc16.dwSupport;
2590 return ret;
2591 }
2592
2593 /**************************************************************************
2594 * waveOutGetDevCapsW [WINMM.163]
2595 */
2596 UINT32 WINAPI waveOutGetDevCaps32W(UINT32 uDeviceID, LPWAVEOUTCAPS32W lpCaps,
2597 UINT32 uSize)
2598 {
2599 WAVEOUTCAPS16 woc16;
2600 UINT32 ret = waveOutGetDevCaps16(uDeviceID,&woc16,sizeof(woc16));
2601
2602 lpCaps->wMid = woc16.wMid;
2603 lpCaps->wPid = woc16.wPid;
2604 lpCaps->vDriverVersion = woc16.vDriverVersion;
2605 lstrcpyAtoW(lpCaps->szPname,woc16.szPname);
2606 lpCaps->dwFormats = woc16.dwFormats;
2607 lpCaps->wChannels = woc16.wChannels;
2608 lpCaps->dwSupport = woc16.dwSupport;
2609 return ret;
2610 }
2611
2612 /**************************************************************************
2613 * waveOutGetErrorText [MMSYSTEM.403]
2614 */
2615 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2616 {
2617 TRACE(mmsys, "waveOutGetErrorText\n");
2618 return(waveGetErrorText(uError, lpText, uSize));
2619 }
2620
2621 /**************************************************************************
2622 * waveOutGetErrorTextA [WINMM.164]
2623 */
2624 UINT32 WINAPI waveOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2625 {
2626 return(waveOutGetErrorText16(uError, lpText, uSize));
2627 }
2628
2629 /**************************************************************************
2630 * waveOutGetErrorTextW [WINMM.165]
2631 */
2632 UINT32 WINAPI waveOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2633 {
2634 LPSTR xstr = HeapAlloc(GetProcessHeap(),0,uSize);
2635 UINT32 ret = waveOutGetErrorText32A(uError, xstr, uSize);
2636
2637 lstrcpyAtoW(lpText,xstr);
2638 HeapFree(GetProcessHeap(),0,xstr);
2639 return ret;
2640 }
2641
2642
2643 /**************************************************************************
2644 * waveGetErrorText [internal]
2645 */
2646 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
2647 {
2648 LPSTR msgptr;
2649 TRACE(mmsys, "(%04X, %p, %d);\n",
2650 uError, lpText, uSize);
2651 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
2652 lpText[0] = '\0';
2653 switch(uError) {
2654 case MMSYSERR_NOERROR:
2655 msgptr = "The specified command was carried out.";
2656 break;
2657 case MMSYSERR_ERROR:
2658 msgptr = "Undefined external error.";
2659 break;
2660 case MMSYSERR_BADDEVICEID:
2661 msgptr = "A device ID has been used that is out of range for your system.";
2662 break;
2663 case MMSYSERR_NOTENABLED:
2664 msgptr = "The driver was not enabled.";
2665 break;
2666 case MMSYSERR_ALLOCATED:
2667 msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
2668 break;
2669 case MMSYSERR_INVALHANDLE:
2670 msgptr = "The specified device handle is invalid.";
2671 break;
2672 case MMSYSERR_NODRIVER:
2673 msgptr = "There is no driver installed on your system !\n";
2674 break;
2675 case MMSYSERR_NOMEM:
2676 msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
2677 break;
2678 case MMSYSERR_NOTSUPPORTED:
2679 msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
2680 break;
2681 case MMSYSERR_BADERRNUM:
2682 msgptr = "An error number was specified that is not defined in the system.";
2683 break;
2684 case MMSYSERR_INVALFLAG:
2685 msgptr = "An invalid flag was passed to a system function.";
2686 break;
2687 case MMSYSERR_INVALPARAM:
2688 msgptr = "An invalid parameter was passed to a system function.";
2689 break;
2690 case WAVERR_BADFORMAT:
2691 msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
2692 break;
2693 case WAVERR_STILLPLAYING:
2694 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
2695 break;
2696 case WAVERR_UNPREPARED:
2697 msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
2698 break;
2699 case WAVERR_SYNC:
2700 msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
2701 break;
2702 default:
2703 msgptr = "Unknown MMSYSTEM Error !\n";
2704 break;
2705 }
2706 lstrcpyn32A(lpText, msgptr, uSize);
2707 return TRUE;
2708 }
2709
2710 /**************************************************************************
2711 * waveOutOpen [WINMM.173]
2712 * All the args/structs have the same layout as the win16 equivalents
2713 */
2714 UINT32 WINAPI waveOutOpen32(HWAVEOUT32 * lphWaveOut, UINT32 uDeviceID,
2715 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
2716 DWORD dwInstance, DWORD dwFlags)
2717 {
2718 HWAVEOUT16 hwo16;
2719 UINT32 ret=waveOutOpen16(&hwo16,uDeviceID,lpFormat,dwCallback,dwInstance,dwFlags);
2720 if (lphWaveOut) *lphWaveOut=hwo16;
2721 return ret;
2722 }
2723 /**************************************************************************
2724 * waveOutOpen [MMSYSTEM.404]
2725 */
2726 UINT16 WINAPI waveOutOpen16(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
2727 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
2728 DWORD dwInstance, DWORD dwFlags)
2729 {
2730 HWAVEOUT16 hWaveOut;
2731 LPWAVEOPENDESC lpDesc;
2732 DWORD dwRet = 0;
2733 BOOL32 bMapperFlg = FALSE;
2734
2735 TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
2736 lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
2737 if (dwFlags & WAVE_FORMAT_QUERY)
2738 TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
2739 if (uDeviceID == (UINT16)WAVE_MAPPER) {
2740 TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
2741 bMapperFlg = TRUE;
2742 uDeviceID = 0;
2743 }
2744 if (lpFormat == NULL) return WAVERR_BADFORMAT;
2745
2746 hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
2747 if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
2748 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2749 if (lpDesc == NULL) return MMSYSERR_NOMEM;
2750 lpDesc->hWave = hWaveOut;
2751 lpDesc->lpFormat = (LPWAVEFORMAT)lpFormat; /* should the struct be copied iso pointer? */
2752 lpDesc->dwCallBack = dwCallback;
2753 lpDesc->dwInstance = dwInstance;
2754 if (uDeviceID >= MAXWAVEDRIVERS)
2755 uDeviceID = 0;
2756 while(uDeviceID < MAXWAVEDRIVERS) {
2757 dwRet = wodMessage(uDeviceID, WODM_OPEN,
2758 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
2759 if (dwRet == MMSYSERR_NOERROR) break;
2760 if (!bMapperFlg) break;
2761 uDeviceID++;
2762 TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
2763 }
2764 lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */
2765 if (dwFlags & WAVE_FORMAT_QUERY) {
2766 TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
2767 dwRet = waveOutClose32(hWaveOut);
2768 }
2769 return dwRet;
2770 }
2771
2772 /**************************************************************************
2773 * waveOutClose [WINMM.161]
2774 */
2775 UINT32 WINAPI waveOutClose32(HWAVEOUT32 hWaveOut)
2776 {
2777 return waveOutClose16(hWaveOut);
2778 }
2779 /**************************************************************************
2780 * waveOutClose [MMSYSTEM.405]
2781 */
2782 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
2783 {
2784 LPWAVEOPENDESC lpDesc;
2785
2786 TRACE(mmsys, "(%04X)\n", hWaveOut);
2787 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2788 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2789 return wodMessage( lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2790 }
2791
2792 /**************************************************************************
2793 * waveOutPrepareHeader [WINMM.175]
2794 */
2795 UINT32 WINAPI waveOutPrepareHeader32(HWAVEOUT32 hWaveOut,
2796 WAVEHDR * lpWaveOutHdr, UINT32 uSize)
2797 {
2798 LPWAVEOPENDESC lpDesc;
2799
2800 TRACE(mmsys, "(%04X, %p, %u);\n",
2801 hWaveOut, lpWaveOutHdr, uSize);
2802 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2803 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2804 return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
2805 (DWORD)lpWaveOutHdr,uSize);
2806 }
2807 /**************************************************************************
2808 * waveOutPrepareHeader [MMSYSTEM.406]
2809 */
2810 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,
2811 WAVEHDR * lpWaveOutHdr, UINT16 uSize)
2812 {
2813 LPWAVEOPENDESC lpDesc;
2814 LPBYTE saveddata = lpWaveOutHdr->lpData;
2815 UINT16 ret;
2816
2817 TRACE(mmsys, "(%04X, %p, %u);\n",
2818 hWaveOut, lpWaveOutHdr, uSize);
2819 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2820 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2821 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
2822 ret = wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
2823 (DWORD)lpWaveOutHdr,uSize);
2824 lpWaveOutHdr->lpData = saveddata;
2825 return ret;
2826 }
2827
2828 /**************************************************************************
2829 * waveOutUnprepareHeader [WINMM.181]
2830 */
2831 UINT32 WINAPI waveOutUnprepareHeader32(HWAVEOUT32 hWaveOut,
2832 WAVEHDR * lpWaveOutHdr, UINT32 uSize)
2833 {
2834 LPWAVEOPENDESC lpDesc;
2835
2836 TRACE(mmsys, "(%04X, %p, %u);\n",
2837 hWaveOut, lpWaveOutHdr, uSize);
2838 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2839 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2840 return wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
2841 (DWORD)lpWaveOutHdr, uSize);
2842 }
2843 /**************************************************************************
2844 * waveOutUnprepareHeader [MMSYSTEM.407]
2845 */
2846 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,
2847 WAVEHDR * lpWaveOutHdr, UINT16 uSize)
2848 {
2849 LPWAVEOPENDESC lpDesc;
2850 LPBYTE saveddata = lpWaveOutHdr->lpData;
2851 UINT16 ret;
2852
2853 TRACE(mmsys, "(%04X, %p, %u);\n",
2854 hWaveOut, lpWaveOutHdr, uSize);
2855 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2856 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2857 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
2858 ret = wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
2859 (DWORD)lpWaveOutHdr, uSize);
2860 lpWaveOutHdr->lpData = saveddata;
2861 return ret;
2862 }
2863
2864 /**************************************************************************
2865 * waveOutWrite [MMSYSTEM.408]
2866 */
2867 UINT32 WINAPI waveOutWrite32(HWAVEOUT32 hWaveOut, WAVEHDR * lpWaveOutHdr,
2868 UINT32 uSize)
2869 {
2870 LPWAVEOPENDESC lpDesc;
2871 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2872 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2873 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2874 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
2875 return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
2876 }
2877 /**************************************************************************
2878 * waveOutWrite [MMSYSTEM.408]
2879 */
2880 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
2881 UINT16 uSize)
2882 {
2883 LPWAVEOPENDESC lpDesc;
2884 UINT16 ret;
2885
2886 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2887 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2888 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2889 lpWaveOutHdr->reserved=(DWORD)lpWaveOutHdr->lpData;/*save original ptr*/
2890 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
2891 ret = wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
2892 lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved;
2893 return ret;
2894 }
2895
2896 /**************************************************************************
2897 * waveOutPause [WINMM.174]
2898 */
2899 UINT32 WINAPI waveOutPause32(HWAVEOUT32 hWaveOut)
2900 {
2901 return waveOutPause16(hWaveOut);
2902 }
2903
2904 /**************************************************************************
2905 * waveOutPause [MMSYSTEM.409]
2906 */
2907 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut)
2908 {
2909 LPWAVEOPENDESC lpDesc;
2910
2911 TRACE(mmsys, "(%04X)\n", hWaveOut);
2912 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2913 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2914 return wodMessage( lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
2915 }
2916
2917 /**************************************************************************
2918 * waveOutRestart [WINMM.177]
2919 */
2920 UINT32 WINAPI waveOutRestart32(HWAVEOUT32 hWaveOut)
2921 {
2922 return waveOutRestart16(hWaveOut);
2923 }
2924 /**************************************************************************
2925 * waveOutRestart [MMSYSTEM.410]
2926 */
2927 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut)
2928 {
2929 LPWAVEOPENDESC lpDesc;
2930
2931 TRACE(mmsys, "(%04X)\n", hWaveOut);
2932 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2933 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2934 return wodMessage( lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
2935 }
2936
2937 /**************************************************************************
2938 * waveOutReset [WINMM.176]
2939 */
2940 UINT32 WINAPI waveOutReset32(HWAVEOUT32 hWaveOut)
2941 {
2942 return waveOutReset16(hWaveOut);
2943 }
2944
2945 /**************************************************************************
2946 * waveOutReset [MMSYSTEM.411]
2947 */
2948 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut)
2949 {
2950 LPWAVEOPENDESC lpDesc;
2951 TRACE(mmsys, "(%04X)\n", hWaveOut);
2952 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2953 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2954 return wodMessage( lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
2955 }
2956
2957 /**************************************************************************
2958 * waveOutGetPosition [WINMM.170]
2959 */
2960 UINT32 WINAPI waveOutGetPosition32(HWAVEOUT32 hWaveOut, LPMMTIME32 lpTime,
2961 UINT32 uSize)
2962 {
2963 MMTIME16 mmt16;
2964 UINT32 ret;
2965
2966 mmt16.wType = lpTime->wType;
2967 ret = waveOutGetPosition16(hWaveOut,&mmt16,sizeof(mmt16));
2968 MMSYSTEM_MMTIME16to32(lpTime,&mmt16);
2969 return ret;
2970 }
2971 /**************************************************************************
2972 * waveOutGetPosition [MMSYSTEM.412]
2973 */
2974 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut,LPMMTIME16 lpTime,
2975 UINT16 uSize)
2976 {
2977 LPWAVEOPENDESC lpDesc;
2978 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
2979 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
2980 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2981 return wodMessage( lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance,
2982 (DWORD)lpTime, (DWORD)uSize);
2983 }
2984
2985 #define WAVEOUT_SHORTCUT_1(xx,XX,atype) \
2986 UINT32 WINAPI waveOut##xx##32(HWAVEOUT32 hWaveOut, atype x) \
2987 { \
2988 return waveOut##xx##16(hWaveOut,x); \
2989 } \
2990 UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \
2991 { \
2992 LPWAVEOPENDESC lpDesc; \
2993 TRACE(mmsys, "waveOut"#xx"(%04X, %08lx);\n", hWaveOut,(DWORD)x);\
2994 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \
2995 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \
2996 return wodMessage(lpDesc->uDeviceID, WODM_##XX, lpDesc->dwInstance,\
2997 (DWORD)x, 0L); \
2998 }
2999
3000 WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH,DWORD*)
3001 WAVEOUT_SHORTCUT_1(SetPitch,SETPITCH,DWORD)
3002 WAVEOUT_SHORTCUT_1(GetPlaybackRate,GETPLAYBACKRATE,DWORD*)
3003 WAVEOUT_SHORTCUT_1(SetPlaybackRate,SETPLAYBACKRATE,DWORD)
3004
3005 #define WAVEOUT_SHORTCUT_2(xx,XX,atype) \
3006 UINT32 WINAPI waveOut##xx##32(UINT32 devid, atype x) \
3007 { \
3008 return waveOut##xx##16(devid,x); \
3009 } \
3010 UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \
3011 { \
3012 TRACE(mmsys, "waveOut"#xx"(%04X, %08lx);\n", devid,(DWORD)x); \
3013 return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \
3014 }
3015
3016
3017 WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME,DWORD*)
3018 WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME,DWORD)
3019
3020
3021 /**************************************************************************
3022 * waveOutBreakLoop [MMSYSTEM.419]
3023 */
3024 UINT32 WINAPI waveOutBreakLoop32(HWAVEOUT32 hWaveOut)
3025 {
3026 return waveOutBreakLoop16(hWaveOut);
3027 }
3028 /**************************************************************************
3029 * waveOutBreakLoop [MMSYSTEM.419]
3030 */
3031 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut)
3032 {
3033 TRACE(mmsys, "(%04X)\n", hWaveOut);
3034 return MMSYSERR_INVALHANDLE;
3035 }
3036
3037 /**************************************************************************
3038 * waveOutGetID [MMSYSTEM.420]
3039 */
3040 UINT32 WINAPI waveOutGetID32(HWAVEOUT32 hWaveOut, UINT32 * lpuDeviceID)
3041 {
3042 LPWAVEOPENDESC lpDesc;
3043 TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
3044 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3045 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3046 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3047 *lpuDeviceID = lpDesc->uDeviceID;
3048 return 0;
3049 }
3050 /**************************************************************************
3051 * waveOutGetID [MMSYSTEM.420]
3052 */
3053 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID)
3054 {
3055 LPWAVEOPENDESC lpDesc;
3056 TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
3057 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3058 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3059 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3060 *lpuDeviceID = lpDesc->uDeviceID;
3061 return 0;
3062 }
3063
3064 /**************************************************************************
3065 * waveOutMessage [MMSYSTEM.421]
3066 */
3067 DWORD WINAPI waveOutMessage32(HWAVEOUT32 hWaveOut, UINT32 uMessage,
3068 DWORD dwParam1, DWORD dwParam2)
3069 {
3070 LPWAVEOPENDESC lpDesc;
3071
3072 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3073 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3074 switch (uMessage) {
3075 case WODM_GETNUMDEVS:
3076 case WODM_GETPOS:
3077 case WODM_GETVOLUME:
3078 case WODM_GETPITCH:
3079 case WODM_GETPLAYBACKRATE:
3080 case WODM_SETVOLUME:
3081 case WODM_SETPITCH:
3082 case WODM_SETPLAYBACKRATE:
3083 case WODM_RESET:
3084 case WODM_PAUSE:
3085 case WODM_PREPARE:
3086 case WODM_UNPREPARE:
3087 case WODM_STOP:
3088 case WODM_CLOSE:
3089 /* no argument conversion needed */
3090 break;
3091 case WODM_WRITE:
3092 return waveOutWrite32(hWaveOut,(LPWAVEHDR)dwParam1,dwParam2);
3093 case WODM_GETDEVCAPS:
3094 /* FIXME: UNICODE/ANSI? */
3095 return waveOutGetDevCaps32A(hWaveOut,(LPWAVEOUTCAPS32A)dwParam1,dwParam2);
3096 case WODM_OPEN:
3097 fprintf(stderr,"waveOutMessage32 can't handle WODM_OPEN, please report.\n");
3098 break;
3099 default:
3100 fprintf(stderr,"unhandled waveOutMessage32(0x%04x,0x%04x,%08lx,%08lx)\n",
3101 hWaveOut,uMessage,dwParam1,dwParam2
3102 );
3103 break;
3104 }
3105 return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3106 }
3107
3108 /**************************************************************************
3109 * waveOutMessage [MMSYSTEM.421]
3110 */
3111 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
3112 DWORD dwParam1, DWORD dwParam2)
3113 {
3114 LPWAVEOPENDESC lpDesc;
3115
3116 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3117 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3118 switch (uMessage) {
3119 case WODM_GETNUMDEVS:
3120 case WODM_SETVOLUME:
3121 case WODM_SETPITCH:
3122 case WODM_SETPLAYBACKRATE:
3123 case WODM_RESET:
3124 case WODM_PAUSE:
3125 case WODM_STOP:
3126 case WODM_CLOSE:
3127 /* no argument conversion needed */
3128 break;
3129 case WODM_GETPOS:
3130 return waveOutGetPosition16(hWaveOut,(LPMMTIME16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3131 case WODM_GETVOLUME:
3132 return waveOutGetVolume16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3133 case WODM_GETPITCH:
3134 return waveOutGetPitch16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3135 case WODM_GETPLAYBACKRATE:
3136 return waveOutGetPlaybackRate16(hWaveOut,(LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3137 case WODM_GETDEVCAPS:
3138 return waveOutGetDevCaps16(hWaveOut,(LPWAVEOUTCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3139 case WODM_PREPARE:
3140 return waveOutPrepareHeader16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3141 case WODM_UNPREPARE:
3142 return waveOutUnprepareHeader16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3143 case WODM_WRITE:
3144 return waveOutWrite16(hWaveOut,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3145 case WODM_OPEN:
3146 fprintf(stderr,"waveOutMessage16 can't handle WODM_OPEN, please report.\n");
3147 break;
3148 default:
3149 fprintf(stderr,"unhandled waveOutMessage16(0x%04x,0x%04x,%08lx,%08lx)\n",
3150 hWaveOut,uMessage,dwParam1,dwParam2
3151 );
3152 }
3153 return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3154 }
3155
3156 /**************************************************************************
3157 * waveInGetNumDevs [WINMM.151]
3158 */
3159 UINT32 WINAPI waveInGetNumDevs32()
3160 {
3161 return waveInGetNumDevs16();
3162 }
3163
3164 /**************************************************************************
3165 * waveInGetNumDevs [MMSYSTEM.501]
3166 */
3167 UINT16 WINAPI waveInGetNumDevs16()
3168 {
3169 UINT16 count = 0;
3170 TRACE(mmsys, "waveInGetNumDevs\n");
3171 count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
3172 TRACE(mmsys, "waveInGetNumDevs return %u \n", count);
3173 return count;
3174 }
3175
3176 /**************************************************************************
3177 * waveInGetDevCapsA [WINMM.147]
3178 */
3179 UINT32 WINAPI waveInGetDevCaps32W(UINT32 uDeviceID, LPWAVEINCAPS32W lpCaps, UINT32 uSize)
3180 {
3181 WAVEINCAPS16 wic16;
3182 UINT32 ret = waveInGetDevCaps16(uDeviceID,&wic16,uSize);
3183
3184 lpCaps->wMid = wic16.wMid;
3185 lpCaps->wPid = wic16.wPid;
3186 lpCaps->vDriverVersion = wic16.vDriverVersion;
3187 lstrcpyAtoW(lpCaps->szPname,wic16.szPname);
3188 lpCaps->dwFormats = wic16.dwFormats;
3189 lpCaps->wChannels = wic16.wChannels;
3190
3191 return ret;
3192 }
3193 /**************************************************************************
3194 * waveInGetDevCapsA [WINMM.146]
3195 */
3196 UINT32 WINAPI waveInGetDevCaps32A(UINT32 uDeviceID, LPWAVEINCAPS32A lpCaps, UINT32 uSize)
3197 {
3198 WAVEINCAPS16 wic16;
3199 UINT32 ret = waveInGetDevCaps16(uDeviceID,&wic16,uSize);
3200
3201 lpCaps->wMid = wic16.wMid;
3202 lpCaps->wPid = wic16.wPid;
3203 lpCaps->vDriverVersion = wic16.vDriverVersion;
3204 strcpy(lpCaps->szPname,wic16.szPname);
3205 lpCaps->dwFormats = wic16.dwFormats;
3206 lpCaps->wChannels = wic16.wChannels;
3207 return ret;
3208 }
3209 /**************************************************************************
3210 * waveInGetDevCaps [MMSYSTEM.502]
3211 */
3212 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize)
3213 {
3214 TRACE(mmsys, "waveInGetDevCaps\n");
3215 return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
3216 }
3217
3218 /**************************************************************************
3219 * waveInGetErrorTextA [WINMM.148]
3220 */
3221 UINT32 WINAPI waveInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
3222 {
3223 TRACE(mmsys, "waveInGetErrorText\n");
3224 return(waveGetErrorText(uError, lpText, uSize));
3225 }
3226
3227 /**************************************************************************
3228 * waveInGetErrorTextW [WINMM.149]
3229 */
3230 UINT32 WINAPI waveInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
3231 {
3232 LPSTR txt = HeapAlloc(GetProcessHeap(),0,uSize);
3233 UINT32 ret = waveGetErrorText(uError, txt, uSize);
3234
3235 lstrcpyAtoW(lpText,txt);
3236 HeapFree(GetProcessHeap(),0,txt);
3237 return ret;
3238 }
3239
3240 /**************************************************************************
3241 * waveInGetErrorText [MMSYSTEM.503]
3242 */
3243 UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
3244 {
3245 TRACE(mmsys, "waveInGetErrorText\n");
3246 return(waveGetErrorText(uError, lpText, uSize));
3247 }
3248
3249
3250 /**************************************************************************
3251 * waveInOpen [WINMM.154]
3252 */
3253 UINT32 WINAPI waveInOpen32(HWAVEIN32 * lphWaveIn, UINT32 uDeviceID,
3254 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
3255 DWORD dwInstance, DWORD dwFlags)
3256 {
3257 HWAVEIN16 hwin16;
3258 UINT32 ret=waveInOpen16(&hwin16,uDeviceID,lpFormat,dwCallback,dwInstance,dwFlags);
3259 if (lphWaveIn) *lphWaveIn = hwin16;
3260 return ret;
3261 }
3262
3263 /**************************************************************************
3264 * waveInOpen [MMSYSTEM.504]
3265 */
3266 UINT16 WINAPI waveInOpen16(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
3267 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
3268 DWORD dwInstance, DWORD dwFlags)
3269 {
3270 HWAVEIN16 hWaveIn;
3271 LPWAVEOPENDESC lpDesc;
3272 DWORD dwRet = 0;
3273 BOOL32 bMapperFlg = FALSE;
3274 TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3275 lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
3276 if (dwFlags & WAVE_FORMAT_QUERY)
3277 TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
3278 if (uDeviceID == (UINT16)WAVE_MAPPER) {
3279 TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
3280 bMapperFlg = TRUE;
3281 uDeviceID = 0;
3282 }
3283 if (lpFormat == NULL) return WAVERR_BADFORMAT;
3284 hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
3285 if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
3286 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3287 if (lpDesc == NULL) return MMSYSERR_NOMEM;
3288 lpDesc->hWave = hWaveIn;
3289 lpDesc->lpFormat = lpFormat;
3290 lpDesc->dwCallBack = dwCallback;
3291 lpDesc->dwInstance = dwInstance;
3292 while(uDeviceID < MAXWAVEDRIVERS) {
3293 dwRet = widMessage(uDeviceID, WIDM_OPEN,
3294 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
3295 if (dwRet == MMSYSERR_NOERROR) break;
3296 if (!bMapperFlg) break;
3297 uDeviceID++;
3298 TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
3299 }
3300 lpDesc->uDeviceID = uDeviceID;
3301 if (dwFlags & WAVE_FORMAT_QUERY) {
3302 TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
3303 dwRet = waveInClose16(hWaveIn);
3304 }
3305 return dwRet;
3306 }
3307
3308 /**************************************************************************
3309 * waveInClose [WINMM.145]
3310 */
3311 UINT32 WINAPI waveInClose32(HWAVEIN32 hWaveIn)
3312 {
3313 return waveInClose16(hWaveIn);
3314 }
3315 /**************************************************************************
3316 * waveInClose [MMSYSTEM.505]
3317 */
3318 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
3319 {
3320 LPWAVEOPENDESC lpDesc;
3321
3322 TRACE(mmsys, "(%04X)\n", hWaveIn);
3323 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3324 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3325 return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3326 }
3327
3328 /**************************************************************************
3329 * waveInPrepareHeader [WINMM.155]
3330 */
3331 UINT32 WINAPI waveInPrepareHeader32(HWAVEIN32 hWaveIn,
3332 WAVEHDR * lpWaveInHdr, UINT32 uSize)
3333 {
3334 LPWAVEOPENDESC lpDesc;
3335
3336 TRACE(mmsys, "(%04X, %p, %u);\n",
3337 hWaveIn, lpWaveInHdr, uSize);
3338 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3339 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3340 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3341 lpWaveInHdr = lpWaveInHdr;
3342 lpWaveInHdr->lpNext = NULL;
3343 lpWaveInHdr->dwBytesRecorded = 0;
3344 TRACE(mmsys, "lpData=%p size=%lu \n",
3345 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3346 return widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance,
3347 (DWORD)lpWaveInHdr, uSize);
3348 }
3349 /**************************************************************************
3350 * waveInPrepareHeader [MMSYSTEM.506]
3351 */
3352 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,
3353 WAVEHDR * lpWaveInHdr, UINT16 uSize)
3354 {
3355 LPWAVEOPENDESC lpDesc;
3356 LPBYTE saveddata = lpWaveInHdr->lpData;
3357 UINT16 ret;
3358
3359 TRACE(mmsys, "(%04X, %p, %u);\n",
3360 hWaveIn, lpWaveInHdr, uSize);
3361 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3362 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3363 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3364 lpWaveInHdr = lpWaveInHdr;
3365 lpWaveInHdr->lpNext = NULL;
3366 lpWaveInHdr->dwBytesRecorded = 0;
3367
3368 TRACE(mmsys, "lpData=%p size=%lu \n",
3369 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3370 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
3371 ret = widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance,
3372 (DWORD)lpWaveInHdr,uSize);
3373 lpWaveInHdr->lpData = saveddata;
3374 return ret;
3375 }
3376
3377
3378 /**************************************************************************
3379 * waveInUnprepareHeader [WINMM.159]
3380 */
3381 UINT32 WINAPI waveInUnprepareHeader32(HWAVEIN32 hWaveIn,
3382 WAVEHDR * lpWaveInHdr, UINT32 uSize)
3383 {
3384 LPWAVEOPENDESC lpDesc;
3385
3386 TRACE(mmsys, "(%04X, %p, %u);\n",
3387 hWaveIn, lpWaveInHdr, uSize);
3388 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3389 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3390 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3391 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
3392 lpWaveInHdr->lpData = NULL;
3393 lpWaveInHdr->lpNext = NULL;
3394 return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance,
3395 (DWORD)lpWaveInHdr, uSize);
3396 }
3397 /**************************************************************************
3398 * waveInUnprepareHeader [MMSYSTEM.507]
3399 */
3400 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,
3401 WAVEHDR * lpWaveInHdr, UINT16 uSize)
3402 {
3403 LPWAVEOPENDESC lpDesc;
3404
3405 TRACE(mmsys, "(%04X, %p, %u);\n",
3406 hWaveIn, lpWaveInHdr, uSize);
3407 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3408 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3409 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3410 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
3411 lpWaveInHdr->lpData = NULL;
3412 lpWaveInHdr->lpNext = NULL;
3413 return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance,
3414 (DWORD)lpWaveInHdr, uSize);
3415 }
3416
3417 /**************************************************************************
3418 * waveInAddBuffer [WINMM.144]
3419 */
3420 UINT32 WINAPI waveInAddBuffer32(HWAVEIN32 hWaveIn,
3421 WAVEHDR * lpWaveInHdr, UINT32 uSize)
3422 {
3423 LPWAVEOPENDESC lpDesc;
3424
3425 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
3426 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3427 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3428 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3429 lpWaveInHdr->lpNext = NULL;
3430 lpWaveInHdr->dwBytesRecorded = 0;
3431 TRACE(mmsys, "lpData=%p size=%lu \n",
3432 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3433 return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
3434 (DWORD)lpWaveInHdr, uSize);
3435
3436 }
3437
3438 /**************************************************************************
3439 * waveInAddBuffer [MMSYSTEM.508]
3440 */
3441 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,
3442 WAVEHDR * lpWaveInHdr, UINT16 uSize)
3443 {
3444 LPWAVEOPENDESC lpDesc;
3445 UINT16 ret;
3446
3447 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
3448 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3449 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3450 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3451 lpWaveInHdr->lpNext = NULL;
3452 lpWaveInHdr->dwBytesRecorded = 0;
3453 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
3454 TRACE(mmsys, "lpData=%p size=%lu \n",
3455 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3456 ret = widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
3457 (DWORD)lpWaveInHdr, uSize);
3458 /*lpWaveInHdr->lpData = saveddata;*/
3459 return ret;
3460 }
3461
3462 /**************************************************************************
3463 * waveInStart [WINMM.157]
3464 */
3465 UINT32 WINAPI waveInStart32(HWAVEIN32 hWaveIn)
3466 {
3467 return waveInStart16(hWaveIn);
3468 }
3469
3470 /**************************************************************************
3471 * waveInStart [MMSYSTEM.509]
3472 */
3473 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn)
3474 {
3475 LPWAVEOPENDESC lpDesc;
3476
3477 TRACE(mmsys, "(%04X)\n", hWaveIn);
3478 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3479 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3480 return widMessage(lpDesc->uDeviceID,WIDM_START,lpDesc->dwInstance,0,0);
3481 }
3482
3483 /**************************************************************************
3484 * waveInStop [WINMM.158]
3485 */
3486 UINT32 WINAPI waveInStop32(HWAVEIN32 hWaveIn)
3487 {
3488 return waveInStop16(hWaveIn);
3489 }
3490
3491 /**************************************************************************
3492 * waveInStop [MMSYSTEM.510]
3493 */
3494 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn)
3495 {
3496 LPWAVEOPENDESC lpDesc;
3497
3498 TRACE(mmsys, "(%04X)\n", hWaveIn);
3499 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3500 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3501 return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
3502 }
3503
3504 /**************************************************************************
3505 * waveInReset [WINMM.156]
3506 */
3507 UINT32 WINAPI waveInReset32(HWAVEIN32 hWaveIn)
3508 {
3509 return waveInReset16(hWaveIn);
3510 }
3511
3512 /**************************************************************************
3513 * waveInReset [MMSYSTEM.511]
3514 */
3515 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn)
3516 {
3517 LPWAVEOPENDESC lpDesc;
3518
3519 TRACE(mmsys, "(%04X)\n", hWaveIn);
3520 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3521 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3522 return widMessage(lpDesc->uDeviceID,WIDM_RESET,lpDesc->dwInstance,0,0);
3523 }
3524
3525 /**************************************************************************
3526 * waveInGetPosition [WINMM.152]
3527 */
3528 UINT32 WINAPI waveInGetPosition32(HWAVEIN32 hWaveIn, LPMMTIME32 lpTime,
3529 UINT32 uSize)
3530 {
3531 MMTIME16 mmt16;
3532 UINT32 ret = waveInGetPosition16(hWaveIn,&mmt16,uSize);
3533
3534 MMSYSTEM_MMTIME16to32(lpTime,&mmt16);
3535 return ret;
3536 }
3537
3538 /**************************************************************************
3539 * waveInGetPosition [MMSYSTEM.512]
3540 */
3541 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn,LPMMTIME16 lpTime,
3542 UINT16 uSize)
3543 {
3544 LPWAVEOPENDESC lpDesc;
3545
3546 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
3547 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3548 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3549 return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance,
3550 (DWORD)lpTime, (DWORD)uSize);
3551 }
3552
3553 /**************************************************************************
3554 * waveInGetID [WINMM.150]
3555 */
3556 UINT32 WINAPI waveInGetID32(HWAVEIN32 hWaveIn, UINT32 * lpuDeviceID)
3557 {
3558 LPWAVEOPENDESC lpDesc;
3559
3560 TRACE(mmsys, "waveInGetID\n");
3561 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3562 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3563 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3564 *lpuDeviceID = lpDesc->uDeviceID;
3565 return 0;
3566 }
3567
3568
3569 /**************************************************************************
3570 * waveInGetID [MMSYSTEM.513]
3571 */
3572 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID)
3573 {
3574 LPWAVEOPENDESC lpDesc;
3575
3576 TRACE(mmsys, "waveInGetID\n");
3577 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3578 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3579 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3580 *lpuDeviceID = lpDesc->uDeviceID;
3581 return 0;
3582 }
3583
3584 /**************************************************************************
3585 * waveInMessage [WINMM.153]
3586 */
3587 DWORD WINAPI waveInMessage32(HWAVEIN32 hWaveIn, UINT32 uMessage,
3588 DWORD dwParam1, DWORD dwParam2)
3589 {
3590 LPWAVEOPENDESC lpDesc;
3591
3592 fprintf(stderr, "waveInMessage32(%04X, %04X, %08lX, %08lX),FIXME!\n",
3593 hWaveIn, uMessage, dwParam1, dwParam2);
3594 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3595 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3596 switch (uMessage) {
3597 case WIDM_OPEN:
3598 fprintf(stderr,"waveInMessage32: cannot handle WIDM_OPEN, please report.\n");
3599 break;
3600 case WIDM_GETNUMDEVS:
3601 case WIDM_GETPOS:
3602 case WIDM_CLOSE:
3603 case WIDM_STOP :
3604 case WIDM_RESET:
3605 case WIDM_START:
3606 case WIDM_PREPARE:
3607 case WIDM_UNPREPARE:
3608 case WIDM_ADDBUFFER:
3609 case WIDM_PAUSE:
3610 /* no argument conversion needed */
3611 break;
3612 case WIDM_GETDEVCAPS:
3613 /*FIXME: ANSI/UNICODE */
3614 return waveInGetDevCaps32A(hWaveIn,(LPWAVEINCAPS32A)dwParam1,dwParam2);
3615 default:
3616 fprintf(stderr,"unhandled waveInMessage32(%04x,%04x,%08lx,%08lx)\n",hWaveIn,uMessage,dwParam1,dwParam2);
3617 break;
3618 }
3619 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3620 }
3621
3622 /**************************************************************************
3623 * waveInMessage [MMSYSTEM.514]
3624 */
3625 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
3626 DWORD dwParam1, DWORD dwParam2)
3627 {
3628 LPWAVEOPENDESC lpDesc;
3629
3630 fprintf(stderr, "waveInMessage(%04X, %04X, %08lX, %08lX),FIXME!\n",
3631 hWaveIn, uMessage, dwParam1, dwParam2);
3632 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3633 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3634 switch (uMessage) {
3635 case WIDM_OPEN:
3636 fprintf(stderr,"waveInMessage16: cannot handle WIDM_OPEN, please report.\n");
3637 break;
3638 case WIDM_GETNUMDEVS:
3639 case WIDM_CLOSE:
3640 case WIDM_STOP :
3641 case WIDM_RESET:
3642 case WIDM_START:
3643 case WIDM_PAUSE:
3644 /* no argument conversion needed */
3645 break;
3646 case WIDM_GETDEVCAPS:
3647 return waveInGetDevCaps16(hWaveIn,(LPWAVEINCAPS16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3648 case WIDM_GETPOS:
3649 return waveInGetPosition16(hWaveIn,(LPMMTIME16)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3650 case WIDM_PREPARE:
3651 return waveInPrepareHeader16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3652 case WIDM_UNPREPARE:
3653 return waveInUnprepareHeader16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3654 case WIDM_ADDBUFFER:
3655 return waveInAddBuffer16(hWaveIn,(LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1),dwParam2);
3656 default:
3657 fprintf(stderr,"unhandled waveInMessage16(%04x,%04x,%08lx,%08lx)\n",hWaveIn,uMessage,dwParam1,dwParam2);
3658 break;
3659 }
3660 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3661 }
3662
3663 /**************************************************************************
3664 * DrvOpen [MMSYSTEM.1100]
3665 */
3666 HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
3667 {
3668 TRACE(mmsys, "('%s', '%s', %08lX);\n",
3669 lpDriverName, lpSectionName, lParam);
3670 return OpenDriver(lpDriverName, lpSectionName, lParam);
3671 }
3672
3673
3674 /**************************************************************************
3675 * DrvClose [MMSYSTEM.1101]
3676 */
3677 LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
3678 {
3679 TRACE(mmsys, "(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
3680 return CloseDriver(hDrvr, lParam1, lParam2);
3681 }
3682
3683
3684 /**************************************************************************
3685 * DrvSendMessage [MMSYSTEM.1102]
3686 */
3687 LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1,
3688 LPARAM lParam2)
3689 {
3690 DWORD dwDriverID = 0;
3691 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX);\n",
3692 hDriver, msg, lParam1, lParam2);
3693 return CDAUDIO_DriverProc(dwDriverID, hDriver, msg, lParam1, lParam2);
3694 }
3695
3696 /**************************************************************************
3697 * DrvGetModuleHandle [MMSYSTEM.1103]
3698 */
3699 HANDLE16 WINAPI DrvGetModuleHandle(HDRVR16 hDrvr)
3700 {
3701 TRACE(mmsys, "(%04X);\n", hDrvr);
3702 return 0;
3703 }
3704
3705
3706 /**************************************************************************
3707 * DrvDefDriverProc [MMSYSTEM.1104]
3708 */
3709 LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg,
3710 DWORD dwParam1, DWORD dwParam2)
3711 {
3712 return DefDriverProc(dwDriverID, hDriv, wMsg, dwParam1, dwParam2);
3713 }
3714
3715 /**************************************************************************
3716 * mmThreadCreate [MMSYSTEM.1120]
3717 */
3718 LRESULT WINAPI mmThreadCreate16(LPVOID x1, LPWORD x2, DWORD x3, DWORD x4) {
3719 fprintf(stderr,"mmThreadCreate16(%p,%p,%08lx,%08lx),stub!\n",
3720 x1,x2,x3,x4
3721 );
3722 *x2 = 0xbabe;
3723 return 0;
3724 }
3725
3726 /**************************************************************************
3727 * mmThreadGetTask [MMSYSTEM.1125]
3728 */
3729 LRESULT WINAPI mmThreadGetTask16(WORD hnd) {
3730 fprintf(stderr,"mmThreadGetTask16(%04x),stub!\n",hnd);
3731 return GetCurrentTask();
3732 }
3733
3734 /**************************************************************************
3735 * mmThreadSignal [MMSYSTEM.1121]
3736 */
3737 LRESULT WINAPI mmThreadSignal16(WORD hnd) {
3738 fprintf(stderr,"mmThreadSignal16(%04x), stub!\n",hnd);
3739 return 0;
3740 }
3741
3742 /**************************************************************************
3743 * mmTaskCreate [MMSYSTEM.900]
3744 */
3745 LRESULT WINAPI mmTaskCreate16(LPWORD lphnd,DWORD x1,DWORD x2) {
3746 fprintf(stderr,"mmTaskCreate16(%p,%08lx,%08lx),stub!\n",lphnd,x1,x2);
3747 *lphnd = 0xcafe;
3748 return 0;
3749 }
3750
3751 /**************************************************************************
3752 * mmTaskSignal [MMSYSTEM.903]
3753 */
3754 LRESULT WINAPI mmTaskSignal16(HTASK16 ht) {
3755 fprintf(stderr,"mmTaskSignal(%04x),stub!\n",ht);
3756 return PostAppMessage16(ht,0x400,0,0);
3757 }
3758
3759 /**************************************************************************
3760 * mciDriverYield [MMSYSTEM.710]
3761 */
3762 LRESULT WINAPI mciDriverYield16(HANDLE16 hnd) {
3763 fprintf(stderr,"mciDriverYield16(%04x),stub!\n",hnd);
3764 return 0;
3765 }
3766
DirectPlay implementation for GSoC