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