?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated (prepare|unprepare)header functions to allow correct callback
[wine/testsucceed.git] / multimedia / mmsystem.c
blob64660d78ae0cce5410be267c87bb51116a69af5f
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MMSYTEM functions
5 *
6 * Copyright 1993 Martin Ayotte
7 */
8
9 /*
10 * Eric POUECH :
11 * 98/9 added support for Win32 MCI
12 */
13
14 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
15 * and long term pointers to 16 bit space in here
16 */
17
18 #include <stdlib.h>
19 #include <string.h>
20 #include <fcntl.h>
21 #include <errno.h>
22 #include <sys/ioctl.h>
23
24 #include "winbase.h"
25 #include "windef.h"
26 #include "wine/winbase16.h"
27 #include "heap.h"
28 #include "user.h"
29 #include "driver.h"
30 #include "multimedia.h"
31 #include "callback.h"
32 #include "module.h"
33 #include "selectors.h"
34 #include "debugstr.h"
35 #include "debug.h"
36
37 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
38 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
39 LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
40 DWORD dwParam1, DWORD dwParam2);
41
42 /**************************************************************************
43 * MMSYSTEM_WEP [MMSYSTEM.1]
44 */
45 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
46 WORD cbHeapSize, LPSTR lpCmdLine)
47 {
48 FIXME(mmsys, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance);
49 return(TRUE);
50 }
51
52 static void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, LPMMTIME mmt32)
53 {
54 mmt16->wType = mmt32->wType;
55 /* layout of rest is the same for 32/16 */
56 memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u));
57 }
58
59 static void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, LPMMTIME16 mmt16)
60 {
61 mmt32->wType = mmt16->wType;
62 /* layout of rest is the same for 32/16,
63 * Note: mmt16->u is 2 bytes smaller than mmt32->u
64 */
65 memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u));
66 }
67
68 static HANDLE PlaySound_hThread = 0;
69 static HANDLE PlaySound_hPlayEvent = 0;
70 static HANDLE PlaySound_hReadyEvent = 0;
71 static HANDLE PlaySound_hMiddleEvent = 0;
72 static BOOL PlaySound_Result = FALSE;
73 static int PlaySound_Stop = FALSE;
74 static int PlaySound_Playing = FALSE;
75
76 static LPCSTR PlaySound_pszSound = NULL;
77 static HMODULE PlaySound_hmod = 0;
78 static DWORD PlaySound_fdwSound = 0;
79 static int PlaySound_Loop = FALSE;
80 static int PlaySound_SearchMode = 0; /* 1 - sndPlaySound search order
81 2 - PlaySound order */
82
83 static HMMIO16 get_mmioFromFile(LPCSTR lpszName)
84 {
85 return mmioOpen16((LPSTR)lpszName, NULL,
86 MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
87 }
88
89 static HMMIO16 get_mmioFromProfile(UINT uFlags, LPCSTR lpszName)
90 {
91 char str[128];
92 LPSTR ptr;
93 HMMIO16 hmmio;
94
95 TRACE(mmsys, "searching in SystemSound List !\n");
96 GetProfileStringA("Sounds", (LPSTR)lpszName, "", str, sizeof(str));
97 if (strlen(str) == 0) {
98 if (uFlags & SND_NODEFAULT) return 0;
99 GetProfileStringA("Sounds", "Default", "", str, sizeof(str));
100 if (strlen(str) == 0) return 0;
101 }
102 if ((ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0';
103 hmmio = get_mmioFromFile(str);
104 if (hmmio == 0) {
105 WARN(mmsys, "can't find SystemSound='%s' !\n", str);
106 return 0;
107 }
108 return hmmio;
109 }
110
111 static BOOL16 WINAPI proc_PlaySound(LPCSTR lpszSoundName, UINT uFlags)
112 {
113 BOOL16 bRet = FALSE;
114 HMMIO16 hmmio;
115 MMCKINFO ckMainRIFF;
116
117 TRACE(mmsys, "SoundName='%s' uFlags=%04X !\n", lpszSoundName, uFlags);
118 if (lpszSoundName == NULL) {
119 TRACE(mmsys, "Stop !\n");
120 return FALSE;
121 }
122 if (uFlags & SND_MEMORY) {
123 MMIOINFO16 mminfo;
124 memset(&mminfo, 0, sizeof(mminfo));
125 mminfo.fccIOProc = FOURCC_MEM;
126 mminfo.pchBuffer = (LPSTR)lpszSoundName;
127 mminfo.cchBuffer = -1;
128 TRACE(mmsys, "Memory sound %p\n", lpszSoundName);
129 hmmio = mmioOpen16(NULL, &mminfo, MMIO_READ);
130 } else {
131 hmmio = 0;
132 if (uFlags & SND_ALIAS)
133 if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0)
134 return FALSE;
135
136 if (uFlags & SND_FILENAME)
137 if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0) return FALSE;
138
139 if (PlaySound_SearchMode == 1) {
140 PlaySound_SearchMode = 0;
141 if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0)
142 if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0)
143 return FALSE;
144 }
145
146 if (PlaySound_SearchMode == 2) {
147 PlaySound_SearchMode = 0;
148 if ((hmmio=get_mmioFromProfile(uFlags | SND_NODEFAULT, lpszSoundName)) == 0)
149 if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0)
150 if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0) return FALSE;
151 }
152 }
153
154 if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0)
155 do {
156 TRACE(mmsys, "ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
157 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
158 ckMainRIFF.cksize);
159
160 if ((ckMainRIFF.ckid == FOURCC_RIFF) &&
161 (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E'))) {
162 MMCKINFO mmckInfo;
163
164 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
165
166 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
167 PCMWAVEFORMAT pcmWaveFormat;
168
169 TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
170 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
171
172 if (mmioRead(hmmio, (HPSTR)&pcmWaveFormat,
173 (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT)) {
174 TRACE(mmsys, "wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag);
175 TRACE(mmsys, "nChannels=%d \n", pcmWaveFormat.wf.nChannels);
176 TRACE(mmsys, "nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec);
177 TRACE(mmsys, "nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec);
178 TRACE(mmsys, "nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign);
179 TRACE(mmsys, "wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample);
180
181 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
182 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
183 WAVEOPENDESC waveDesc;
184 DWORD dwRet;
185
186 TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
187 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
188
189 pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec *
190 pcmWaveFormat.wf.nBlockAlign;
191 waveDesc.hWave = 0;
192 waveDesc.lpFormat = (LPWAVEFORMAT)&pcmWaveFormat;
193
194 dwRet = wodMessage(0, WODM_OPEN, 0, (DWORD)&waveDesc, CALLBACK_NULL);
195 if (dwRet == MMSYSERR_NOERROR) {
196 WAVEHDR waveHdr;
197 HGLOBAL16 hData;
198 INT count, bufsize, left = mmckInfo.cksize;
199
200 bufsize = 64000;
201 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
202 waveHdr.lpData = (LPSTR)GlobalLock16(hData);
203 waveHdr.dwBufferLength = bufsize;
204 waveHdr.dwUser = 0L;
205 waveHdr.dwFlags = 0L;
206 waveHdr.dwLoops = 0L;
207
208 dwRet = wodMessage(0, WODM_PREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
209 if (dwRet == MMSYSERR_NOERROR) {
210 while (left) {
211 if (PlaySound_Stop) {
212 PlaySound_Stop = FALSE;
213 PlaySound_Loop = FALSE;
214 break;
215 }
216 if (bufsize > left) bufsize = left;
217 count = mmioRead(hmmio, waveHdr.lpData,bufsize);
218 if (count < 1) break;
219 left -= count;
220 waveHdr.dwBufferLength = count;
221 /* waveHdr.dwBytesRecorded = count; */
222 /* FIXME: doesn't expect async ops */
223 wodMessage(0, WODM_WRITE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
224 }
225 wodMessage(0, WODM_UNPREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
226 wodMessage(0, WODM_CLOSE, 0, 0L, 0L);
227
228 bRet = TRUE;
229 } else
230 WARN(mmsys, "can't prepare WaveOut device !\n");
231
232 GlobalUnlock16(hData);
233 GlobalFree16(hData);
234 }
235 }
236 }
237 }
238 }
239 } while (PlaySound_Loop);
240
241 if (hmmio != 0) mmioClose(hmmio, 0);
242 return bRet;
243 }
244
245 static DWORD WINAPI PlaySound_Thread(LPVOID arg)
246 {
247 DWORD res;
248
249 for (;;) {
250 PlaySound_Playing = FALSE;
251 SetEvent(PlaySound_hReadyEvent);
252 res = WaitForSingleObject(PlaySound_hPlayEvent, INFINITE);
253 ResetEvent(PlaySound_hReadyEvent);
254 SetEvent(PlaySound_hMiddleEvent);
255 if (res == WAIT_FAILED) ExitThread(2);
256 if (res != WAIT_OBJECT_0) continue;
257 PlaySound_Playing = TRUE;
258
259 if ((PlaySound_fdwSound & SND_RESOURCE) == SND_RESOURCE) {
260 HRSRC hRES;
261 HGLOBAL hGLOB;
262 void* ptr;
263
264 if ((hRES = FindResourceA(PlaySound_hmod, PlaySound_pszSound, "WAVE")) == 0) {
265 PlaySound_Result = FALSE;
266 continue;
267 }
268 if ((hGLOB = LoadResource(PlaySound_hmod, hRES)) == 0) {
269 PlaySound_Result = FALSE;
270 continue;
271 }
272 if ((ptr = LockResource(hGLOB)) == NULL) {
273 FreeResource(hGLOB);
274 PlaySound_Result = FALSE;
275 continue;
276 }
277 PlaySound_Result = proc_PlaySound(ptr,
278 ((UINT16)PlaySound_fdwSound ^ SND_RESOURCE) | SND_MEMORY);
279 FreeResource(hGLOB);
280 continue;
281 }
282 PlaySound_Result=proc_PlaySound(PlaySound_pszSound, (UINT16)PlaySound_fdwSound);
283 }
284 }
285
286 /**************************************************************************
287 * PlaySoundA [WINMM.1]
288 */
289 BOOL WINAPI PlaySoundA(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound)
290 {
291 static LPSTR StrDup = NULL;
292
293 TRACE(mmsys, "pszSound='%p' hmod=%04X fdwSound=%08lX\n",
294 pszSound, hmod, fdwSound);
295
296 if (PlaySound_hThread == 0) { /* This is the first time they called us */
297 DWORD id;
298 if ((PlaySound_hReadyEvent = CreateEventA(NULL, TRUE, FALSE, NULL)) == 0)
299 return FALSE;
300 if ((PlaySound_hMiddleEvent = CreateEventA(NULL, FALSE, FALSE, NULL)) == 0)
301 return FALSE;
302 if ((PlaySound_hPlayEvent = CreateEventA(NULL, FALSE, FALSE, NULL)) == 0)
303 return FALSE;
304 if ((PlaySound_hThread = CreateThread(NULL, 0, PlaySound_Thread, 0, 0, &id)) == 0)
305 return FALSE;
306 }
307
308 /* FIXME? I see no difference between SND_WAIT and SND_NOSTOP ! */
309 if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && PlaySound_Playing)
310 return FALSE;
311
312 /* Trying to stop if playing */
313 if (PlaySound_Playing) PlaySound_Stop = TRUE;
314
315 /* Waiting playing thread to get ready. I think 10 secs is ok & if not then leave*/
316 if (WaitForSingleObject(PlaySound_hReadyEvent, 1000*10) != WAIT_OBJECT_0)
317 return FALSE;
318
319 if (!pszSound || (fdwSound & SND_PURGE))
320 return FALSE; /* We stoped playing so leaving */
321
322 if (PlaySound_SearchMode != 1) PlaySound_SearchMode = 2;
323 if (!(fdwSound & SND_ASYNC)) {
324 if (fdwSound & SND_LOOP)
325 return FALSE;
326 PlaySound_pszSound = pszSound;
327 PlaySound_hmod = hmod;
328 PlaySound_fdwSound = fdwSound;
329 PlaySound_Result = FALSE;
330 SetEvent(PlaySound_hPlayEvent);
331 if (WaitForSingleObject(PlaySound_hMiddleEvent, INFINITE) != WAIT_OBJECT_0)
332 return FALSE;
333 if (WaitForSingleObject(PlaySound_hReadyEvent, INFINITE) != WAIT_OBJECT_0)
334 return FALSE;
335 return PlaySound_Result;
336 } else {
337 PlaySound_hmod = hmod;
338 PlaySound_fdwSound = fdwSound;
339 PlaySound_Result = FALSE;
340 if (StrDup) {
341 HeapFree(GetProcessHeap(), 0, StrDup);
342 StrDup = NULL;
343 }
344 if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) &&
345 !((DWORD)pszSound >> 16)) || !pszSound)) {
346 StrDup = HEAP_strdupA(GetProcessHeap(), 0,pszSound);
347 PlaySound_pszSound = StrDup;
348 } else PlaySound_pszSound = pszSound;
349 PlaySound_Loop = fdwSound & SND_LOOP;
350 SetEvent(PlaySound_hPlayEvent);
351 ResetEvent(PlaySound_hMiddleEvent);
352 return TRUE;
353 }
354 return FALSE;
355 }
356
357 /**************************************************************************
358 * PlaySoundW [WINMM.18]
359 */
360 BOOL WINAPI PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
361 {
362 LPSTR pszSoundA;
363 BOOL bSound;
364
365 if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) &&
366 !((DWORD)pszSound >> 16)) || !pszSound)) {
367 pszSoundA = HEAP_strdupWtoA(GetProcessHeap(), 0,pszSound);
368 bSound = PlaySoundA(pszSoundA, hmod, fdwSound);
369 HeapFree(GetProcessHeap(), 0,pszSoundA);
370 } else
371 bSound = PlaySoundA((LPCSTR)pszSound, hmod, fdwSound);
372
373 return bSound;
374 }
375
376 /**************************************************************************
377 * sndPlaySoundA [MMSYSTEM.2][WINMM135]
378 */
379 BOOL16 WINAPI sndPlaySoundA(LPCSTR lpszSoundName, UINT16 uFlags)
380 {
381 PlaySound_SearchMode = 1;
382 return PlaySoundA(lpszSoundName, 0, uFlags);
383 }
384
385 /**************************************************************************
386 * sndPlaySoundW [WINMM.136]
387 */
388 BOOL16 WINAPI sndPlaySoundW(LPCWSTR lpszSoundName, UINT16 uFlags)
389 {
390 PlaySound_SearchMode = 1;
391 return PlaySoundW(lpszSoundName, 0, uFlags);
392 }
393
394 /**************************************************************************
395 * mmsystemGetVersion [WINMM.134]
396 */
397 UINT WINAPI mmsystemGetVersion()
398 {
399 return mmsystemGetVersion16();
400 }
401
402 /**************************************************************************
403 * mmsystemGetVersion [MMSYSTEM.5]
404 * return value borrowed from Win95 winmm.dll ;)
405 */
406 UINT16 WINAPI mmsystemGetVersion16()
407 {
408 TRACE(mmsys, "3.10 (Win95?)\n");
409 return 0x030a;
410 }
411
412 /**************************************************************************
413 * DriverProc [MMSYSTEM.6]
414 */
415 LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
416 DWORD dwParam1, DWORD dwParam2)
417 {
418 return DrvDefDriverProc(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
419 }
420
421 /**************************************************************************
422 * DriverCallback [MMSYSTEM.31]
423 */
424 BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
425 WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
426 {
427 TRACE(mmsys, "(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
428 dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
429
430 switch (uFlags & DCB_TYPEMASK) {
431 case DCB_NULL:
432 TRACE(mmsys, "CALLBACK_NULL !\n");
433 break;
434 case DCB_WINDOW:
435 TRACE(mmsys, "CALLBACK_WINDOW = %04lX handle = %04X!\n",
436 dwCallBack, hDev);
437 if (!IsWindow(dwCallBack) || USER_HEAP_LIN_ADDR(hDev) == NULL)
438 return FALSE;
439
440 PostMessageA((HWND16)dwCallBack, wMsg, hDev, dwParam1);
441 break;
442 case DCB_TASK:
443 TRACE(mmsys, "CALLBACK_TASK !\n");
444 return FALSE;
445 case DCB_FUNCTION:
446 TRACE(mmsys, "CALLBACK_FUNCTION !\n");
447 Callbacks->CallDriverCallback((FARPROC16)dwCallBack,
448 hDev, wMsg, dwUser,
449 dwParam1, dwParam2 );
450 break;
451 case DCB_FUNC32:
452 TRACE(mmsys, "CALLBACK_FUNCTION !\n");
453 ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser,
454 dwParam1, dwParam2 );
455 break;
456 default:
457 WARN(mmsys, "Unknown callback type\n");
458 break;
459 }
460 return TRUE;
461 }
462
463 /**************************************************************************
464 * Mixer devices. New to Win95
465 */
466
467 /**************************************************************************
468 * find out the real mixer ID depending on hmix (depends on dwFlags)
469 * FIXME: also fix dwInstance passing to mixMessage
470 */
471 static UINT MIXER_GetDevID(HMIXEROBJ hmix, DWORD dwFlags)
472 {
473 /* FIXME: Check dwFlags for MIXER_OBJSECTF_xxxx entries and modify hmix
474 * accordingly. For now we always use mixerdevice 0.
475 */
476 return 0;
477 }
478
479 /**************************************************************************
480 * mixerGetNumDevs [WINMM.108]
481 */
482 UINT WINAPI mixerGetNumDevs(void)
483 {
484 UINT16 count = mixMessage(0, MXDM_GETNUMDEVS, 0L, 0L, 0L);
485
486 TRACE(mmaux,"mixerGetNumDevs returns %d\n",count);
487 return count;
488 }
489
490 /**************************************************************************
491 * mixerGetNumDevs [MMSYSTEM.800]
492 */
493 UINT16 WINAPI mixerGetNumDevs16()
494 {
495 return mixerGetNumDevs();
496 }
497
498 /**************************************************************************
499 * mixerGetDevCapsA [WINMM.101]
500 */
501 UINT WINAPI mixerGetDevCapsA(UINT devid, LPMIXERCAPSA mixcaps, UINT size)
502 {
503 return mixMessage(devid, MXDM_GETDEVCAPS, 0L, (DWORD)mixcaps, (DWORD)size);
504 }
505
506 /**************************************************************************
507 * mixerGetDevCapsW [WINMM.102]
508 */
509 UINT WINAPI mixerGetDevCapsW(UINT devid, LPMIXERCAPSW mixcaps, UINT size)
510 {
511 MIXERCAPSA micA;
512 UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
513
514 if (ret == MMSYSERR_NOERROR) {
515 mixcaps->wMid = micA.wMid;
516 mixcaps->wPid = micA.wPid;
517 mixcaps->vDriverVersion = micA.vDriverVersion;
518 lstrcpyAtoW(mixcaps->szPname, micA.szPname);
519 mixcaps->fdwSupport = micA.fdwSupport;
520 mixcaps->cDestinations = micA.cDestinations;
521 }
522 return ret;
523 }
524
525 /**************************************************************************
526 * mixerGetDevCaps [MMSYSTEM.801]
527 */
528 UINT16 WINAPI mixerGetDevCaps16(UINT16 devid, LPMIXERCAPS16 mixcaps, UINT16 size)
529 {
530 MIXERCAPSA micA;
531 UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
532
533 if (ret == MMSYSERR_NOERROR) {
534 mixcaps->wMid = micA.wMid;
535 mixcaps->wPid = micA.wPid;
536 mixcaps->vDriverVersion = micA.vDriverVersion;
537 strcpy(PTR_SEG_TO_LIN(mixcaps->szPname), micA.szPname);
538 mixcaps->fdwSupport = micA.fdwSupport;
539 mixcaps->cDestinations = micA.cDestinations;
540 }
541 return ret;
542 }
543
544 /**************************************************************************
545 * mixerOpen [WINMM.110]
546 */
547 UINT WINAPI mixerOpen(LPHMIXER lphmix, UINT uDeviceID, DWORD dwCallback,
548 DWORD dwInstance, DWORD fdwOpen)
549 {
550 HMIXER16 hmix16;
551 UINT ret;
552
553 FIXME(mmsys,"(%p,%d,%08lx,%08lx,%08lx): semi stub?\n",
554 lphmix,uDeviceID, dwCallback, dwInstance, fdwOpen);
555 ret = mixerOpen16(&hmix16,uDeviceID, dwCallback, dwInstance,fdwOpen);
556 if (lphmix) *lphmix = hmix16;
557 return ret;
558 }
559
560 /**************************************************************************
561 * mixerOpen [MMSYSTEM.803]
562 */
563 UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback,
564 DWORD dwInstance, DWORD fdwOpen)
565 {
566 HMIXER16 hmix;
567 LPMIXEROPENDESC lpmod;
568 BOOL mapperflag = (uDeviceID==0);
569 DWORD dwRet=0;
570
571 TRACE(mmsys,"(%p,%d,%08lx,%08lx,%08lx)\n",
572 lphmix,uDeviceID, dwCallback, dwInstance, fdwOpen);
573 hmix = USER_HEAP_ALLOC(sizeof(MIXEROPENDESC));
574 if (lphmix) *lphmix = hmix;
575 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
576 lpmod->hmx = hmix;
577 lpmod->dwCallback = dwCallback;
578 lpmod->dwInstance = dwInstance;
579 if (uDeviceID >= MAXMIXERDRIVERS)
580 uDeviceID = 0;
581 while (uDeviceID < MAXMIXERDRIVERS) {
582 dwRet = mixMessage(uDeviceID, MXDM_OPEN, dwInstance, (DWORD)lpmod, fdwOpen);
583 if (dwRet == MMSYSERR_NOERROR) break;
584 if (!mapperflag) break;
585 uDeviceID++;
586 }
587 lpmod->uDeviceID = uDeviceID;
588
589 if (dwRet != MMSYSERR_NOERROR) {
590 USER_HEAP_FREE(hmix);
591 if (lphmix) *lphmix = 0;
592 }
593
594 return dwRet;
595 }
596
597 /**************************************************************************
598 * mixerClose [WINMM.98]
599 */
600 UINT WINAPI mixerClose(HMIXER hmix)
601 {
602 LPMIXEROPENDESC lpmod;
603 DWORD dwRet;
604
605 FIXME(mmsys,"(%04x): semi-stub?\n", hmix);
606
607 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
608 if (lpmod == NULL) return MMSYSERR_INVALHANDLE;
609 dwRet = mixMessage(lpmod->uDeviceID, MXDM_CLOSE, lpmod->dwInstance, 0L, 0L);
610 USER_HEAP_FREE(hmix);
611 return dwRet;
612 }
613
614 /**************************************************************************
615 * mixerClose [MMSYSTEM.803]
616 */
617 UINT16 WINAPI mixerClose16(HMIXER16 hmix)
618 {
619 return mixerClose(hmix);
620 }
621
622 /**************************************************************************
623 * mixerGetID [WINMM.103]
624 */
625 UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
626 {
627 FIXME(mmsys,"(%04x %p %08lx): semi-stub\n", hmix, lpid, fdwID);
628
629 if (lpid)
630 *lpid = MIXER_GetDevID(hmix, fdwID);
631
632 return MMSYSERR_NOERROR; /* FIXME: many error possibilities */
633 }
634
635 /**************************************************************************
636 * mixerGetID
637 */
638 UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID)
639 {
640 UINT xid;
641 UINT ret = mixerGetID(hmix, &xid, fdwID);
642
643 if (lpid)
644 *lpid = xid;
645 return ret;
646 }
647
648 /**************************************************************************
649 * mixerGetControlDetailsA [WINMM.99]
650 */
651 UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
652 {
653 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
654 return MMSYSERR_NOTENABLED;
655 }
656
657 /**************************************************************************
658 * mixerGetControlDetailsW [WINMM.100]
659 */
660 UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
661 {
662 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
663 return MMSYSERR_NOTENABLED;
664 }
665
666 /**************************************************************************
667 * mixerGetControlDetails [MMSYSTEM.808]
668 */
669 UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails)
670 {
671 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
672 return MMSYSERR_NOTENABLED;
673 }
674
675 /**************************************************************************
676 * mixerGetLineControlsA [WINMM.104]
677 */
678 UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlc, DWORD fdwControls)
679 {
680 UINT uDevID;
681
682 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmlc, fdwControls);
683
684 uDevID = MIXER_GetDevID(hmix, 0);
685
686 return mixMessage(uDevID, MXDM_GETLINECONTROLS, 0, (DWORD)lpmlc, fdwControls);
687 }
688
689 /**************************************************************************
690 * mixerGetLineControlsW [WINMM.105]
691 */
692 UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlc, DWORD fdwControls)
693 {
694 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmlc, fdwControls);
695 return MMSYSERR_NOTENABLED;
696 }
697
698 /**************************************************************************
699 * mixerGetLineControls [MMSYSTEM.807]
700 */
701 UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix, LPMIXERLINECONTROLS16 lpmlc, DWORD fdwControls)
702 {
703 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmlc, fdwControls);
704 return MMSYSERR_NOTENABLED;
705 }
706
707 /**************************************************************************
708 * mixerGetLineInfoA [WINMM.106]
709 */
710 UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpml, DWORD fdwInfo)
711 {
712 UINT16 devid;
713
714 TRACE(mmsys, "(%04x, %p, %08lx)\n", hmix, lpml, fdwInfo);
715
716 /* FIXME: I'm not sure of the flags */
717 devid = MIXER_GetDevID(hmix, fdwInfo);
718 return mixMessage(devid, MXDM_GETLINEINFO, 0, (DWORD)lpml, fdwInfo);
719 }
720
721 /**************************************************************************
722 * mixerGetLineInfoW [WINMM.107]
723 */
724 UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpml, DWORD fdwInfo)
725 {
726 MIXERLINEA mlA;
727 UINT ret;
728
729 TRACE(mmsys,"(%04x,%p,%08lx)\n", hmix, lpml, fdwInfo);
730
731 if (lpml == NULL || lpml->cbStruct != sizeof(*lpml))
732 return MMSYSERR_INVALPARAM;
733
734 mlA.cbStruct = sizeof(mlA);
735 mlA.dwDestination = lpml->dwDestination;
736 mlA.dwSource = lpml->dwSource;
737 mlA.dwLineID = lpml->dwLineID;
738 mlA.dwUser = lpml->dwUser;
739 mlA.dwComponentType = lpml->dwComponentType;
740 mlA.cChannels = lpml->cChannels;
741 mlA.cConnections = lpml->cConnections;
742 mlA.cControls = lpml->cControls;
743
744 ret = mixerGetLineInfoA(hmix, &mlA, fdwInfo);
745
746 lpml->dwDestination = mlA.dwDestination;
747 lpml->dwSource = mlA.dwSource;
748 lpml->dwLineID = mlA.dwLineID;
749 lpml->fdwLine = mlA.fdwLine;
750 lpml->dwUser = mlA.dwUser;
751 lpml->dwComponentType = mlA.dwComponentType;
752 lpml->cChannels = mlA.cChannels;
753 lpml->cConnections = mlA.cConnections;
754 lpml->cControls = mlA.cControls;
755 lstrcpyAtoW(lpml->szShortName, mlA.szShortName);
756 lstrcpyAtoW(lpml->szName, mlA.szName);
757 lpml->Target.dwType = mlA.Target.dwType;
758 lpml->Target.dwDeviceID = mlA.Target.dwDeviceID;
759 lpml->Target.wMid = mlA.Target.wMid;
760 lpml->Target.wPid = mlA.Target.wPid;
761 lpml->Target.vDriverVersion = mlA.Target.vDriverVersion;
762 lstrcpyAtoW(lpml->Target.szPname, mlA.Target.szPname);
763
764 return ret;
765 }
766
767 /**************************************************************************
768 * mixerGetLineInfo [MMSYSTEM.805]
769 */
770 UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpml, DWORD fdwInfo)
771 {
772 MIXERLINEA mlA;
773 UINT ret;
774
775 TRACE(mmsys, "(%04x,%p,%08lx)\n", hmix, lpml, fdwInfo);
776
777 if (lpml == NULL || lpml->cbStruct != sizeof(*lpml))
778 return MMSYSERR_INVALPARAM;
779
780 mlA.cbStruct = sizeof(mlA);
781 mlA.dwDestination = lpml->dwDestination;
782 mlA.dwSource = lpml->dwSource;
783 mlA.dwLineID = lpml->dwLineID;
784 mlA.dwUser = lpml->dwUser;
785 mlA.dwComponentType = lpml->dwComponentType;
786 mlA.cChannels = lpml->cChannels;
787 mlA.cConnections = lpml->cConnections;
788 mlA.cControls = lpml->cControls;
789
790 ret = mixerGetLineInfoA(hmix, &mlA, fdwInfo);
791
792 lpml->dwDestination = mlA.dwDestination;
793 lpml->dwSource = mlA.dwSource;
794 lpml->dwLineID = mlA.dwLineID;
795 lpml->fdwLine = mlA.fdwLine;
796 lpml->dwUser = mlA.dwUser;
797 lpml->dwComponentType = mlA.dwComponentType;
798 lpml->cChannels = mlA.cChannels;
799 lpml->cConnections = mlA.cConnections;
800 lpml->cControls = mlA.cControls;
801 strcpy(PTR_SEG_TO_LIN(lpml->szShortName), mlA.szShortName);
802 strcpy(PTR_SEG_TO_LIN(lpml->szName), mlA.szName);
803 lpml->Target.dwType = mlA.Target.dwType;
804 lpml->Target.dwDeviceID = mlA.Target.dwDeviceID;
805 lpml->Target.wMid = mlA.Target.wMid;
806 lpml->Target.wPid = mlA.Target.wPid;
807 lpml->Target.vDriverVersion = mlA.Target.vDriverVersion;
808 strcpy(PTR_SEG_TO_LIN(lpml->Target.szPname), mlA.Target.szPname);
809 return ret;
810 }
811
812 /**************************************************************************
813 * mixerSetControlDetails [WINMM.111]
814 */
815 UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
816 {
817 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
818 return MMSYSERR_NOTENABLED;
819 }
820
821 /**************************************************************************
822 * mixerSetControlDetails [MMSYSTEM.809]
823 */
824 UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails)
825 {
826 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
827 return MMSYSERR_NOTENABLED;
828 }
829
830 /**************************************************************************
831 * mixerMessage [WINMM.109]
832 */
833 UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
834 {
835 LPMIXEROPENDESC lpmod;
836 UINT16 uDeviceID;
837
838 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
839 if (lpmod)
840 uDeviceID = lpmod->uDeviceID;
841 else
842 uDeviceID = 0;
843 FIXME(mmsys,"(%04lx,%d,%08lx,%08lx): semi-stub?\n",
844 (DWORD)hmix,uMsg, dwParam1, dwParam2);
845 return mixMessage(uDeviceID,uMsg, 0L, dwParam1, dwParam2);
846 }
847
848 /**************************************************************************
849 * mixerMessage [MMSYSTEM.804]
850 */
851 UINT16 WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1, DWORD dwParam2)
852 {
853 LPMIXEROPENDESC lpmod;
854 UINT16 uDeviceID;
855
856 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
857 uDeviceID = (lpmod) ? lpmod->uDeviceID : 0;
858 FIXME(mmsys,"(%04x,%d,%08lx,%08lx) - semi-stub?\n",
859 hmix,uMsg, dwParam1, dwParam2);
860 return mixMessage(uDeviceID,uMsg, 0L, dwParam1, dwParam2);
861 }
862
863 /**************************************************************************
864 * auxGetNumDevs [WINMM.22]
865 */
866 UINT WINAPI auxGetNumDevs()
867 {
868 return auxGetNumDevs16();
869 }
870
871 /**************************************************************************
872 * auxGetNumDevs [MMSYSTEM.350]
873 */
874 UINT16 WINAPI auxGetNumDevs16()
875 {
876 UINT16 count;
877
878 TRACE(mmsys, "\n");
879 count = auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
880 TRACE(mmsys, "=> %u\n", count);
881 return count;
882 }
883
884 /**************************************************************************
885 * auxGetDevCaps [WINMM.20]
886 */
887 UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
888 {
889 AUXCAPS16 ac16;
890 UINT ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16));
891
892 lpCaps->wMid = ac16.wMid;
893 lpCaps->wPid = ac16.wPid;
894 lpCaps->vDriverVersion = ac16.vDriverVersion;
895 lstrcpyAtoW(lpCaps->szPname,ac16.szPname);
896 lpCaps->wTechnology = ac16.wTechnology;
897 lpCaps->dwSupport = ac16.dwSupport;
898 return ret;
899 }
900
901 /**************************************************************************
902 * auxGetDevCaps [WINMM.21]
903 */
904 UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
905 {
906 AUXCAPS16 ac16;
907 UINT ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16));
908
909 lpCaps->wMid = ac16.wMid;
910 lpCaps->wPid = ac16.wPid;
911 lpCaps->vDriverVersion = ac16.vDriverVersion;
912 strcpy(lpCaps->szPname,ac16.szPname);
913 lpCaps->wTechnology = ac16.wTechnology;
914 lpCaps->dwSupport = ac16.dwSupport;
915 return ret;
916 }
917
918 /**************************************************************************
919 * auxGetDevCaps [MMSYSTEM.351]
920 */
921 UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize)
922 {
923 TRACE(mmsys, "(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize);
924
925 return auxMessage(uDeviceID, AUXDM_GETDEVCAPS,
926 0L, (DWORD)lpCaps, (DWORD)uSize);
927 }
928
929 /**************************************************************************
930 * auxGetVolume [WINM.23]
931 */
932 UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
933 {
934 return auxGetVolume16(uDeviceID, lpdwVolume);
935 }
936
937 /**************************************************************************
938 * auxGetVolume [MMSYSTEM.352]
939 */
940 UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
941 {
942 TRACE(mmsys, "(%04X, %p) !\n", uDeviceID, lpdwVolume);
943
944 return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
945 }
946
947 /**************************************************************************
948 * auxSetVolume [WINMM.25]
949 */
950 UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
951 {
952 return auxSetVolume16(uDeviceID, dwVolume);
953 }
954
955 /**************************************************************************
956 * auxSetVolume [MMSYSTEM.353]
957 */
958 UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
959 {
960 TRACE(mmsys, "(%04X, %08lX) !\n", uDeviceID, dwVolume);
961
962 return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L);
963 }
964
965 /**************************************************************************
966 * auxOutMessage [MMSYSTEM.354]
967 */
968 DWORD WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD dw1, DWORD dw2)
969 {
970 switch (uMessage) {
971 case AUXDM_GETNUMDEVS:
972 case AUXDM_GETVOLUME:
973 case AUXDM_SETVOLUME:
974 /* no argument conversion needed */
975 break;
976 case AUXDM_GETDEVCAPS:
977 return auxGetDevCapsA(uDeviceID, (LPAUXCAPSA)dw1, dw2);
978 default:
979 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
980 uDeviceID,uMessage, dw1, dw2);
981 break;
982 }
983 return auxMessage(uDeviceID,uMessage, 0L, dw1, dw2);
984 }
985
986 /**************************************************************************
987 * auxOutMessage [MMSYSTEM.354]
988 */
989 DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
990 {
991 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", uDeviceID, uMessage, dw1, dw2);
992
993 switch (uMessage) {
994 case AUXDM_GETNUMDEVS:
995 case AUXDM_SETVOLUME:
996 /* no argument conversion needed */
997 break;
998 case AUXDM_GETVOLUME:
999 return auxGetVolume16(uDeviceID, (LPDWORD)PTR_SEG_TO_LIN(dw1));
1000 case AUXDM_GETDEVCAPS:
1001 return auxGetDevCaps16(uDeviceID, (LPAUXCAPS16)PTR_SEG_TO_LIN(dw1), dw2);
1002 default:
1003 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
1004 uDeviceID,uMessage, dw1, dw2);
1005 break;
1006 }
1007 return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2);
1008 }
1009
1010 /**************************************************************************
1011 * mciGetErrorStringW [WINMM.46]
1012 */
1013 BOOL WINAPI mciGetErrorStringW(DWORD wError, LPWSTR lpstrBuffer, UINT uLength)
1014 {
1015 LPSTR bufstr = HeapAlloc(GetProcessHeap(), 0,uLength);
1016 BOOL ret = mciGetErrorStringA(wError, bufstr, uLength);
1017
1018 lstrcpyAtoW(lpstrBuffer, bufstr);
1019 HeapFree(GetProcessHeap(), 0, bufstr);
1020 return ret;
1021 }
1022
1023 /**************************************************************************
1024 * mciGetErrorStringA [WINMM.45]
1025 */
1026 BOOL WINAPI mciGetErrorStringA(DWORD wError, LPSTR lpstrBuffer, UINT uLength)
1027 {
1028 return mciGetErrorString16(wError, lpstrBuffer,uLength);
1029 }
1030
1031 /**************************************************************************
1032 * mciGetErrorString [MMSYSTEM.706]
1033 */
1034 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
1035 {
1036 LPSTR msgptr;
1037 BOOL16 ret = TRUE;
1038
1039 TRACE(mmsys, "(%08lX, %p, %d);\n", wError, lpstrBuffer, uLength);
1040
1041 if ((lpstrBuffer == NULL) || (uLength < 1))
1042 return FALSE;
1043
1044 lpstrBuffer[0] = '\0';
1045
1046 switch (wError) {
1047 case 0:
1048 msgptr = "The specified command has been executed.";
1049 break;
1050 case MCIERR_INVALID_DEVICE_ID:
1051 msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device.";
1052 break;
1053 case MCIERR_UNRECOGNIZED_KEYWORD:
1054 msgptr = "The driver cannot recognize the specified command parameter.";
1055 break;
1056 case MCIERR_UNRECOGNIZED_COMMAND:
1057 msgptr = "The driver cannot recognize the specified command.";
1058 break;
1059 case MCIERR_HARDWARE:
1060 msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer.";
1061 break;
1062 case MCIERR_INVALID_DEVICE_NAME:
1063 msgptr = "The specified device is not open or is not recognized by MCI.";
1064 break;
1065 case MCIERR_OUT_OF_MEMORY:
1066 msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again.";
1067 break;
1068 case MCIERR_DEVICE_OPEN:
1069 msgptr = "The device name is already being used as an alias by this application. Use a unique alias.";
1070 break;
1071 case MCIERR_CANNOT_LOAD_DRIVER:
1072 msgptr = "There is an undetectable problem in loading the specified device driver.";
1073 break;
1074 case MCIERR_MISSING_COMMAND_STRING:
1075 msgptr = "No command was specified.";
1076 break;
1077 case MCIERR_PARAM_OVERFLOW:
1078 msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer.";
1079 break;
1080 case MCIERR_MISSING_STRING_ARGUMENT:
1081 msgptr = "The specified command requires a character-string parameter. Please provide one.";
1082 break;
1083 case MCIERR_BAD_INTEGER:
1084 msgptr = "The specified integer is invalid for this command.";
1085 break;
1086 case MCIERR_PARSER_INTERNAL:
1087 msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver.";
1088 break;
1089 case MCIERR_DRIVER_INTERNAL:
1090 msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver.";
1091 break;
1092 case MCIERR_MISSING_PARAMETER:
1093 msgptr = "The specified command requires a parameter. Please supply one.";
1094 break;
1095 case MCIERR_UNSUPPORTED_FUNCTION:
1096 msgptr = "The MCI device you are using does not support the specified command.";
1097 break;
1098 case MCIERR_FILE_NOT_FOUND:
1099 msgptr = "Cannot find the specified file. Make sure the path and filename are correct.";
1100 break;
1101 case MCIERR_DEVICE_NOT_READY:
1102 msgptr = "The device driver is not ready.";
1103 break;
1104 case MCIERR_INTERNAL:
1105 msgptr = "A problem occurred in initializing MCI. Try restarting Windows.";
1106 break;
1107 case MCIERR_DRIVER:
1108 msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error.";
1109 break;
1110 case MCIERR_CANNOT_USE_ALL:
1111 msgptr = "Cannot use 'all' as the device name with the specified command.";
1112 break;
1113 case MCIERR_MULTIPLE:
1114 msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error";
1115 break;
1116 case MCIERR_EXTENSION_NOT_FOUND:
1117 msgptr = "Cannot determine the device type from the given filename extension.";
1118 break;
1119 case MCIERR_OUTOFRANGE:
1120 msgptr = "The specified parameter is out of range for the specified command.";
1121 break;
1122 case MCIERR_FLAGS_NOT_COMPATIBLE:
1123 msgptr = "The specified parameters cannot be used together.";
1124 break;
1125 case MCIERR_FILE_NOT_SAVED:
1126 msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network.";
1127 break;
1128 case MCIERR_DEVICE_TYPE_REQUIRED:
1129 msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly.";
1130 break;
1131 case MCIERR_DEVICE_LOCKED:
1132 msgptr = "The specified device is now being closed. Wait a few seconds, and then try again.";
1133 break;
1134 case MCIERR_DUPLICATE_ALIAS:
1135 msgptr = "The specified alias is already being used in this application. Use a unique alias.";
1136 break;
1137 case MCIERR_BAD_CONSTANT:
1138 msgptr = "The specified parameter is invalid for this command.";
1139 break;
1140 case MCIERR_MUST_USE_SHAREABLE:
1141 msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command.";
1142 break;
1143 case MCIERR_MISSING_DEVICE_NAME:
1144 msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one.";
1145 break;
1146 case MCIERR_BAD_TIME_FORMAT:
1147 msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats.";
1148 break;
1149 case MCIERR_NO_CLOSING_QUOTE:
1150 msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one.";
1151 break;
1152 case MCIERR_DUPLICATE_FLAGS:
1153 msgptr = "A parameter or value was specified twice. Only specify it once.";
1154 break;
1155 case MCIERR_INVALID_FILE:
1156 msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format.";
1157 break;
1158 case MCIERR_NULL_PARAMETER_BLOCK:
1159 msgptr = "A null parameter block was passed to MCI.";
1160 break;
1161 case MCIERR_UNNAMED_RESOURCE:
1162 msgptr = "Cannot save an unnamed file. Supply a filename.";
1163 break;
1164 case MCIERR_NEW_REQUIRES_ALIAS:
1165 msgptr = "You must specify an alias when using the 'new' parameter.";
1166 break;
1167 case MCIERR_NOTIFY_ON_AUTO_OPEN:
1168 msgptr = "Cannot use the 'notify' flag with auto-opened devices.";
1169 break;
1170 case MCIERR_NO_ELEMENT_ALLOWED:
1171 msgptr = "Cannot use a filename with the specified device.";
1172 break;
1173 case MCIERR_NONAPPLICABLE_FUNCTION:
1174 msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again.";
1175 break;
1176 case MCIERR_ILLEGAL_FOR_AUTO_OPEN:
1177 msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again.";
1178 break;
1179 case MCIERR_FILENAME_REQUIRED:
1180 msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension.";
1181 break;
1182 case MCIERR_EXTRA_CHARACTERS:
1183 msgptr = "Cannot specify extra characters after a string enclosed in quotation marks.";
1184 break;
1185 case MCIERR_DEVICE_NOT_INSTALLED:
1186 msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device.";
1187 break;
1188 case MCIERR_GET_CD:
1189 msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer.";
1190 break;
1191 case MCIERR_SET_CD:
1192 msgptr = "Cannot access the specified file or MCI device because the application cannot change directories.";
1193 break;
1194 case MCIERR_SET_DRIVE:
1195 msgptr = "Cannot access specified file or MCI device because the application cannot change drives.";
1196 break;
1197 case MCIERR_DEVICE_LENGTH:
1198 msgptr = "Specify a device or driver name that is less than 79 characters.";
1199 break;
1200 case MCIERR_DEVICE_ORD_LENGTH:
1201 msgptr = "Specify a device or driver name that is less than 69 characters.";
1202 break;
1203 case MCIERR_NO_INTEGER:
1204 msgptr = "The specified command requires an integer parameter. Please provide one.";
1205 break;
1206 case MCIERR_WAVE_OUTPUTSINUSE:
1207 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.";
1208 break;
1209 case MCIERR_WAVE_SETOUTPUTINUSE:
1210 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.";
1211 break;
1212 case MCIERR_WAVE_INPUTSINUSE:
1213 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.";
1214 break;
1215 case MCIERR_WAVE_SETINPUTINUSE:
1216 msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again.";
1217 break;
1218 case MCIERR_WAVE_OUTPUTUNSPECIFIED:
1219 msgptr = "Any compatible waveform playback device may be used.";
1220 break;
1221 case MCIERR_WAVE_INPUTUNSPECIFIED:
1222 msgptr = "Any compatible waveform recording device may be used.";
1223 break;
1224 case MCIERR_WAVE_OUTPUTSUNSUITABLE:
1225 msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device.";
1226 break;
1227 case MCIERR_WAVE_SETOUTPUTUNSUITABLE:
1228 msgptr = "The device you are trying to play to cannot recognize the current file format.";
1229 break;
1230 case MCIERR_WAVE_INPUTSUNSUITABLE:
1231 msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device.";
1232 break;
1233 case MCIERR_WAVE_SETINPUTUNSUITABLE:
1234 msgptr = "The device you are trying to record from cannot recognize the current file format.";
1235 break;
1236 case MCIERR_NO_WINDOW:
1237 msgptr = "There is no display window.";
1238 break;
1239 case MCIERR_CREATEWINDOW:
1240 msgptr = "Could not create or use window.";
1241 break;
1242 case MCIERR_FILE_READ:
1243 msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection.";
1244 break;
1245 case MCIERR_FILE_WRITE:
1246 msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network.";
1247 break;
1248 case MCIERR_SEQ_DIV_INCOMPATIBLE:
1249 msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together.";
1250 break;
1251 case MCIERR_SEQ_NOMIDIPRESENT:
1252 msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver.";
1253 break;
1254 case MCIERR_SEQ_PORT_INUSE:
1255 msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again.";
1256 break;
1257 case MCIERR_SEQ_PORT_MAPNODEVICE:
1258 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.";
1259 break;
1260 case MCIERR_SEQ_PORT_MISCERROR:
1261 msgptr = "An error occurred with the specified port.";
1262 break;
1263 case MCIERR_SEQ_PORT_NONEXISTENT:
1264 msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device.";
1265 break;
1266 case MCIERR_SEQ_PORTUNSPECIFIED:
1267 msgptr = "The system doesnot have a current MIDI port specified.";
1268 break;
1269 case MCIERR_SEQ_TIMER:
1270 msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again.";
1271 break;
1272
1273 /*
1274 msg# 513 : vcr
1275 msg# 514 : videodisc
1276 msg# 515 : overlay
1277 msg# 516 : cdaudio
1278 msg# 517 : dat
1279 msg# 518 : scanner
1280 msg# 519 : animation
1281 msg# 520 : digitalvideo
1282 msg# 521 : other
1283 msg# 522 : waveaudio
1284 msg# 523 : sequencer
1285 msg# 524 : not ready
1286 msg# 525 : stopped
1287 msg# 526 : playing
1288 msg# 527 : recording
1289 msg# 528 : seeking
1290 msg# 529 : paused
1291 msg# 530 : open
1292 msg# 531 : false
1293 msg# 532 : true
1294 msg# 533 : milliseconds
1295 msg# 534 : hms
1296 msg# 535 : msf
1297 msg# 536 : frames
1298 msg# 537 : smpte 24
1299 msg# 538 : smpte 25
1300 msg# 539 : smpte 30
1301 msg# 540 : smpte 30 drop
1302 msg# 541 : bytes
1303 msg# 542 : samples
1304 msg# 543 : tmsf
1305 */
1306 default:
1307 msgptr = "Unknown MCI Error !\n";
1308 ret = FALSE;
1309 break;
1310 }
1311 lstrcpynA(lpstrBuffer, msgptr, uLength);
1312 TRACE(mmsys, "msg = %s;\n", msgptr);
1313 return ret;
1314 }
1315
1316 /**************************************************************************
1317 * mciDriverNotify [MMSYSTEM.711]
1318 */
1319 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
1320 {
1321 TRACE(mmsys, "(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
1322
1323 if (!IsWindow(hWndCallBack)) {
1324 WARN(mmsys, "bad hWnd for call back\n");
1325 return FALSE;
1326 }
1327 TRACE(mmsys, "before PostMessage\n");
1328 PostMessageA(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
1329 return TRUE;
1330 }
1331
1332 /**************************************************************************
1333 * mciDriverNotify [WINMM.36]
1334 */
1335 BOOL WINAPI mciDriverNotify(HWND hWndCallBack, UINT wDevID, UINT wStatus)
1336 {
1337 FIXME(mmsys, "(%08X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
1338
1339 if (!IsWindow(hWndCallBack)) {
1340 WARN(mmsys, "bad hWnd for call back\n");
1341 return FALSE;
1342 }
1343 TRACE(mmsys, "before PostMessage\n");
1344 PostMessageA(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
1345 return TRUE;
1346 }
1347
1348 /**************************************************************************
1349 * mciGetDriverData [MMSYSTEM.708]
1350 */
1351 DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
1352 {
1353 return mciGetDriverData(uDeviceID);
1354 }
1355
1356 /**************************************************************************
1357 * mciGetDriverData [WINMM.44]
1358 */
1359 DWORD WINAPI mciGetDriverData(UINT uDeviceID)
1360 {
1361 TRACE(mmsys,"(%04x)\n", uDeviceID);
1362 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0) {
1363 WARN(mmsys, "Bad uDeviceID\n");
1364 return 0L;
1365 }
1366
1367 return MCI_GetDrv(uDeviceID)->dwPrivate;
1368 }
1369
1370 /**************************************************************************
1371 * mciSetDriverData [MMSYSTEM.707]
1372 */
1373 BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
1374 {
1375 return mciSetDriverData(uDeviceID, data);
1376 }
1377
1378 /**************************************************************************
1379 * mciSetDriverData [WINMM.53]
1380 */
1381 BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD data)
1382 {
1383 TRACE(mmsys, "(%04x,%08lx)\n", uDeviceID, data);
1384 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0) {
1385 WARN(mmsys, "Bad uDeviceID\n");
1386 return FALSE;
1387 }
1388
1389 MCI_GetDrv(uDeviceID)->dwPrivate = data;
1390 return TRUE;
1391 }
1392
1393 /**************************************************************************
1394 * mciLoadCommandResource [MMSYSTEM.705]
1395 */
1396 UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hinst, LPCSTR resname, UINT16 type)
1397 {
1398 char buf[200];
1399 OFSTRUCT ofs;
1400 HANDLE16 xhinst;
1401 HRSRC16 hrsrc;
1402 HGLOBAL16 hmem;
1403 LPSTR segstr;
1404 SEGPTR xmem;
1405 LPBYTE lmem;
1406 static UINT16 mcidevtype = 0;
1407
1408 FIXME(mmsys,"(%04x,%s,%d): stub!\n", hinst, resname, type);
1409 if (!lstrcmpiA(resname, "core")) {
1410 FIXME(mmsys, "(...,\"core\",...), have to use internal tables... (not there yet)\n");
1411 return 0;
1412 }
1413 return ++mcidevtype;
1414 /* if file exists "resname.mci", then load resource "resname" from it
1415 * otherwise directly from driver
1416 */
1417 strcpy(buf,resname);
1418 strcat(buf,".mci");
1419 if (OpenFile(buf, &ofs,OF_EXIST) != HFILE_ERROR) {
1420 xhinst = LoadLibrary16(buf);
1421 if (xhinst > 32)
1422 hinst = xhinst;
1423 } /* else use passed hinst */
1424 segstr = SEGPTR_STRDUP(resname);
1425 hrsrc = FindResource16(hinst, SEGPTR_GET(segstr), type);
1426 SEGPTR_FREE(segstr);
1427 if (!hrsrc) {
1428 WARN(mmsys, "no special commandlist found in resource\n");
1429 return MCI_NO_COMMAND_TABLE;
1430 }
1431 hmem = LoadResource16(hinst, hrsrc);
1432 if (!hmem) {
1433 WARN(mmsys, "couldn't load resource??\n");
1434 return MCI_NO_COMMAND_TABLE;
1435 }
1436 xmem = WIN16_LockResource16(hmem);
1437 if (!xmem) {
1438 WARN(mmsys, "couldn't lock resource??\n");
1439 FreeResource16(hmem);
1440 return MCI_NO_COMMAND_TABLE;
1441 }
1442 lmem = PTR_SEG_TO_LIN(xmem);
1443 TRACE(mmsys, "first resource entry is %s\n", (char*)lmem);
1444 /* parse resource, register stuff, return unique id */
1445 return ++mcidevtype;
1446 }
1447
1448 /**************************************************************************
1449 * mciFreeCommandResource [MMSYSTEM.713]
1450 */
1451 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
1452 {
1453 FIXME(mci, "(%04x) stub\n", uTable);
1454 return 0;
1455 }
1456
1457 /**************************************************************************
1458 * mciFreeCommandResource [WINMM.39]
1459 */
1460 BOOL WINAPI mciFreeCommandResource(UINT uTable)
1461 {
1462 FIXME(mci, "(%08x) stub\n", uTable);
1463 return 0;
1464 }
1465
1466 /**************************************************************************
1467 * mciLoadCommandResource [WINMM.48]
1468 */
1469 UINT WINAPI mciLoadCommandResource(HANDLE hinst, LPCWSTR resname, UINT type)
1470 {
1471 FIXME(mci, "(%04x,%s,%d): stub!\n", hinst, debugstr_w(resname), type);
1472 return 0;
1473 }
1474
1475 /**************************************************************************
1476 * mciSendCommandA [WINMM.49]
1477 */
1478 DWORD WINAPI mciSendCommandA(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
1479 {
1480 DWORD dwRet;
1481
1482 TRACE(mci, "(%08x,%s,%08lx,%08lx)\n", wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
1483
1484 switch (wMsg) {
1485 case MCI_OPEN:
1486 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
1487 break;
1488 case MCI_CLOSE:
1489 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
1490 break;
1491 case MCI_SYSINFO:
1492 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
1493 break;
1494 default:
1495 if (wDevID == MCI_ALL_DEVICE_ID) {
1496 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
1497 dwRet = MCIERR_CANNOT_USE_ALL;
1498 } else {
1499 dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
1500 }
1501 break;
1502 }
1503 dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2, TRUE);
1504 TRACE(mci, "=> %08lx\n", dwRet);
1505 return dwRet;
1506 }
1507
1508 /**************************************************************************
1509 * mciSendCommandW [WINMM.50]
1510 */
1511 DWORD WINAPI mciSendCommandW(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
1512 {
1513 return 0x1; /* !ok */
1514 }
1515
1516 /**************************************************************************
1517 * mciSendCommand [MMSYSTEM.701]
1518 */
1519 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1520 {
1521 DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND;
1522
1523 TRACE(mmsys, "(%04X, %s, %08lX, %08lX)\n",
1524 wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
1525
1526 switch (wMsg) {
1527 case MCI_OPEN:
1528 if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) {
1529 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
1530 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
1531 }
1532 break;
1533 case MCI_CLOSE:
1534 if (wDevID == MCI_ALL_DEVICE_ID) {
1535 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
1536 dwRet = MCIERR_CANNOT_USE_ALL;
1537 } else if (!MCI_DevIDValid(wDevID)) {
1538 dwRet = MCIERR_INVALID_DEVICE_ID;
1539 } else if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) {
1540 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
1541 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
1542 }
1543 break;
1544 case MCI_SYSINFO:
1545 if (MCI_MapMsg16To32A(0, wDevID, &dwParam2) >= 0) {
1546 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
1547 MCI_UnMapMsg16To32A(0, wDevID, dwParam2);
1548 }
1549 break;
1550 /* FIXME: it seems that MCI_BREAK and MCI_SOUND need the same handling */
1551 default:
1552 if (wDevID == MCI_ALL_DEVICE_ID) {
1553 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
1554 dwRet = MCIERR_CANNOT_USE_ALL;
1555 } else if (!MCI_DevIDValid(wDevID)) {
1556 dwRet = MCIERR_INVALID_DEVICE_ID;
1557 } else {
1558 int res;
1559
1560 switch (DRIVER_GetType(MCI_GetDrv(wDevID)->hDrv)) {
1561 case WINE_DI_TYPE_16:
1562 dwRet = SendDriverMessage16(MCI_GetDrv(wDevID)->hDrv, wMsg, dwParam1, dwParam2);
1563 break;
1564 case WINE_DI_TYPE_32:
1565 switch (res = MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2)) {
1566 case -1:
1567 TRACE(mci, "Not handled yet (%s)\n", MCI_CommandToString(wMsg));
1568 dwRet = MCIERR_DRIVER_INTERNAL;
1569 break;
1570 case -2:
1571 TRACE(mci, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg));
1572 dwRet = MCIERR_OUT_OF_MEMORY;
1573 break;
1574 case 0:
1575 case 1:
1576 dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
1577 if (res)
1578 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
1579 break;
1580 }
1581 break;
1582 default:
1583 WARN(mmsys, "Unknown driver type=%u\n", DRIVER_GetType(MCI_GetDrv(wDevID)->hDrv));
1584 dwRet = MCIERR_DRIVER_INTERNAL;
1585 }
1586 }
1587 }
1588 dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2, FALSE);
1589 TRACE(mmsys, "=> %ld\n", dwRet);
1590 return dwRet;
1591 }
1592
1593 /**************************************************************************
1594 * mciGetDeviceID [MMSYSTEM.703]
1595 */
1596 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
1597 {
1598 UINT16 wDevID;
1599 TRACE(mmsys, "(\"%s\")\n", lpstrName);
1600
1601 if (!lpstrName)
1602 return 0;
1603
1604 if (!lstrcmpiA(lpstrName, "ALL"))
1605 return MCI_ALL_DEVICE_ID;
1606
1607 for (wDevID = MCI_FirstDevID(); MCI_DevIDValid(wDevID); wDevID = MCI_NextDevID(wDevID)) {
1608 if (MCI_GetDrv(wDevID)->modp.wType) {
1609 FIXME(mmsys, "This is wrong for compound devices\n");
1610 /* FIXME: for compound devices, lpstrName is matched against
1611 * the name of the file, not the name of the device...
1612 */
1613 if (MCI_GetOpenDrv(wDevID)->lpstrDeviceType &&
1614 strcmp(MCI_GetOpenDrv(wDevID)->lpstrDeviceType, lpstrName) == 0)
1615 return wDevID;
1616
1617 if (MCI_GetOpenDrv(wDevID)->lpstrAlias &&
1618 strcmp(MCI_GetOpenDrv(wDevID)->lpstrAlias, lpstrName) == 0)
1619 return wDevID;
1620 }
1621 }
1622
1623 return 0;
1624 }
1625
1626 /**************************************************************************
1627 * mciGetDeviceIDA [WINMM.41]
1628 */
1629 UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName)
1630 {
1631 return mciGetDeviceID16(lpstrName);
1632 }
1633
1634 /**************************************************************************
1635 * mciGetDeviceIDW [WINMM.43]
1636 */
1637 UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
1638 {
1639 LPSTR lpstrName;
1640 UINT ret;
1641
1642 lpstrName = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrName);
1643 ret = mciGetDeviceID16(lpstrName);
1644 HeapFree(GetProcessHeap(), 0, lpstrName);
1645 return ret;
1646 }
1647
1648 /**************************************************************************
1649 * mciSetYieldProc [MMSYSTEM.714]
1650 */
1651 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
1652 {
1653 TRACE(mmsys, "(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
1654 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0) {
1655 WARN(mmsys, "Bad uDeviceID\n");
1656 return FALSE;
1657 }
1658
1659 MCI_GetDrv(uDeviceID)->lpfnYieldProc = fpYieldProc;
1660 MCI_GetDrv(uDeviceID)->dwYieldData = dwYieldData;
1661 MCI_GetDrv(uDeviceID)->bIs32 = FALSE;
1662
1663 return TRUE;
1664 }
1665
1666 /**************************************************************************
1667 * mciSetYieldProc [WINMM.54]
1668 */
1669 BOOL WINAPI mciSetYieldProc(UINT uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
1670 {
1671 TRACE(mmsys, "(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
1672 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0) {
1673 WARN(mmsys, "Bad uDeviceID\n");
1674 return FALSE;
1675 }
1676
1677 MCI_GetDrv(uDeviceID)->lpfnYieldProc = fpYieldProc;
1678 MCI_GetDrv(uDeviceID)->dwYieldData = dwYieldData;
1679 MCI_GetDrv(uDeviceID)->bIs32 = TRUE;
1680
1681 return TRUE;
1682 }
1683
1684 /**************************************************************************
1685 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
1686 */
1687 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
1688 {
1689 FIXME(mci, "(%lu, %s) stub\n", dwElementID, lpstrType);
1690 return 0;
1691 }
1692
1693 /**************************************************************************
1694 * mciGetDeviceIDFromElementIDW [WINMM.42]
1695 */
1696 UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
1697 {
1698 /* FIXME: that's rather strange, there is no
1699 * mciGetDeviceIDFromElementID32A in winmm.spec
1700 */
1701 FIXME(mci, "(%lu, %p) stub\n", dwElementID, lpstrType);
1702 return 0;
1703 }
1704
1705 /**************************************************************************
1706 * mciGetYieldProc [MMSYSTEM.716]
1707 */
1708 YIELDPROC WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
1709 {
1710 TRACE(mmsys, "(%u, %p)\n", uDeviceID, lpdwYieldData);
1711 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0) {
1712 WARN(mmsys, "Bad uDeviceID\n");
1713 return NULL;
1714 }
1715 if (!MCI_GetDrv(uDeviceID)->lpfnYieldProc) {
1716 WARN(mmsys, "No proc set\n");
1717 return NULL;
1718 }
1719 if (MCI_GetDrv(uDeviceID)->bIs32) {
1720 WARN(mmsys, "Proc is 32 bit\n");
1721 return NULL;
1722 }
1723 return MCI_GetDrv(uDeviceID)->lpfnYieldProc;
1724 }
1725
1726 /**************************************************************************
1727 * mciGetYieldProc [WINMM.47]
1728 */
1729 YIELDPROC WINAPI mciGetYieldProc(UINT uDeviceID, DWORD* lpdwYieldData)
1730 {
1731 TRACE(mmsys, "(%u, %p)\n", uDeviceID, lpdwYieldData);
1732 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0) {
1733 WARN(mmsys, "Bad uDeviceID\n");
1734 return NULL;
1735 }
1736 if (!MCI_GetDrv(uDeviceID)->lpfnYieldProc) {
1737 WARN(mmsys, "No proc set\n");
1738 return NULL;
1739 }
1740 if (!MCI_GetDrv(uDeviceID)->bIs32) {
1741 WARN(mmsys, "Proc is 32 bit\n");
1742 return NULL;
1743 }
1744 return MCI_GetDrv(uDeviceID)->lpfnYieldProc;
1745 }
1746
1747 /**************************************************************************
1748 * mciGetCreatorTask [MMSYSTEM.717]
1749 */
1750 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
1751 {
1752 return mciGetCreatorTask(uDeviceID);
1753 }
1754
1755 /**************************************************************************
1756 * mciGetCreatorTask [WINMM.40]
1757 */
1758 HTASK WINAPI mciGetCreatorTask(UINT uDeviceID)
1759 {
1760 HTASK ret;
1761
1762 TRACE(mci, "(%u)\n", uDeviceID);
1763
1764 ret = (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0) ?
1765 0 : MCI_GetDrv(uDeviceID)->hCreatorTask;
1766
1767 TRACE(mci, "=> %04x\n", ret);
1768 return ret;
1769 }
1770
1771 /**************************************************************************
1772 * mciDriverYield [MMSYSTEM.710]
1773 */
1774 UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
1775 {
1776 UINT16 ret = 0;
1777
1778 TRACE(mmsys,"(%04x)\n", uDeviceID);
1779 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0 ||
1780 !MCI_GetDrv(uDeviceID)->lpfnYieldProc || MCI_GetDrv(uDeviceID)->bIs32) {
1781 UserYield16();
1782 } else {
1783 ret = MCI_GetDrv(uDeviceID)->lpfnYieldProc(uDeviceID, MCI_GetDrv(uDeviceID)->dwYieldData);
1784 }
1785
1786 return ret;
1787 }
1788
1789 /**************************************************************************
1790 * mciDriverYield [WINMM.37]
1791 */
1792 UINT WINAPI mciDriverYield(UINT uDeviceID)
1793 {
1794 UINT ret = 0;
1795
1796 TRACE(mmsys,"(%04x)\n", uDeviceID);
1797 if (!MCI_DevIDValid(uDeviceID) || MCI_GetDrv(uDeviceID)->modp.wType == 0 ||
1798 !MCI_GetDrv(uDeviceID)->lpfnYieldProc || !MCI_GetDrv(uDeviceID)->bIs32) {
1799 UserYield16();
1800 } else {
1801 ret = MCI_GetDrv(uDeviceID)->lpfnYieldProc(uDeviceID, MCI_GetDrv(uDeviceID)->dwYieldData);
1802 }
1803
1804 return ret;
1805 }
1806
1807 /**************************************************************************
1808 * midiOutGetNumDevs [WINMM.80]
1809 */
1810 UINT WINAPI midiOutGetNumDevs(void)
1811 {
1812 return midiOutGetNumDevs16();
1813 }
1814
1815 /**************************************************************************
1816 * midiOutGetNumDevs [MMSYSTEM.201]
1817 */
1818 UINT16 WINAPI midiOutGetNumDevs16(void)
1819 {
1820 UINT16 count = modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
1821
1822 TRACE(mmsys, "returns %u\n", count);
1823 return count;
1824 }
1825
1826 /**************************************************************************
1827 * midiOutGetDevCapsW [WINMM.76]
1828 */
1829 UINT WINAPI midiOutGetDevCapsW(UINT uDeviceID, LPMIDIOUTCAPSW lpCaps, UINT uSize)
1830 {
1831 MIDIOUTCAPS16 moc16;
1832 UINT ret;
1833
1834 ret = midiOutGetDevCaps16(uDeviceID, &moc16, sizeof(moc16));
1835 lpCaps->wMid = moc16.wMid;
1836 lpCaps->wPid = moc16.wPid;
1837 lpCaps->vDriverVersion = moc16.vDriverVersion;
1838 lstrcpyAtoW(lpCaps->szPname, moc16.szPname);
1839 lpCaps->wTechnology = moc16.wTechnology;
1840 lpCaps->wVoices = moc16.wVoices;
1841 lpCaps->wNotes = moc16.wNotes;
1842 lpCaps->wChannelMask = moc16.wChannelMask;
1843 lpCaps->dwSupport = moc16.dwSupport;
1844 return ret;
1845 }
1846
1847 /**************************************************************************
1848 * midiOutGetDevCapsA [WINMM.75]
1849 */
1850 UINT WINAPI midiOutGetDevCapsA(UINT uDeviceID, LPMIDIOUTCAPSA lpCaps, UINT uSize)
1851 {
1852 MIDIOUTCAPS16 moc16;
1853 UINT ret;
1854
1855 ret = midiOutGetDevCaps16(uDeviceID, &moc16, sizeof(moc16));
1856 lpCaps->wMid = moc16.wMid;
1857 lpCaps->wPid = moc16.wPid;
1858 lpCaps->vDriverVersion = moc16.vDriverVersion;
1859 strcpy(lpCaps->szPname, moc16.szPname);
1860 lpCaps->wTechnology = moc16.wTechnology;
1861 lpCaps->wVoices = moc16.wVoices;
1862 lpCaps->wNotes = moc16.wNotes;
1863 lpCaps->wChannelMask = moc16.wChannelMask;
1864 lpCaps->dwSupport = moc16.dwSupport;
1865 return ret;
1866 }
1867
1868 /**************************************************************************
1869 * midiOutGetDevCaps [MMSYSTEM.202]
1870 */
1871 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps, UINT16 uSize)
1872 {
1873 TRACE(mmsys, "midiOutGetDevCaps\n");
1874 return modMessage(uDeviceID, MODM_GETDEVCAPS, 0, (DWORD)lpCaps,uSize);
1875 }
1876
1877 /**************************************************************************
1878 * midiOutGetErrorTextA [WINMM.77]
1879 */
1880 UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
1881 {
1882 TRACE(mmsys, "midiOutGetErrorText\n");
1883 return midiGetErrorText(uError, lpText, uSize);
1884 }
1885
1886 /**************************************************************************
1887 * midiOutGetErrorTextW [WINMM.78]
1888 */
1889 UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
1890 {
1891 LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize);
1892 UINT ret;
1893
1894 TRACE(mmsys, "midiOutGetErrorText\n");
1895 ret = midiGetErrorText(uError, xstr, uSize);
1896 lstrcpyAtoW(lpText,xstr);
1897 HeapFree(GetProcessHeap(), 0,xstr);
1898 return ret;
1899 }
1900
1901 /**************************************************************************
1902 * midiOutGetErrorText [MMSYSTEM.203]
1903 */
1904 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
1905 {
1906 TRACE(mmsys, "midiOutGetErrorText\n");
1907 return midiGetErrorText(uError, lpText, uSize);
1908 }
1909
1910 /**************************************************************************
1911 * midiGetErrorText [internal]
1912 */
1913 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
1914 {
1915 LPSTR msgptr;
1916 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
1917 lpText[0] = '\0';
1918 switch (uError) {
1919 case MIDIERR_UNPREPARED:
1920 msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
1921 break;
1922 case MIDIERR_STILLPLAYING:
1923 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
1924 break;
1925 case MIDIERR_NOMAP:
1926 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.";
1927 break;
1928 case MIDIERR_NOTREADY:
1929 msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
1930 break;
1931 case MIDIERR_NODEVICE:
1932 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.";
1933 break;
1934 case MIDIERR_INVALIDSETUP:
1935 msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
1936 break;
1937 /*
1938 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
1939 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
1940 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
1941 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.
1942 msg# 340 : An error occurred using the specified port.
1943 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
1944 msg# 342 : There is no current MIDI port.
1945 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
1946 */
1947 default:
1948 msgptr = "Unknown MIDI Error !\n";
1949 break;
1950 }
1951 lstrcpynA(lpText, msgptr, uSize);
1952 return TRUE;
1953 }
1954
1955 /**************************************************************************
1956 * midiOutOpen [WINM.84]
1957 */
1958 UINT WINAPI midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID,
1959 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1960 {
1961 HMIDIOUT16 hmo16;
1962 UINT ret;
1963
1964 ret = midiOutOpen16(&hmo16,uDeviceID, dwCallback, dwInstance,
1965 CALLBACK32CONV(dwFlags));
1966 if (lphMidiOut) *lphMidiOut = hmo16;
1967 return ret;
1968 }
1969
1970 /**************************************************************************
1971 * midiOutOpen [MMSYSTEM.204]
1972 */
1973 UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID,
1974 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
1975 {
1976 HMIDI16 hMidiOut;
1977 LPMIDIOPENDESC lpDesc;
1978 DWORD dwRet = 0;
1979 BOOL bMapperFlg = FALSE;
1980
1981 if (lphMidiOut != NULL) *lphMidiOut = 0;
1982 TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
1983 lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
1984 if (uDeviceID == (UINT16)MIDI_MAPPER) {
1985 TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
1986 bMapperFlg = TRUE;
1987 uDeviceID = 0;
1988 }
1989 hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
1990 if (lphMidiOut != NULL)
1991 *lphMidiOut = hMidiOut;
1992 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
1993 if (lpDesc == NULL)
1994 return MMSYSERR_NOMEM;
1995 lpDesc->hMidi = hMidiOut;
1996 lpDesc->dwCallback = dwCallback;
1997 lpDesc->dwInstance = dwInstance;
1998
1999 while (uDeviceID < MAXMIDIDRIVERS) {
2000 dwRet = modMessage(uDeviceID, MODM_OPEN,
2001 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
2002 if (dwRet == MMSYSERR_NOERROR) break;
2003 if (!bMapperFlg) break;
2004 uDeviceID++;
2005 TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
2006 }
2007 lpDesc->wDevID = uDeviceID;
2008
2009 if (dwRet != MMSYSERR_NOERROR) {
2010 USER_HEAP_FREE(hMidiOut);
2011 if (lphMidiOut) *lphMidiOut = 0;
2012 }
2013
2014 return dwRet;
2015 }
2016
2017 /**************************************************************************
2018 * midiOutClose [WINMM.74]
2019 */
2020 UINT WINAPI midiOutClose(HMIDIOUT hMidiOut)
2021 {
2022 return midiOutClose16(hMidiOut);
2023 }
2024
2025 /**************************************************************************
2026 * midiOutClose [MMSYSTEM.205]
2027 */
2028 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
2029 {
2030 LPMIDIOPENDESC lpDesc;
2031 DWORD dwRet;
2032
2033 TRACE(mmsys, "(%04X)\n", hMidiOut);
2034
2035 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2036 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2037 dwRet = modMessage(lpDesc->wDevID, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2038 USER_HEAP_FREE(hMidiOut);
2039 return dwRet;
2040 }
2041
2042 /**************************************************************************
2043 * midiOutPrepareHeader [WINMM.85]
2044 */
2045 UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
2046 MIDIHDR16* lpMidiOutHdr, UINT uSize)
2047 {
2048 LPMIDIOPENDESC lpDesc;
2049
2050 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2051
2052 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2053 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2054 lpMidiOutHdr->reserved = (DWORD)lpMidiOutHdr->lpData;
2055 return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance,
2056 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2057 }
2058
2059 /**************************************************************************
2060 * midiOutPrepareHeader [MMSYSTEM.206]
2061 */
2062 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,
2063 MIDIHDR16* lpMidiOutHdr, UINT16 uSize)
2064 {
2065 LPMIDIOPENDESC lpDesc;
2066
2067 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2068
2069 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2070 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2071 lpMidiOutHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiOutHdr->lpData);
2072 return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance,
2073 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2074 }
2075
2076 /**************************************************************************
2077 * midiOutUnprepareHeader [WINMM.89]
2078 */
2079 UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
2080 MIDIHDR16* lpMidiOutHdr, UINT uSize)
2081 {
2082 return midiOutUnprepareHeader16(hMidiOut, lpMidiOutHdr,uSize);
2083 }
2084
2085 /**************************************************************************
2086 * midiOutUnprepareHeader [MMSYSTEM.207]
2087 */
2088 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,
2089 MIDIHDR16* lpMidiOutHdr, UINT16 uSize)
2090 {
2091 LPMIDIOPENDESC lpDesc;
2092
2093 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2094
2095 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2096 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2097 return modMessage(lpDesc->wDevID, MODM_UNPREPARE, lpDesc->dwInstance,
2098 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2099 }
2100
2101 /**************************************************************************
2102 * midiOutShortMsg [WINMM.88]
2103 */
2104 UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
2105 {
2106 return midiOutShortMsg16(hMidiOut, dwMsg);
2107 }
2108
2109 /**************************************************************************
2110 * midiOutShortMsg [MMSYSTEM.208]
2111 */
2112 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
2113 {
2114 LPMIDIOPENDESC lpDesc;
2115
2116 TRACE(mmsys, "(%04X, %08lX)\n", hMidiOut, dwMsg);
2117
2118 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2119 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2120 return modMessage(lpDesc->wDevID, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
2121 }
2122
2123 /**************************************************************************
2124 * midiOutLongMsg [WINMM.82]
2125 */
2126 UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
2127 MIDIHDR16* lpMidiOutHdr, UINT uSize)
2128 {
2129 return midiOutLongMsg16(hMidiOut, lpMidiOutHdr,uSize);
2130 }
2131
2132 /**************************************************************************
2133 * midiOutLongMsg [MMSYSTEM.209]
2134 */
2135 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,
2136 MIDIHDR16* lpMidiOutHdr, UINT16 uSize)
2137 {
2138 LPMIDIOPENDESC lpDesc;
2139
2140 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2141
2142 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2143 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2144 return modMessage(lpDesc->wDevID, MODM_LONGDATA, lpDesc->dwInstance,
2145 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2146 }
2147
2148 /**************************************************************************
2149 * midiOutReset [WINMM.86]
2150 */
2151 UINT WINAPI midiOutReset(HMIDIOUT hMidiOut)
2152 {
2153 return midiOutReset16(hMidiOut);
2154 }
2155
2156 /**************************************************************************
2157 * midiOutReset [MMSYSTEM.210]
2158 */
2159 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
2160 {
2161 LPMIDIOPENDESC lpDesc;
2162
2163 TRACE(mmsys, "(%04X)\n", hMidiOut);
2164
2165 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2166 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2167 return modMessage(lpDesc->wDevID, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
2168 }
2169
2170 /**************************************************************************
2171 * midiOutGetVolume [WINM.81]
2172 */
2173 UINT WINAPI midiOutGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
2174 {
2175 return midiOutGetVolume16(uDeviceID, lpdwVolume);
2176 }
2177
2178 /**************************************************************************
2179 * midiOutGetVolume [MMSYSTEM.211]
2180 */
2181 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
2182 {
2183 TRACE(mmsys, "(%04X, %p);\n", uDeviceID, lpdwVolume);
2184 return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
2185 }
2186
2187 /**************************************************************************
2188 * midiOutSetVolume [WINMM.87]
2189 */
2190 UINT WINAPI midiOutSetVolume(UINT uDeviceID, DWORD dwVolume)
2191 {
2192 return midiOutSetVolume16(uDeviceID, dwVolume);
2193 }
2194
2195 /**************************************************************************
2196 * midiOutSetVolume [MMSYSTEM.212]
2197 */
2198 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
2199 {
2200 TRACE(mmsys, "(%04X, %08lX);\n", uDeviceID, dwVolume);
2201 return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
2202 }
2203
2204 /**************************************************************************
2205 * midiOutCachePatches [WINMM.73]
2206 */
2207 UINT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut, UINT uBank,
2208 WORD* lpwPatchArray, UINT uFlags)
2209 {
2210 return midiOutCachePatches16(hMidiOut,uBank, lpwPatchArray,uFlags);
2211 }
2212
2213 /**************************************************************************
2214 * midiOutCachePatches [MMSYSTEM.213]
2215 */
2216 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
2217 WORD* lpwPatchArray, UINT16 uFlags)
2218 {
2219 /* not really necessary to support this */
2220 FIXME(mmsys, "not supported yet\n");
2221 return MMSYSERR_NOTSUPPORTED;
2222 }
2223
2224 /**************************************************************************
2225 * midiOutCacheDrumPatches [WINMM.72]
2226 */
2227 UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut, UINT uPatch,
2228 WORD* lpwKeyArray, UINT uFlags)
2229 {
2230 return midiOutCacheDrumPatches16(hMidiOut,uPatch, lpwKeyArray,uFlags);
2231 }
2232
2233 /**************************************************************************
2234 * midiOutCacheDrumPatches [MMSYSTEM.214]
2235 */
2236 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
2237 WORD* lpwKeyArray, UINT16 uFlags)
2238 {
2239 FIXME(mmsys, "not supported yet\n");
2240 return MMSYSERR_NOTSUPPORTED;
2241 }
2242
2243 /**************************************************************************
2244 * midiOutGetID [WINMM.79]
2245 */
2246 UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT* lpuDeviceID)
2247 {
2248 UINT16 xid;
2249 UINT ret;
2250
2251 ret = midiOutGetID16(hMidiOut, &xid);
2252 *lpuDeviceID = xid;
2253 return ret;
2254 }
2255
2256 /**************************************************************************
2257 * midiOutGetID [MMSYSTEM.215]
2258 */
2259 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID)
2260 {
2261 TRACE(mmsys, "midiOutGetID\n");
2262 return 0;
2263 }
2264
2265 /**************************************************************************
2266 * midiOutMessage [WINMM.83]
2267 */
2268 DWORD WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
2269 DWORD dwParam1, DWORD dwParam2)
2270 {
2271 LPMIDIOPENDESC lpDesc;
2272
2273 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2274 hMidiOut, uMessage, dwParam1, dwParam2);
2275 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2276 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2277 switch (uMessage) {
2278 case MODM_OPEN:
2279 FIXME(mmsys,"can't handle MODM_OPEN!\n");
2280 return 0;
2281 case MODM_GETDEVCAPS:
2282 return midiOutGetDevCapsA(hMidiOut, (LPMIDIOUTCAPSA)dwParam1, dwParam2);
2283 case MODM_GETNUMDEVS:
2284 case MODM_RESET:
2285 case MODM_CLOSE:
2286 case MODM_GETVOLUME:
2287 case MODM_SETVOLUME:
2288 case MODM_LONGDATA:
2289 case MODM_PREPARE:
2290 case MODM_UNPREPARE:
2291 /* no argument conversion needed */
2292 break;
2293 default:
2294 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2295 hMidiOut,uMessage, dwParam1, dwParam2);
2296 break;
2297 }
2298 return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2299 }
2300
2301 /**************************************************************************
2302 * midiOutMessage [MMSYSTEM.216]
2303 */
2304 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
2305 DWORD dwParam1, DWORD dwParam2)
2306 {
2307 LPMIDIOPENDESC lpDesc;
2308
2309 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2310 hMidiOut, uMessage, dwParam1, dwParam2);
2311 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2312 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2313 switch (uMessage) {
2314 case MODM_OPEN:
2315 FIXME(mmsys,"can't handle MODM_OPEN!\n");
2316 return 0;
2317 case MODM_GETNUMDEVS:
2318 case MODM_RESET:
2319 case MODM_CLOSE:
2320 case MODM_SETVOLUME:
2321 /* no argument conversion needed */
2322 break;
2323 case MODM_GETVOLUME:
2324 return midiOutGetVolume16(hMidiOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
2325 case MODM_LONGDATA:
2326 return midiOutLongMsg16(hMidiOut, (LPMIDIHDR16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2327 case MODM_PREPARE:
2328 return midiOutPrepareHeader16(hMidiOut, (LPMIDIHDR16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2329 case MODM_UNPREPARE:
2330 return midiOutUnprepareHeader16(hMidiOut, (LPMIDIHDR16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2331 default:
2332 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2333 hMidiOut,uMessage, dwParam1, dwParam2);
2334 break;
2335 }
2336 return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2337 }
2338
2339 /**************************************************************************
2340 * midiInGetNumDevs [WINMM.64]
2341 */
2342 UINT WINAPI midiInGetNumDevs(void)
2343 {
2344 return midiInGetNumDevs16();
2345 }
2346
2347 /**************************************************************************
2348 * midiInGetNumDevs [MMSYSTEM.301]
2349 */
2350 UINT16 WINAPI midiInGetNumDevs16(void)
2351 {
2352 UINT16 count = 0;
2353 TRACE(mmsys, "midiInGetNumDevs\n");
2354 count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
2355 TRACE(mmsys, "midiInGetNumDevs return %u \n", count);
2356 return count;
2357 }
2358
2359 /**************************************************************************
2360 * midiInGetDevCaps [WINMM.60]
2361 */
2362 UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
2363 {
2364 MIDIINCAPS16 mic16;
2365 UINT ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize);
2366
2367 lpCaps->wMid = mic16.wMid;
2368 lpCaps->wPid = mic16.wPid;
2369 lpCaps->vDriverVersion = mic16.vDriverVersion;
2370 lstrcpyAtoW(lpCaps->szPname, mic16.szPname);
2371 lpCaps->dwSupport = mic16.dwSupport;
2372 return ret;
2373 }
2374
2375 /**************************************************************************
2376 * midiInGetDevCaps [WINMM.59]
2377 */
2378 UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
2379 {
2380 MIDIINCAPS16 mic16;
2381 UINT ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize);
2382
2383 lpCaps->wMid = mic16.wMid;
2384 lpCaps->wPid = mic16.wPid;
2385 lpCaps->vDriverVersion = mic16.vDriverVersion;
2386 strcpy(lpCaps->szPname, mic16.szPname);
2387 lpCaps->dwSupport = mic16.dwSupport;
2388 return ret;
2389 }
2390
2391 /**************************************************************************
2392 * midiInGetDevCaps [MMSYSTEM.302]
2393 */
2394 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID,
2395 LPMIDIINCAPS16 lpCaps, UINT16 uSize)
2396 {
2397 TRACE(mmsys, "midiInGetDevCaps\n");
2398 return midMessage(uDeviceID, MIDM_GETDEVCAPS, 0, (DWORD)lpCaps, uSize);
2399 }
2400
2401 /**************************************************************************
2402 * midiInGetErrorText [WINMM.62]
2403 */
2404 UINT WINAPI midiInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
2405 {
2406 LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize);
2407 UINT ret = midiInGetErrorText16(uError,xstr,uSize);
2408 lstrcpyAtoW(lpText,xstr);
2409 HeapFree(GetProcessHeap(), 0,xstr);
2410 return ret;
2411 }
2412
2413 /**************************************************************************
2414 * midiInGetErrorText [WINMM.61]
2415 */
2416 UINT WINAPI midiInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
2417 {
2418 return midiInGetErrorText16(uError, lpText,uSize);
2419 }
2420
2421 /**************************************************************************
2422 * midiInGetErrorText [MMSYSTEM.303]
2423 */
2424 UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2425 {
2426 TRACE(mmsys, "midiInGetErrorText\n");
2427 return (midiGetErrorText(uError, lpText, uSize));
2428 }
2429
2430 /**************************************************************************
2431 * midiInOpen [WINMM.66]
2432 */
2433 UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
2434 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2435 {
2436 HMIDIIN16 xhmid16;
2437 UINT ret = midiInOpen16(&xhmid16,uDeviceID, dwCallback, dwInstance,
2438 CALLBACK32CONV(dwFlags));
2439 if (lphMidiIn)
2440 *lphMidiIn = xhmid16;
2441 return ret;
2442 }
2443
2444 /**************************************************************************
2445 * midiInOpen [MMSYSTEM.304]
2446 */
2447 UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
2448 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2449 {
2450 HMIDI16 hMidiIn;
2451 LPMIDIOPENDESC lpDesc;
2452 DWORD dwRet = 0;
2453 BOOL bMapperFlg = FALSE;
2454
2455 if (lphMidiIn != NULL)
2456 *lphMidiIn = 0;
2457 TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
2458 lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
2459 if (uDeviceID == (UINT16)MIDI_MAPPER) {
2460 TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
2461 bMapperFlg = TRUE;
2462 uDeviceID = 0;
2463 }
2464 hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
2465 if (lphMidiIn != NULL)
2466 *lphMidiIn = hMidiIn;
2467 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2468 if (lpDesc == NULL)
2469 return MMSYSERR_NOMEM;
2470 lpDesc->hMidi = hMidiIn;
2471 lpDesc->dwCallback = dwCallback;
2472 lpDesc->dwInstance = dwInstance;
2473
2474 while (uDeviceID < MAXMIDIDRIVERS) {
2475 dwRet = midMessage(uDeviceID, MIDM_OPEN,
2476 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
2477 if (dwRet == MMSYSERR_NOERROR)
2478 break;
2479 if (!bMapperFlg)
2480 break;
2481 uDeviceID++;
2482 TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
2483 }
2484 lpDesc->wDevID = uDeviceID;
2485
2486 if (dwRet != MMSYSERR_NOERROR) {
2487 USER_HEAP_FREE(hMidiIn);
2488 if (lphMidiIn) *lphMidiIn = 0;
2489 }
2490
2491 return dwRet;
2492 }
2493
2494 /**************************************************************************
2495 * midiInClose [WINMM.58]
2496 */
2497 UINT WINAPI midiInClose(HMIDIIN hMidiIn)
2498 {
2499 return midiInClose16(hMidiIn);
2500 }
2501
2502 /**************************************************************************
2503 * midiInClose [MMSYSTEM.305]
2504 */
2505 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
2506 {
2507 LPMIDIOPENDESC lpDesc;
2508 DWORD dwRet;
2509
2510 TRACE(mmsys, "(%04X)\n", hMidiIn);
2511 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2512 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2513 dwRet = midMessage(lpDesc->wDevID, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2514 USER_HEAP_FREE(hMidiIn);
2515 return dwRet;
2516 }
2517
2518 /**************************************************************************
2519 * midiInPrepareHeader [WINMM.67]
2520 */
2521 UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
2522 MIDIHDR16* lpMidiInHdr, UINT uSize)
2523 {
2524 LPMIDIOPENDESC lpDesc;
2525
2526 TRACE(mmsys, "(%04X, %p, %d)\n",
2527 hMidiIn, lpMidiInHdr, uSize);
2528 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2529 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2530 lpMidiInHdr->reserved = (DWORD)lpMidiInHdr->lpData;
2531 return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance,
2532 (DWORD)lpMidiInHdr, (DWORD)uSize);
2533 }
2534
2535 /**************************************************************************
2536 * midiInPrepareHeader [MMSYSTEM.306]
2537 */
2538 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,
2539 MIDIHDR16* lpMidiInHdr, UINT16 uSize)
2540 {
2541 LPMIDIOPENDESC lpDesc;
2542
2543 TRACE(mmsys, "(%04X, %p, %d)\n",
2544 hMidiIn, lpMidiInHdr, uSize);
2545 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2546 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2547 lpMidiInHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiInHdr->lpData);
2548 return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance,
2549 (DWORD)lpMidiInHdr, (DWORD)uSize);
2550 }
2551
2552 /**************************************************************************
2553 * midiInUnprepareHeader [WINMM.71]
2554 */
2555 UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
2556 MIDIHDR16* lpMidiInHdr, UINT uSize)
2557 {
2558 return midiInUnprepareHeader16(hMidiIn, lpMidiInHdr,uSize);
2559 }
2560
2561 /**************************************************************************
2562 * midiInUnprepareHeader [MMSYSTEM.307]
2563 */
2564 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,
2565 MIDIHDR16* lpMidiInHdr, UINT16 uSize)
2566 {
2567 LPMIDIOPENDESC lpDesc;
2568 TRACE(mmsys, "(%04X, %p, %d)\n",
2569 hMidiIn, lpMidiInHdr, uSize);
2570 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2571 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2572 return midMessage(lpDesc->wDevID, MIDM_UNPREPARE, lpDesc->dwInstance,
2573 (DWORD)lpMidiInHdr, (DWORD)uSize);
2574 }
2575
2576 /**************************************************************************
2577 * midiInAddBuffer [WINMM.57]
2578 */
2579 UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
2580 MIDIHDR16* lpMidiInHdr, UINT uSize)
2581 {
2582 return midiInAddBuffer16(hMidiIn, lpMidiInHdr,uSize);
2583 }
2584
2585 /**************************************************************************
2586 * midiInAddBuffer [MMSYSTEM.308]
2587 */
2588 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,
2589 MIDIHDR16* lpMidiInHdr, UINT16 uSize)
2590 {
2591 TRACE(mmsys, "midiInAddBuffer\n");
2592 return 0;
2593 }
2594
2595 /**************************************************************************
2596 * midiInStart [WINMM.69]
2597 */
2598 UINT WINAPI midiInStart(HMIDIIN hMidiIn)
2599 {
2600 return midiInStart16(hMidiIn);
2601 }
2602
2603 /**************************************************************************
2604 * midiInStart [MMSYSTEM.309]
2605 */
2606 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
2607 {
2608 LPMIDIOPENDESC lpDesc;
2609
2610 TRACE(mmsys, "(%04X)\n", hMidiIn);
2611 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2612 if (lpDesc == NULL)
2613 return MMSYSERR_INVALHANDLE;
2614 return midMessage(lpDesc->wDevID, MIDM_START, lpDesc->dwInstance, 0L, 0L);
2615 }
2616
2617 /**************************************************************************
2618 * midiInStop [WINMM.70]
2619 */
2620 UINT WINAPI midiInStop(HMIDIIN hMidiIn)
2621 {
2622 return midiInStop16(hMidiIn);
2623 }
2624
2625 /**************************************************************************
2626 * midiInStop [MMSYSTEM.310]
2627 */
2628 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
2629 {
2630 LPMIDIOPENDESC lpDesc;
2631
2632 TRACE(mmsys, "(%04X)\n", hMidiIn);
2633 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2634 if (lpDesc == NULL)
2635 return MMSYSERR_INVALHANDLE;
2636 return midMessage(lpDesc->wDevID, MIDM_STOP, lpDesc->dwInstance, 0L, 0L);
2637 }
2638
2639 /**************************************************************************
2640 * midiInReset [WINMM.68]
2641 */
2642 UINT WINAPI midiInReset(HMIDIIN hMidiIn)
2643 {
2644 return midiInReset16(hMidiIn);
2645 }
2646
2647 /**************************************************************************
2648 * midiInReset [MMSYSTEM.311]
2649 */
2650 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
2651 {
2652 LPMIDIOPENDESC lpDesc;
2653
2654 TRACE(mmsys, "(%04X)\n", hMidiIn);
2655 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2656 if (lpDesc == NULL)
2657 return MMSYSERR_INVALHANDLE;
2658 return midMessage(lpDesc->wDevID, MIDM_RESET, lpDesc->dwInstance, 0L, 0L);
2659 }
2660
2661 /**************************************************************************
2662 * midiInGetID [WINMM.63]
2663 */
2664 UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT* lpuDeviceID)
2665 {
2666 LPMIDIOPENDESC lpDesc;
2667
2668 TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID);
2669 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2670 if (lpDesc == NULL)
2671 return MMSYSERR_INVALHANDLE;
2672 if (lpuDeviceID == NULL)
2673 return MMSYSERR_INVALPARAM;
2674 *lpuDeviceID = lpDesc->wDevID;
2675
2676 return MMSYSERR_NOERROR;
2677 }
2678
2679 /**************************************************************************
2680 * midiInGetID [MMSYSTEM.312]
2681 */
2682 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
2683 {
2684 LPMIDIOPENDESC lpDesc;
2685
2686 TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID);
2687 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2688 if (lpDesc == NULL)
2689 return MMSYSERR_INVALHANDLE;
2690 if (lpuDeviceID == NULL)
2691 return MMSYSERR_INVALPARAM;
2692 *lpuDeviceID = lpDesc->wDevID;
2693
2694 return MMSYSERR_NOERROR;
2695 }
2696
2697 /**************************************************************************
2698 * midiInMessage [WINMM.65]
2699 */
2700 DWORD WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
2701 DWORD dwParam1, DWORD dwParam2)
2702 {
2703 LPMIDIOPENDESC lpDesc;
2704
2705 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2706 hMidiIn, uMessage, dwParam1, dwParam2);
2707 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2708 if (lpDesc == NULL)
2709 return MMSYSERR_INVALHANDLE;
2710
2711 switch (uMessage) {
2712 case MIDM_OPEN:
2713 FIXME(mmsys,"can't handle MIDM_OPEN!\n");
2714 return 0;
2715 case MIDM_GETDEVCAPS:
2716 return midiInGetDevCapsA(hMidiIn, (LPMIDIINCAPSA)dwParam1, dwParam2);
2717 case MIDM_GETNUMDEVS:
2718 case MIDM_RESET:
2719 case MIDM_STOP:
2720 case MIDM_START:
2721 case MIDM_CLOSE:
2722 /* no argument conversion needed */
2723 break;
2724 case MIDM_PREPARE:
2725 return midiInPrepareHeader(hMidiIn, (LPMIDIHDR16)dwParam1, dwParam2);
2726 case MIDM_UNPREPARE:
2727 return midiInUnprepareHeader(hMidiIn, (LPMIDIHDR16)dwParam1, dwParam2);
2728 case MIDM_ADDBUFFER:
2729 return midiInAddBuffer(hMidiIn, (LPMIDIHDR16)dwParam1, dwParam2);
2730 default:
2731 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2732 hMidiIn,uMessage, dwParam1, dwParam2);
2733 break;
2734 }
2735 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2736 }
2737
2738 /**************************************************************************
2739 * midiInMessage [MMSYSTEM.313]
2740 */
2741 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
2742 DWORD dwParam1, DWORD dwParam2)
2743 {
2744 LPMIDIOPENDESC lpDesc;
2745
2746 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
2747
2748 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
2749 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2750 switch (uMessage) {
2751 case MIDM_OPEN:
2752 WARN(mmsys,"can't handle MIDM_OPEN!\n");
2753 return 0;
2754 case MIDM_GETDEVCAPS:
2755 return midiInGetDevCaps16(hMidiIn, (LPMIDIINCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2756 case MIDM_GETNUMDEVS:
2757 case MIDM_RESET:
2758 case MIDM_STOP:
2759 case MIDM_START:
2760 case MIDM_CLOSE:
2761 /* no argument conversion needed */
2762 break;
2763 case MIDM_PREPARE:
2764 return midiInPrepareHeader16(hMidiIn, (LPMIDIHDR16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2765 case MIDM_UNPREPARE:
2766 return midiInUnprepareHeader16(hMidiIn, (LPMIDIHDR16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2767 case MIDM_ADDBUFFER:
2768 return midiInAddBuffer16(hMidiIn, (LPMIDIHDR16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2769 default:
2770 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2771 hMidiIn,uMessage, dwParam1, dwParam2);
2772 break;
2773 }
2774 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2775 }
2776
2777 #define MIDI_STREAM_MAGIC 0xC9080F17
2778
2779 typedef struct {
2780 DWORD dwMagic;
2781 HMIDIOUT hDevice;
2782 /* thread ID */
2783 DWORD dwTempo;
2784 DWORD dwTimeDiv;
2785 DWORD dwMS;
2786 DWORD dwStatus;
2787 LPMIDIHDR lpMidiHdr;
2788 } WINE_MIDIStream;
2789
2790 /**************************************************************************
2791 * MMSYSTEM_MidiStreamPlayer [internal]
2792 */
2793 static void WINE_UNUSED MMSYSTEM_MidiStreamPlayer(WINE_MIDIStream* ms)
2794 {
2795 /* FIXME: should I sleep a bit when there is no pending lpMidiHdr ?
2796 * => provide a better synchronization system
2797 * midiStreamPause/midiStreamRestart should freeze/thaw this thread
2798 * global resource should guard access to ms->lpMidiHdr list, or
2799 * use a MB to send new LPMIDIHDR
2800 * an empty ms->lpMidiHdr list should freeze this thread
2801 */
2802 for (;;) {
2803 if (ms->dwStatus && ms->lpMidiHdr) {
2804 LPMIDIEVENT me = (LPMIDIEVENT)(ms->lpMidiHdr->lpData + ms->lpMidiHdr->dwOffset);
2805
2806 FIXME(mmsys, "Should wait for current time to be in sync with me->dwDeltaTime\n");
2807
2808 if (me->dwEvent & MEVT_F_CALLBACK) {
2809 WARN(mmsys, "Should generate callback when encountering F_CALLBACK flagged midi events...\n");
2810 }
2811 switch (MEVT_EVENTTYPE(me->dwEvent)) {
2812 case MEVT_COMMENT:
2813 /* do nothing, skip bytes */
2814 break;
2815 case MEVT_LONGMSG:
2816 WARN(mmsys, "NIY: sending Sysex Event");
2817 break;
2818 case MEVT_NOP:
2819 break;
2820 case MEVT_SHORTMSG:
2821 midiOutShortMsg(ms->hDevice, MEVT_EVENTPARM(me->dwEvent));
2822 break;
2823 case MEVT_TEMPO:
2824 ms->dwTempo = MEVT_EVENTPARM(me->dwEvent);
2825 break;
2826 case MEVT_VERSION:
2827 break;
2828 }
2829 ms->lpMidiHdr->dwOffset += sizeof(MIDIEVENT);
2830 if (me->dwEvent & MEVT_F_LONG) {
2831 ms->lpMidiHdr->dwOffset += MEVT_EVENTPARM(me->dwEvent);
2832 }
2833 if (ms->lpMidiHdr->dwOffset >= ms->lpMidiHdr->dwBufferLength) {
2834 ms->lpMidiHdr->dwFlags |= MHDR_DONE;
2835 ms->lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
2836 ms->lpMidiHdr = (LPMIDIHDR)ms->lpMidiHdr->lpNext;
2837 WARN(mmsys, "Should generate callback when done with MIDIHDR...\n");
2838 }
2839 FIXME(mmsys, "Should accordingly update ms->dwMS with me->dwDeltaTime\n");
2840 }
2841 }
2842 }
2843
2844 /**************************************************************************
2845 * midiStreamClose [WINMM.90]
2846 */
2847 MMRESULT WINAPI midiStreamClose(HMIDISTRM hms)
2848 {
2849 WINE_MIDIStream* ms;
2850
2851 TRACE(midi, "(%08x)!\n", hms);
2852
2853 ms = (WINE_MIDIStream*)hms;
2854 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
2855 return MMSYSERR_INVALHANDLE;
2856
2857 free(ms);
2858
2859 return MMSYSERR_NOTSUPPORTED;
2860 }
2861
2862 /**************************************************************************
2863 * midiStreamOpen [WINMM.91]
2864 */
2865 MMRESULT WINAPI midiStreamOpen(HMIDISTRM* phms, LPUINT lpuDeviceID,
2866 DWORD cMidi, DWORD dwCallback,
2867 DWORD dwInstance, DWORD fdwOpen)
2868 {
2869 WINE_MIDIStream* ms;
2870
2871 TRACE(midi, "(%p,%p,%ld, 0x%08lx, 0x%08lx, 0x%08lx), stub!\n",
2872 phms, lpuDeviceID,cMidi, dwCallback, dwInstance, fdwOpen);
2873
2874 if (cMidi != 1 || phms == NULL || lpuDeviceID == NULL)
2875 return MMSYSERR_INVALPARAM;
2876
2877 ms = malloc(sizeof(WINE_MIDIStream));
2878 *phms = (HMIDISTRM)ms;
2879 ms->dwMagic = MIDI_STREAM_MAGIC;
2880 ms->dwTempo = 50000; /* FIXME */
2881 ms->dwTimeDiv = 1; /* FIXME */
2882 ms->dwMS = 0;
2883 ms->dwStatus = 0;
2884
2885 /* FIXME is this correct ? */
2886 *lpuDeviceID = 0;
2887 /* FIXME is this correct ? */
2888 return midiOutOpen(&(ms->hDevice), *lpuDeviceID, dwCallback, dwInstance, fdwOpen);
2889 }
2890
2891 /**************************************************************************
2892 * midiStreamOut [WINMM.92]
2893 */
2894 MMRESULT WINAPI midiStreamOut(HMIDISTRM hms, LPMIDIHDR16 lpMidiHdr, UINT cbMidiHdr)
2895 {
2896 FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMidiHdr, cbMidiHdr);
2897 return MMSYSERR_NOTSUPPORTED;
2898 }
2899
2900 /**************************************************************************
2901 * midiStreamPause [WINMM.93]
2902 */
2903 MMRESULT WINAPI midiStreamPause(HMIDISTRM hms)
2904 {
2905 WINE_MIDIStream* ms;
2906
2907 TRACE(midi, "(%08x)!\n", hms);
2908
2909 ms = (WINE_MIDIStream*)hms;
2910 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
2911 return MMSYSERR_INVALHANDLE;
2912
2913 ms->dwStatus = 0;
2914 return MMSYSERR_NOERROR;
2915 }
2916
2917 /**************************************************************************
2918 * midiStreamPosition [WINMM.94]
2919 */
2920 MMRESULT WINAPI midiStreamPosition(HMIDISTRM hms, LPMMTIME lpMMT, UINT cbmmt)
2921 {
2922 WINE_MIDIStream* ms;
2923 DWORD ret = MMSYSERR_NOERROR;
2924
2925 FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMMT, cbmmt);
2926
2927 ms = (WINE_MIDIStream*)hms;
2928
2929 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) {
2930 ret = MMSYSERR_INVALHANDLE;
2931 } else if (lpMMT == NULL || cbmmt != sizeof(MMTIME)) {
2932 ret = MMSYSERR_INVALPARAM;
2933 } else {
2934 switch (lpMMT->wType) {
2935 case TIME_MS:
2936 lpMMT->u.ms = ms->dwMS;
2937 break;
2938 default:
2939 lpMMT->wType = TIME_MS;
2940 ret = MMSYSERR_INVALPARAM;
2941 }
2942 }
2943 return ret;
2944 }
2945
2946 /**************************************************************************
2947 * midiStreamProperty [WINMM.95]
2948 */
2949 MMRESULT WINAPI midiStreamProperty(HMIDISTRM hms, LPBYTE lpPropData, DWORD dwProperty)
2950 {
2951 WINE_MIDIStream* ms = (WINE_MIDIStream*)hms;
2952 MMRESULT ret = MMSYSERR_NOERROR;
2953
2954 TRACE(midi, "(%08x, %p, %lx)\n", hms, lpPropData, dwProperty);
2955
2956 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) {
2957 ret = MMSYSERR_INVALHANDLE;
2958 } else if ((dwProperty & (MIDIPROP_GET|MIDIPROP_SET)) == 0) {
2959 return MMSYSERR_INVALPARAM;
2960 } else if (dwProperty & MIDIPROP_TEMPO) {
2961 MIDIPROPTEMPO* mpt = (MIDIPROPTEMPO*)lpPropData;
2962
2963 if (sizeof(MIDIPROPTEMPO) != mpt->cbStruct) {
2964 ret = MMSYSERR_INVALPARAM;
2965 } else if (dwProperty & MIDIPROP_GET) {
2966 ms->dwTempo = mpt->dwTempo;
2967 } else if (dwProperty & MIDIPROP_SET) {
2968 mpt->dwTempo = ms->dwTempo;
2969 }
2970 } else if (dwProperty & MIDIPROP_TIMEDIV) {
2971 MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData;
2972
2973 if (sizeof(MIDIPROPTIMEDIV) != mptd->cbStruct) {
2974 ret = MMSYSERR_INVALPARAM;
2975 } else if (dwProperty & MIDIPROP_GET) {
2976 ms->dwTimeDiv = mptd->dwTimeDiv;
2977 } else if (dwProperty & MIDIPROP_SET) {
2978 mptd->dwTimeDiv = ms->dwTimeDiv;
2979 }
2980 } else {
2981 ret = MMSYSERR_INVALPARAM;
2982 }
2983
2984 return ret;
2985 }
2986
2987 /**************************************************************************
2988 * midiStreamRestart [WINMM.96]
2989 */
2990 MMRESULT WINAPI midiStreamRestart(HMIDISTRM hms)
2991 {
2992 WINE_MIDIStream* ms;
2993
2994 TRACE(midi, "(%08x)!\n", hms);
2995
2996 ms = (WINE_MIDIStream*)hms;
2997 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
2998 return MMSYSERR_INVALHANDLE;
2999
3000 ms->dwStatus = 1;
3001 return MMSYSERR_NOERROR;
3002 }
3003
3004 /**************************************************************************
3005 * midiStreamStop [WINMM.97]
3006 */
3007 MMRESULT WINAPI midiStreamStop(HMIDISTRM hms)
3008 {
3009 FIXME(midi, "(%08x stub!)\n", hms);
3010 return MMSYSERR_NOTSUPPORTED;
3011 }
3012
3013 /**************************************************************************
3014 * midiStreamClose [MMSYSTEM.252]
3015 */
3016 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms)
3017 {
3018 return midiStreamClose(hms);
3019 }
3020
3021 /**************************************************************************
3022 * midiStreamOpen [MMSYSTEM.251]
3023 */
3024 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phms, LPUINT16 devid,
3025 DWORD cMidi, DWORD dwCallback,
3026 DWORD dwInstance, DWORD fdwOpen)
3027 {
3028 HMIDISTRM hms32;
3029 MMRESULT ret;
3030 UINT devid32;
3031
3032 if (!phms || !devid)
3033 return MMSYSERR_INVALPARAM;
3034 devid32 = *devid;
3035 ret = midiStreamOpen(&hms32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen);
3036 *phms = hms32;
3037 *devid = devid32;
3038 return ret;
3039 }
3040
3041 /**************************************************************************
3042 * midiStreamOut [MMSYSTEM.254]
3043 */
3044 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hms, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr)
3045 {
3046 return midiStreamOut(hms, lpMidiHdr, cbMidiHdr);
3047 }
3048
3049 /**************************************************************************
3050 * midiStreamPause [MMSYSTEM.255]
3051 */
3052 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hms)
3053 {
3054 return midiStreamPause(hms);
3055 }
3056
3057 /**************************************************************************
3058 * midiStreamPosition [MMSYSTEM.253]
3059 */
3060 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hms, LPMMTIME16 lpmmt, UINT16 cbmmt)
3061 {
3062 MMTIME mmt32;
3063 MMRESULT ret;
3064
3065 if (!lpmmt)
3066 return MMSYSERR_INVALPARAM;
3067 MMSYSTEM_MMTIME16to32(&mmt32, lpmmt);
3068 ret = midiStreamPosition(hms, &mmt32, cbmmt);
3069 MMSYSTEM_MMTIME32to16(lpmmt, &mmt32);
3070 return ret;
3071 }
3072
3073 /**************************************************************************
3074 * midiStreamProperty [MMSYSTEM.250]
3075 */
3076 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hms, LPBYTE lpPropData, DWORD dwProperty)
3077 {
3078 return midiStreamProperty(hms, lpPropData, dwProperty);
3079 }
3080
3081 /**************************************************************************
3082 * midiStreamRestart [MMSYSTEM.256]
3083 */
3084 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hms)
3085 {
3086 return midiStreamRestart(hms);
3087 }
3088
3089 /**************************************************************************
3090 * midiStreamStop [MMSYSTEM.257]
3091 */
3092 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hms)
3093 {
3094 return midiStreamStop(hms);
3095 }
3096
3097 /**************************************************************************
3098 * waveOutGetNumDevs [MMSYSTEM.401]
3099 */
3100 UINT WINAPI waveOutGetNumDevs()
3101 {
3102 return waveOutGetNumDevs16();
3103 }
3104
3105 /**************************************************************************
3106 * waveOutGetNumDevs [WINMM.167]
3107 */
3108 UINT16 WINAPI waveOutGetNumDevs16()
3109 {
3110 UINT16 count = 0;
3111 TRACE(mmsys, "waveOutGetNumDevs\n");
3112 /* FIXME: I'm not sure MCI_FirstDevID() is correct */
3113 count += wodMessage(MCI_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L);
3114 TRACE(mmsys, "waveOutGetNumDevs return %u \n", count);
3115 return count;
3116 }
3117
3118 /**************************************************************************
3119 * waveOutGetDevCaps [MMSYSTEM.402]
3120 */
3121 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, LPWAVEOUTCAPS16 lpCaps,
3122 UINT16 uSize)
3123 {
3124 if (uDeviceID > waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID;
3125 if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */
3126 TRACE(mmsys, "waveOutGetDevCaps\n");
3127 return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
3128 }
3129
3130 /**************************************************************************
3131 * waveOutGetDevCapsA [WINMM.162]
3132 */
3133 UINT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
3134 UINT uSize)
3135 {
3136 WAVEOUTCAPS16 woc16;
3137 UINT16 ret = waveOutGetDevCaps16(uDeviceID, &woc16, sizeof(woc16));
3138
3139 lpCaps->wMid = woc16.wMid;
3140 lpCaps->wPid = woc16.wPid;
3141 lpCaps->vDriverVersion = woc16.vDriverVersion;
3142 strcpy(lpCaps->szPname, woc16.szPname);
3143 lpCaps->dwFormats = woc16.dwFormats;
3144 lpCaps->wChannels = woc16.wChannels;
3145 lpCaps->dwSupport = woc16.dwSupport;
3146 return ret;
3147 }
3148
3149 /**************************************************************************
3150 * waveOutGetDevCapsW [WINMM.163]
3151 */
3152 UINT WINAPI waveOutGetDevCapsW(UINT uDeviceID, LPWAVEOUTCAPSW lpCaps,
3153 UINT uSize)
3154 {
3155 WAVEOUTCAPS16 woc16;
3156 UINT ret = waveOutGetDevCaps16(uDeviceID, &woc16, sizeof(woc16));
3157
3158 lpCaps->wMid = woc16.wMid;
3159 lpCaps->wPid = woc16.wPid;
3160 lpCaps->vDriverVersion = woc16.vDriverVersion;
3161 lstrcpyAtoW(lpCaps->szPname, woc16.szPname);
3162 lpCaps->dwFormats = woc16.dwFormats;
3163 lpCaps->wChannels = woc16.wChannels;
3164 lpCaps->dwSupport = woc16.dwSupport;
3165 return ret;
3166 }
3167
3168 /**************************************************************************
3169 * waveOutGetErrorText [MMSYSTEM.403]
3170 */
3171 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
3172 {
3173 TRACE(mmsys, "waveOutGetErrorText\n");
3174 return(waveGetErrorText(uError, lpText, uSize));
3175 }
3176
3177 /**************************************************************************
3178 * waveOutGetErrorTextA [WINMM.164]
3179 */
3180 UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
3181 {
3182 return(waveOutGetErrorText16(uError, lpText, uSize));
3183 }
3184
3185 /**************************************************************************
3186 * waveOutGetErrorTextW [WINMM.165]
3187 */
3188 UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
3189 {
3190 LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize);
3191 UINT ret = waveOutGetErrorTextA(uError, xstr, uSize);
3192
3193 lstrcpyAtoW(lpText,xstr);
3194 HeapFree(GetProcessHeap(), 0,xstr);
3195 return ret;
3196 }
3197
3198 /**************************************************************************
3199 * waveGetErrorText [internal]
3200 */
3201 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
3202 {
3203 LPSTR msgptr;
3204 TRACE(mmsys, "(%04X, %p, %d);\n",
3205 uError, lpText, uSize);
3206 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
3207 lpText[0] = '\0';
3208 switch (uError) {
3209 case MMSYSERR_NOERROR:
3210 msgptr = "The specified command was carried out.";
3211 break;
3212 case MMSYSERR_ERROR:
3213 msgptr = "Undefined external error.";
3214 break;
3215 case MMSYSERR_BADDEVICEID:
3216 msgptr = "A device ID has been used that is out of range for your system.";
3217 break;
3218 case MMSYSERR_NOTENABLED:
3219 msgptr = "The driver was not enabled.";
3220 break;
3221 case MMSYSERR_ALLOCATED:
3222 msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
3223 break;
3224 case MMSYSERR_INVALHANDLE:
3225 msgptr = "The specified device handle is invalid.";
3226 break;
3227 case MMSYSERR_NODRIVER:
3228 msgptr = "There is no driver installed on your system !\n";
3229 break;
3230 case MMSYSERR_NOMEM:
3231 msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
3232 break;
3233 case MMSYSERR_NOTSUPPORTED:
3234 msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
3235 break;
3236 case MMSYSERR_BADERRNUM:
3237 msgptr = "An error number was specified that is not defined in the system.";
3238 break;
3239 case MMSYSERR_INVALFLAG:
3240 msgptr = "An invalid flag was passed to a system function.";
3241 break;
3242 case MMSYSERR_INVALPARAM:
3243 msgptr = "An invalid parameter was passed to a system function.";
3244 break;
3245 case WAVERR_BADFORMAT:
3246 msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
3247 break;
3248 case WAVERR_STILLPLAYING:
3249 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
3250 break;
3251 case WAVERR_UNPREPARED:
3252 msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
3253 break;
3254 case WAVERR_SYNC:
3255 msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
3256 break;
3257 default:
3258 msgptr = "Unknown MMSYSTEM Error !\n";
3259 break;
3260 }
3261 lstrcpynA(lpText, msgptr, uSize);
3262 return TRUE;
3263 }
3264
3265 /**************************************************************************
3266 * waveOutOpen [WINMM.173]
3267 * All the args/structs have the same layout as the win16 equivalents
3268 */
3269 UINT WINAPI waveOutOpen(HWAVEOUT* lphWaveOut, UINT uDeviceID,
3270 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3271 DWORD dwInstance, DWORD dwFlags)
3272 {
3273 HWAVEOUT16 hwo16;
3274 UINT ret = waveOutOpen16(&hwo16,uDeviceID, lpFormat, dwCallback, dwInstance,
3275 CALLBACK32CONV(dwFlags));
3276
3277 if (lphWaveOut) *lphWaveOut=hwo16;
3278 return ret;
3279 }
3280
3281 /**************************************************************************
3282 * waveOutOpen [MMSYSTEM.404]
3283 */
3284 UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID,
3285 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3286 DWORD dwInstance, DWORD dwFlags)
3287 {
3288 HWAVEOUT16 hWaveOut;
3289 LPWAVEOPENDESC lpDesc;
3290 DWORD dwRet = 0;
3291 BOOL bMapperFlg = FALSE;
3292
3293 TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3294 lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
3295 if (dwFlags & WAVE_FORMAT_QUERY)
3296 TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
3297 if (uDeviceID == (UINT16)WAVE_MAPPER) {
3298 TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
3299 bMapperFlg = TRUE;
3300 uDeviceID = 0;
3301 }
3302 if (lpFormat == NULL) return WAVERR_BADFORMAT;
3303
3304 hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
3305 if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
3306 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3307 if (lpDesc == NULL) return MMSYSERR_NOMEM;
3308 lpDesc->hWave = hWaveOut;
3309 lpDesc->lpFormat = (LPWAVEFORMAT)lpFormat; /* should the struct be copied iso pointer? */
3310 lpDesc->dwCallBack = dwCallback;
3311 lpDesc->dwInstance = dwInstance;
3312 if (uDeviceID >= MAXWAVEDRIVERS)
3313 uDeviceID = 0;
3314 while (uDeviceID < MAXWAVEDRIVERS) {
3315 dwRet = wodMessage(uDeviceID, WODM_OPEN,
3316 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
3317 if (dwRet == MMSYSERR_NOERROR) break;
3318 if (!bMapperFlg) break;
3319 uDeviceID++;
3320 TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
3321 }
3322 lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */
3323 if (dwFlags & WAVE_FORMAT_QUERY) {
3324 TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
3325 dwRet = waveOutClose(hWaveOut);
3326 if (lphWaveOut) *lphWaveOut = 0;
3327 }
3328 else if (dwRet != MMSYSERR_NOERROR)
3329 {
3330 USER_HEAP_FREE(hWaveOut);
3331 if (lphWaveOut) *lphWaveOut = 0;
3332 }
3333 return dwRet;
3334 }
3335
3336 /**************************************************************************
3337 * waveOutClose [WINMM.161]
3338 */
3339 UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
3340 {
3341 return waveOutClose16(hWaveOut);
3342 }
3343
3344 /**************************************************************************
3345 * waveOutClose [MMSYSTEM.405]
3346 */
3347 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
3348 {
3349 LPWAVEOPENDESC lpDesc;
3350 DWORD dwRet;
3351
3352 TRACE(mmsys, "(%04X)\n", hWaveOut);
3353
3354 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3355 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3356 dwRet = wodMessage(lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3357 USER_HEAP_FREE(hWaveOut);
3358 return dwRet;
3359 }
3360
3361 /**************************************************************************
3362 * waveOutPrepareHeader [WINMM.175]
3363 */
3364 UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
3365 WAVEHDR* lpWaveOutHdr, UINT uSize)
3366 {
3367 LPWAVEOPENDESC lpDesc;
3368
3369 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3370
3371 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3372 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3373 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3374 return wodMessage(lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
3375 (DWORD)lpWaveOutHdr,uSize);
3376 }
3377
3378 /**************************************************************************
3379 * waveOutPrepareHeader [MMSYSTEM.406]
3380 */
3381 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,
3382 WAVEHDR* lpWaveOutHdr, UINT16 uSize)
3383 {
3384 LPWAVEOPENDESC lpDesc;
3385 UINT16 ret;
3386
3387 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3388
3389 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3390 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3391 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3392 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3393 ret = wodMessage(lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
3394 (DWORD)lpWaveOutHdr,uSize);
3395 lpWaveOutHdr->lpData = lpWaveOutHdr->lpData;
3396 return ret;
3397 }
3398
3399 /**************************************************************************
3400 * waveOutUnprepareHeader [WINMM.181]
3401 */
3402 UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
3403 WAVEHDR* lpWaveOutHdr, UINT uSize)
3404 {
3405 LPWAVEOPENDESC lpDesc;
3406
3407 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3408
3409 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3410 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3411 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3412 return wodMessage(lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance,
3413 (DWORD)lpWaveOutHdr, uSize);
3414 }
3415
3416 /**************************************************************************
3417 * waveOutUnprepareHeader [MMSYSTEM.407]
3418 */
3419 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,
3420 WAVEHDR* lpWaveOutHdr, UINT16 uSize)
3421 {
3422 LPWAVEOPENDESC lpDesc;
3423 UINT16 ret;
3424
3425 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3426
3427 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3428 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3429 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3430 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3431 ret = wodMessage(lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance,
3432 (DWORD)lpWaveOutHdr, uSize);
3433 lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved;
3434 return ret;
3435 }
3436
3437 /**************************************************************************
3438 * waveOutWrite [MMSYSTEM.408]
3439 */
3440 UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR* lpWaveOutHdr,
3441 UINT uSize)
3442 {
3443 LPWAVEOPENDESC lpDesc;
3444
3445 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3446
3447 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3448 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3449 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3450 return wodMessage(lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
3451 }
3452
3453 /**************************************************************************
3454 * waveOutWrite [MMSYSTEM.408]
3455 */
3456 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
3457 UINT16 uSize)
3458 {
3459 LPWAVEOPENDESC lpDesc;
3460 UINT16 ret;
3461
3462 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3463
3464 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3465 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3466 lpWaveOutHdr->reserved =(DWORD)lpWaveOutHdr->lpData;/*save original ptr*/
3467 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3468 ret = wodMessage(lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
3469 lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved;
3470 return ret;
3471 }
3472
3473 /**************************************************************************
3474 * waveOutPause [WINMM.174]
3475 */
3476 UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
3477 {
3478 return waveOutPause16(hWaveOut);
3479 }
3480
3481 /**************************************************************************
3482 * waveOutPause [MMSYSTEM.409]
3483 */
3484 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut)
3485 {
3486 LPWAVEOPENDESC lpDesc;
3487
3488 TRACE(mmsys, "(%04X)\n", hWaveOut);
3489
3490 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3491 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3492 return wodMessage(lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
3493 }
3494
3495 /**************************************************************************
3496 * waveOutRestart [WINMM.177]
3497 */
3498 UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
3499 {
3500 return waveOutRestart16(hWaveOut);
3501 }
3502
3503 /**************************************************************************
3504 * waveOutRestart [MMSYSTEM.410]
3505 */
3506 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut)
3507 {
3508 LPWAVEOPENDESC lpDesc;
3509
3510 TRACE(mmsys, "(%04X)\n", hWaveOut);
3511
3512 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3513 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3514 return wodMessage(lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
3515 }
3516
3517 /**************************************************************************
3518 * waveOutReset [WINMM.176]
3519 */
3520 UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
3521 {
3522 return waveOutReset16(hWaveOut);
3523 }
3524
3525 /**************************************************************************
3526 * waveOutReset [MMSYSTEM.411]
3527 */
3528 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut)
3529 {
3530 LPWAVEOPENDESC lpDesc;
3531
3532 TRACE(mmsys, "(%04X)\n", hWaveOut);
3533
3534 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3535 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3536 return wodMessage(lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
3537 }
3538
3539 /**************************************************************************
3540 * waveOutGetPosition [WINMM.170]
3541 */
3542 UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
3543 UINT uSize)
3544 {
3545 MMTIME16 mmt16;
3546 UINT ret;
3547
3548 mmt16.wType = lpTime->wType;
3549 ret = waveOutGetPosition16(hWaveOut, &mmt16, sizeof(mmt16));
3550 MMSYSTEM_MMTIME16to32(lpTime, &mmt16);
3551 return ret;
3552 }
3553
3554 /**************************************************************************
3555 * waveOutGetPosition [MMSYSTEM.412]
3556 */
3557 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime,
3558 UINT16 uSize)
3559 {
3560 LPWAVEOPENDESC lpDesc;
3561 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
3562 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3563 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3564 return wodMessage(lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance,
3565 (DWORD)lpTime, (DWORD)uSize);
3566 }
3567
3568 #define WAVEOUT_SHORTCUT_1(xx,XX,atype) \
3569 UINT WINAPI waveOut##xx(HWAVEOUT hWaveOut, atype x) \
3570 { \
3571 return waveOut##xx##16(hWaveOut,x); \
3572 } \
3573 UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \
3574 { \
3575 LPWAVEOPENDESC lpDesc; \
3576 TRACE(mmsys, "(%04X, %08lx);\n", hWaveOut, (DWORD)x); \
3577 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \
3578 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \
3579 return wodMessage(lpDesc->uDeviceID, WODM_##XX, \
3580 lpDesc->dwInstance, (DWORD)x, 0L); \
3581 }
3582
3583 WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH, DWORD*)
3584 WAVEOUT_SHORTCUT_1(SetPitch,SETPITCH, DWORD)
3585 WAVEOUT_SHORTCUT_1(GetPlaybackRate,GETPLAYBACKRATE, DWORD*)
3586 WAVEOUT_SHORTCUT_1(SetPlaybackRate,SETPLAYBACKRATE, DWORD)
3587
3588 #define WAVEOUT_SHORTCUT_2(xx,XX,atype) \
3589 UINT WINAPI waveOut##xx(UINT devid, atype x) \
3590 { \
3591 return waveOut##xx##16(devid,x); \
3592 } \
3593 UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \
3594 { \
3595 TRACE(mmsys, "(%04X, %08lx);\n", devid, (DWORD)x); \
3596 return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \
3597 }
3598
3599 WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME, DWORD*)
3600 WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME, DWORD)
3601
3602 /**************************************************************************
3603 * waveOutBreakLoop [MMSYSTEM.419]
3604 */
3605 UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
3606 {
3607 return waveOutBreakLoop16(hWaveOut);
3608 }
3609
3610 /**************************************************************************
3611 * waveOutBreakLoop [MMSYSTEM.419]
3612 */
3613 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut)
3614 {
3615 TRACE(mmsys, "(%04X)\n", hWaveOut);
3616 return MMSYSERR_INVALHANDLE;
3617 }
3618
3619 /**************************************************************************
3620 * waveOutGetID [MMSYSTEM.420]
3621 */
3622 UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
3623 {
3624 LPWAVEOPENDESC lpDesc;
3625
3626 TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
3627
3628 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3629 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3630 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3631 *lpuDeviceID = lpDesc->uDeviceID;
3632 return 0;
3633 }
3634
3635 /**************************************************************************
3636 * waveOutGetID [MMSYSTEM.420]
3637 */
3638 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID)
3639 {
3640 LPWAVEOPENDESC lpDesc;
3641
3642 TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
3643
3644 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3645 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3646 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
3647 *lpuDeviceID = lpDesc->uDeviceID;
3648 return 0;
3649 }
3650
3651 /**************************************************************************
3652 * waveOutMessage [MMSYSTEM.421]
3653 */
3654 DWORD WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
3655 DWORD dwParam1, DWORD dwParam2)
3656 {
3657 LPWAVEOPENDESC lpDesc;
3658
3659 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3660 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3661 switch (uMessage) {
3662 case WODM_GETNUMDEVS:
3663 case WODM_GETPOS:
3664 case WODM_GETVOLUME:
3665 case WODM_GETPITCH:
3666 case WODM_GETPLAYBACKRATE:
3667 case WODM_SETVOLUME:
3668 case WODM_SETPITCH:
3669 case WODM_SETPLAYBACKRATE:
3670 case WODM_RESET:
3671 case WODM_PAUSE:
3672 case WODM_PREPARE:
3673 case WODM_UNPREPARE:
3674 case WODM_STOP:
3675 case WODM_CLOSE:
3676 /* no argument conversion needed */
3677 break;
3678 case WODM_WRITE:
3679 return waveOutWrite(hWaveOut, (LPWAVEHDR)dwParam1, dwParam2);
3680 case WODM_GETDEVCAPS:
3681 /* FIXME: UNICODE/ANSI? */
3682 return waveOutGetDevCapsA(hWaveOut, (LPWAVEOUTCAPSA)dwParam1, dwParam2);
3683 case WODM_OPEN:
3684 FIXME(mmsys,"can't handle WODM_OPEN, please report.\n");
3685 break;
3686 default:
3687 ERR(mmsys,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n",
3688 hWaveOut,uMessage, dwParam1, dwParam2);
3689 break;
3690 }
3691 return wodMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3692 }
3693
3694 /**************************************************************************
3695 * waveOutMessage [MMSYSTEM.421]
3696 */
3697 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
3698 DWORD dwParam1, DWORD dwParam2)
3699 {
3700 LPWAVEOPENDESC lpDesc;
3701
3702 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3703 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3704 switch (uMessage) {
3705 case WODM_GETNUMDEVS:
3706 case WODM_SETVOLUME:
3707 case WODM_SETPITCH:
3708 case WODM_SETPLAYBACKRATE:
3709 case WODM_RESET:
3710 case WODM_PAUSE:
3711 case WODM_STOP:
3712 case WODM_CLOSE:
3713 /* no argument conversion needed */
3714 break;
3715 case WODM_GETPOS:
3716 return waveOutGetPosition16(hWaveOut, (LPMMTIME16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3717 case WODM_GETVOLUME:
3718 return waveOutGetVolume16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3719 case WODM_GETPITCH:
3720 return waveOutGetPitch16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3721 case WODM_GETPLAYBACKRATE:
3722 return waveOutGetPlaybackRate16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
3723 case WODM_GETDEVCAPS:
3724 return waveOutGetDevCaps16(hWaveOut, (LPWAVEOUTCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3725 case WODM_PREPARE:
3726 return waveOutPrepareHeader16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3727 case WODM_UNPREPARE:
3728 return waveOutUnprepareHeader16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3729 case WODM_WRITE:
3730 return waveOutWrite16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3731 case WODM_OPEN:
3732 FIXME(mmsys,"can't handle WODM_OPEN, please report.\n");
3733 break;
3734 default:
3735 ERR(mmsys,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n",
3736 hWaveOut,uMessage, dwParam1, dwParam2);
3737 }
3738 return wodMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3739 }
3740
3741 /**************************************************************************
3742 * waveInGetNumDevs [WINMM.151]
3743 */
3744 UINT WINAPI waveInGetNumDevs()
3745 {
3746 return waveInGetNumDevs16();
3747 }
3748
3749 /**************************************************************************
3750 * waveInGetNumDevs [MMSYSTEM.501]
3751 */
3752 UINT16 WINAPI waveInGetNumDevs16()
3753 {
3754 UINT16 count = 0;
3755
3756 TRACE(mmsys, "waveInGetNumDevs\n");
3757 count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
3758 TRACE(mmsys, "waveInGetNumDevs return %u \n", count);
3759 return count;
3760 }
3761
3762 /**************************************************************************
3763 * waveInGetDevCapsA [WINMM.147]
3764 */
3765 UINT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
3766 {
3767 WAVEINCAPS16 wic16;
3768 UINT ret = waveInGetDevCaps16(uDeviceID, &wic16,uSize);
3769
3770 lpCaps->wMid = wic16.wMid;
3771 lpCaps->wPid = wic16.wPid;
3772 lpCaps->vDriverVersion = wic16.vDriverVersion;
3773 lstrcpyAtoW(lpCaps->szPname, wic16.szPname);
3774 lpCaps->dwFormats = wic16.dwFormats;
3775 lpCaps->wChannels = wic16.wChannels;
3776
3777 return ret;
3778 }
3779
3780 /**************************************************************************
3781 * waveInGetDevCapsA [WINMM.146]
3782 */
3783 UINT WINAPI waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
3784 {
3785 WAVEINCAPS16 wic16;
3786 UINT ret = waveInGetDevCaps16(uDeviceID, &wic16,uSize);
3787
3788 lpCaps->wMid = wic16.wMid;
3789 lpCaps->wPid = wic16.wPid;
3790 lpCaps->vDriverVersion = wic16.vDriverVersion;
3791 strcpy(lpCaps->szPname, wic16.szPname);
3792 lpCaps->dwFormats = wic16.dwFormats;
3793 lpCaps->wChannels = wic16.wChannels;
3794 return ret;
3795 }
3796
3797 /**************************************************************************
3798 * waveInGetDevCaps [MMSYSTEM.502]
3799 */
3800 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize)
3801 {
3802 TRACE(mmsys, "waveInGetDevCaps\n");
3803
3804 return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
3805 }
3806
3807 /**************************************************************************
3808 * waveInGetErrorTextA [WINMM.148]
3809 */
3810 UINT WINAPI waveInGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
3811 {
3812 TRACE(mmsys, "waveInGetErrorText\n");
3813 return(waveGetErrorText(uError, lpText, uSize));
3814 }
3815
3816 /**************************************************************************
3817 * waveInGetErrorTextW [WINMM.149]
3818 */
3819 UINT WINAPI waveInGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
3820 {
3821 LPSTR txt = HeapAlloc(GetProcessHeap(), 0,uSize);
3822 UINT ret = waveGetErrorText(uError, txt, uSize);
3823
3824 lstrcpyAtoW(lpText, txt);
3825 HeapFree(GetProcessHeap(), 0, txt);
3826 return ret;
3827 }
3828
3829 /**************************************************************************
3830 * waveInGetErrorText [MMSYSTEM.503]
3831 */
3832 UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
3833 {
3834 TRACE(mmsys, "waveInGetErrorText\n");
3835 return(waveGetErrorText(uError, lpText, uSize));
3836 }
3837
3838 /**************************************************************************
3839 * waveInOpen [WINMM.154]
3840 */
3841 UINT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
3842 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
3843 DWORD dwInstance, DWORD dwFlags)
3844 {
3845 HWAVEIN16 hwin16;
3846 UINT ret = waveInOpen16(&hwin16,uDeviceID, lpFormat, dwCallback, dwInstance,
3847 CALLBACK32CONV(dwFlags));
3848 if (lphWaveIn) *lphWaveIn = hwin16;
3849 return ret;
3850 }
3851
3852 /**************************************************************************
3853 * waveInOpen [MMSYSTEM.504]
3854 */
3855 UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
3856 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
3857 DWORD dwInstance, DWORD dwFlags)
3858 {
3859 HWAVEIN16 hWaveIn;
3860 LPWAVEOPENDESC lpDesc;
3861 DWORD dwRet = 0;
3862 BOOL bMapperFlg = FALSE;
3863
3864 TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3865 lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
3866 if (dwFlags & WAVE_FORMAT_QUERY)
3867 TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
3868 if (uDeviceID == (UINT16)WAVE_MAPPER) {
3869 TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
3870 bMapperFlg = TRUE;
3871 uDeviceID = 0;
3872 }
3873 if (lpFormat == NULL) return WAVERR_BADFORMAT;
3874 hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
3875 if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
3876 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3877 if (lpDesc == NULL) return MMSYSERR_NOMEM;
3878 lpDesc->hWave = hWaveIn;
3879 lpDesc->lpFormat = lpFormat;
3880 lpDesc->dwCallBack = dwCallback;
3881 lpDesc->dwInstance = dwInstance;
3882 while (uDeviceID < MAXWAVEDRIVERS) {
3883 dwRet = widMessage(uDeviceID, WIDM_OPEN,
3884 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
3885 if (dwRet == MMSYSERR_NOERROR) break;
3886 if (!bMapperFlg) break;
3887 uDeviceID++;
3888 TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
3889 }
3890 lpDesc->uDeviceID = uDeviceID;
3891 if (dwFlags & WAVE_FORMAT_QUERY) {
3892 TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
3893 dwRet = waveInClose16(hWaveIn);
3894 }
3895 else if (dwRet != MMSYSERR_NOERROR) {
3896 USER_HEAP_FREE(hWaveIn);
3897 if (lphWaveIn) *lphWaveIn = 0;
3898 }
3899
3900 return dwRet;
3901 }
3902
3903 /**************************************************************************
3904 * waveInClose [WINMM.145]
3905 */
3906 UINT WINAPI waveInClose(HWAVEIN hWaveIn)
3907 {
3908 return waveInClose16(hWaveIn);
3909 }
3910
3911 /**************************************************************************
3912 * waveInClose [MMSYSTEM.505]
3913 */
3914 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
3915 {
3916 LPWAVEOPENDESC lpDesc;
3917 DWORD dwRet;
3918
3919 TRACE(mmsys, "(%04X)\n", hWaveIn);
3920 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3921 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3922 dwRet = widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3923 USER_HEAP_FREE(hWaveIn);
3924 return dwRet;
3925 }
3926
3927 /**************************************************************************
3928 * waveInPrepareHeader [WINMM.155]
3929 */
3930 UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn,
3931 WAVEHDR* lpWaveInHdr, UINT uSize)
3932 {
3933 LPWAVEOPENDESC lpDesc;
3934
3935 TRACE(mmsys, "(%04X, %p, %u);\n",
3936 hWaveIn, lpWaveInHdr, uSize);
3937 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3938 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3939 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3940 lpWaveInHdr = lpWaveInHdr;
3941 lpWaveInHdr->lpNext = NULL;
3942 lpWaveInHdr->dwBytesRecorded = 0;
3943 TRACE(mmsys, "lpData=%p size=%lu \n",
3944 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3945 return widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance,
3946 (DWORD)lpWaveInHdr, uSize);
3947 }
3948
3949 /**************************************************************************
3950 * waveInPrepareHeader [MMSYSTEM.506]
3951 */
3952 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,
3953 WAVEHDR* lpWaveInHdr, UINT16 uSize)
3954 {
3955 LPWAVEOPENDESC lpDesc;
3956 LPBYTE saveddata = lpWaveInHdr->lpData;
3957 UINT16 ret;
3958
3959 TRACE(mmsys, "(%04X, %p, %u);\n",
3960 hWaveIn, lpWaveInHdr, uSize);
3961 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3962 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3963 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3964 lpWaveInHdr = lpWaveInHdr;
3965 lpWaveInHdr->lpNext = NULL;
3966 lpWaveInHdr->dwBytesRecorded = 0;
3967
3968 TRACE(mmsys, "lpData=%p size=%lu \n",
3969 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
3970 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
3971 ret = widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance,
3972 (DWORD)lpWaveInHdr,uSize);
3973 lpWaveInHdr->lpData = saveddata;
3974 return ret;
3975 }
3976
3977 /**************************************************************************
3978 * waveInUnprepareHeader [WINMM.159]
3979 */
3980 UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn,
3981 WAVEHDR* lpWaveInHdr, UINT uSize)
3982 {
3983 LPWAVEOPENDESC lpDesc;
3984
3985 TRACE(mmsys, "(%04X, %p, %u);\n",
3986 hWaveIn, lpWaveInHdr, uSize);
3987 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
3988 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3989 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
3990 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
3991 lpWaveInHdr->lpData = NULL;
3992 lpWaveInHdr->lpNext = NULL;
3993 return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance,
3994 (DWORD)lpWaveInHdr, uSize);
3995 }
3996
3997 /**************************************************************************
3998 * waveInUnprepareHeader [MMSYSTEM.507]
3999 */
4000 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,
4001 WAVEHDR* lpWaveInHdr, UINT16 uSize)
4002 {
4003 LPWAVEOPENDESC lpDesc;
4004
4005 TRACE(mmsys, "(%04X, %p, %u);\n",
4006 hWaveIn, lpWaveInHdr, uSize);
4007 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4008 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4009 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4010 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
4011 lpWaveInHdr->lpData = NULL;
4012 lpWaveInHdr->lpNext = NULL;
4013 return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance,
4014 (DWORD)lpWaveInHdr, uSize);
4015 }
4016
4017 /**************************************************************************
4018 * waveInAddBuffer [WINMM.144]
4019 */
4020 UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
4021 WAVEHDR* lpWaveInHdr, UINT uSize)
4022 {
4023 LPWAVEOPENDESC lpDesc;
4024
4025 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4026 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4027 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4028 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4029 lpWaveInHdr->lpNext = NULL;
4030 lpWaveInHdr->dwBytesRecorded = 0;
4031 TRACE(mmsys, "lpData=%p size=%lu \n",
4032 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4033 return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
4034 (DWORD)lpWaveInHdr, uSize);
4035
4036 }
4037
4038 /**************************************************************************
4039 * waveInAddBuffer [MMSYSTEM.508]
4040 */
4041 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,
4042 WAVEHDR* lpWaveInHdr, UINT16 uSize)
4043 {
4044 LPWAVEOPENDESC lpDesc;
4045 UINT16 ret;
4046
4047 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4048 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4049 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4050 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4051 lpWaveInHdr->lpNext = NULL;
4052 lpWaveInHdr->dwBytesRecorded = 0;
4053 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
4054 TRACE(mmsys, "lpData=%p size=%lu \n",
4055 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4056 ret = widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
4057 (DWORD)lpWaveInHdr, uSize);
4058 /*lpWaveInHdr->lpData = saveddata;*/
4059 return ret;
4060 }
4061
4062 /**************************************************************************
4063 * waveInStart [WINMM.157]
4064 */
4065 UINT WINAPI waveInStart(HWAVEIN hWaveIn)
4066 {
4067 return waveInStart16(hWaveIn);
4068 }
4069
4070 /**************************************************************************
4071 * waveInStart [MMSYSTEM.509]
4072 */
4073 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn)
4074 {
4075 LPWAVEOPENDESC lpDesc;
4076
4077 TRACE(mmsys, "(%04X)\n", hWaveIn);
4078 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4079 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4080 return widMessage(lpDesc->uDeviceID, WIDM_START, lpDesc->dwInstance, 0, 0);
4081 }
4082
4083 /**************************************************************************
4084 * waveInStop [WINMM.158]
4085 */
4086 UINT WINAPI waveInStop(HWAVEIN hWaveIn)
4087 {
4088 return waveInStop16(hWaveIn);
4089 }
4090
4091 /**************************************************************************
4092 * waveInStop [MMSYSTEM.510]
4093 */
4094 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn)
4095 {
4096 LPWAVEOPENDESC lpDesc;
4097
4098 TRACE(mmsys, "(%04X)\n", hWaveIn);
4099 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4100 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4101 return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
4102 }
4103
4104 /**************************************************************************
4105 * waveInReset [WINMM.156]
4106 */
4107 UINT WINAPI waveInReset(HWAVEIN hWaveIn)
4108 {
4109 return waveInReset16(hWaveIn);
4110 }
4111
4112 /**************************************************************************
4113 * waveInReset [MMSYSTEM.511]
4114 */
4115 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn)
4116 {
4117 LPWAVEOPENDESC lpDesc;
4118
4119 TRACE(mmsys, "(%04X)\n", hWaveIn);
4120 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4121 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4122 return widMessage(lpDesc->uDeviceID, WIDM_RESET, lpDesc->dwInstance, 0, 0);
4123 }
4124
4125 /**************************************************************************
4126 * waveInGetPosition [WINMM.152]
4127 */
4128 UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
4129 UINT uSize)
4130 {
4131 MMTIME16 mmt16;
4132 UINT ret;
4133
4134 mmt16.wType = lpTime->wType;
4135 ret = waveInGetPosition16(hWaveIn, &mmt16,uSize);
4136
4137 MMSYSTEM_MMTIME16to32(lpTime, &mmt16);
4138 return ret;
4139 }
4140
4141 /**************************************************************************
4142 * waveInGetPosition [MMSYSTEM.512]
4143 */
4144 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime,
4145 UINT16 uSize)
4146 {
4147 LPWAVEOPENDESC lpDesc;
4148
4149 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
4150 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4151 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4152 return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance,
4153 (DWORD)lpTime, (DWORD)uSize);
4154 }
4155
4156 /**************************************************************************
4157 * waveInGetID [WINMM.150]
4158 */
4159 UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
4160 {
4161 LPWAVEOPENDESC lpDesc;
4162
4163 TRACE(mmsys, "waveInGetID\n");
4164 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4165 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4166 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4167 *lpuDeviceID = lpDesc->uDeviceID;
4168 return 0;
4169 }
4170
4171 /**************************************************************************
4172 * waveInGetID [MMSYSTEM.513]
4173 */
4174 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID)
4175 {
4176 LPWAVEOPENDESC lpDesc;
4177
4178 TRACE(mmsys, "waveInGetID\n");
4179 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4180 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4181 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4182 *lpuDeviceID = lpDesc->uDeviceID;
4183 return 0;
4184 }
4185
4186 /**************************************************************************
4187 * waveInMessage [WINMM.153]
4188 */
4189 DWORD WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
4190 DWORD dwParam1, DWORD dwParam2)
4191 {
4192 LPWAVEOPENDESC lpDesc;
4193
4194 FIXME(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
4195 hWaveIn, uMessage, dwParam1, dwParam2);
4196 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4197 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4198 switch (uMessage) {
4199 case WIDM_OPEN:
4200 FIXME(mmsys, "cannot handle WIDM_OPEN, please report.\n");
4201 break;
4202 case WIDM_GETNUMDEVS:
4203 case WIDM_GETPOS:
4204 case WIDM_CLOSE:
4205 case WIDM_STOP:
4206 case WIDM_RESET:
4207 case WIDM_START:
4208 case WIDM_PREPARE:
4209 case WIDM_UNPREPARE:
4210 case WIDM_ADDBUFFER:
4211 case WIDM_PAUSE:
4212 /* no argument conversion needed */
4213 break;
4214 case WIDM_GETDEVCAPS:
4215 /*FIXME: ANSI/UNICODE */
4216 return waveInGetDevCapsA(hWaveIn, (LPWAVEINCAPSA)dwParam1, dwParam2);
4217 default:
4218 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4219 hWaveIn,uMessage, dwParam1, dwParam2);
4220 break;
4221 }
4222 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4223 }
4224
4225 /**************************************************************************
4226 * waveInMessage [MMSYSTEM.514]
4227 */
4228 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
4229 DWORD dwParam1, DWORD dwParam2)
4230 {
4231 LPWAVEOPENDESC lpDesc;
4232
4233 FIXME(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
4234 hWaveIn, uMessage, dwParam1, dwParam2);
4235 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4236 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4237 switch (uMessage) {
4238 case WIDM_OPEN:
4239 FIXME(mmsys,"cannot handle WIDM_OPEN, please report.\n");
4240 break;
4241 case WIDM_GETNUMDEVS:
4242 case WIDM_CLOSE:
4243 case WIDM_STOP:
4244 case WIDM_RESET:
4245 case WIDM_START:
4246 case WIDM_PAUSE:
4247 /* no argument conversion needed */
4248 break;
4249 case WIDM_GETDEVCAPS:
4250 return waveInGetDevCaps16(hWaveIn, (LPWAVEINCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4251 case WIDM_GETPOS:
4252 return waveInGetPosition16(hWaveIn, (LPMMTIME16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4253 case WIDM_PREPARE:
4254 return waveInPrepareHeader16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4255 case WIDM_UNPREPARE:
4256 return waveInUnprepareHeader16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4257 case WIDM_ADDBUFFER:
4258 return waveInAddBuffer16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4259 default:
4260 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4261 hWaveIn,uMessage, dwParam1, dwParam2);
4262 break;
4263 }
4264 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4265 }
4266
4267 /**************************************************************************
4268 * DrvOpen [MMSYSTEM.1100]
4269 */
4270 HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
4271 {
4272 TRACE(mmsys,"('%s','%s',%08lX);\n", lpDriverName, lpSectionName, lParam);
4273
4274 return OpenDriver16(lpDriverName, lpSectionName, lParam);
4275 }
4276
4277 /**************************************************************************
4278 * DrvClose [MMSYSTEM.1101]
4279 */
4280 LRESULT WINAPI DrvClose(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
4281 {
4282 TRACE(mmsys, "(%04X, %08lX, %08lX);\n", hDrv, lParam1, lParam2);
4283
4284 return CloseDriver16(hDrv, lParam1, lParam2);
4285 }
4286
4287 /**************************************************************************
4288 * DrvSendMessage [MMSYSTEM.1102]
4289 */
4290 LRESULT WINAPI DrvSendMessage(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
4291 LPARAM lParam2)
4292 {
4293 /* DWORD dwDriverID = 0; */
4294
4295 FIXME(mmsys, "(%04X, %04X, %08lX, %08lX);\n", hDrv, msg, lParam1, lParam2);
4296 return MMSYSERR_NOTENABLED;
4297 /* FIXME: wrong ... */
4298 /* should known the mapping between hDrv and wDevIDs */
4299 /* MCICDAUDIO_DriverProc16(dwDriverID, hDrv, msg, lParam1, lParam2); */
4300 }
4301
4302 /**************************************************************************
4303 * DrvGetModuleHandle [MMSYSTEM.1103]
4304 */
4305 HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
4306 {
4307 return GetDriverModuleHandle16(hDrv);
4308 }
4309
4310 /**************************************************************************
4311 * DrvDefDriverProc [MMSYSTEM.1104]
4312 */
4313 LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
4314 DWORD dwParam1, DWORD dwParam2)
4315 {
4316 /* FIXME : any mapping from 32 to 16 bit structure ? */
4317 return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
4318 }
4319
4320 /**************************************************************************
4321 * DefDriverProc [WINMM.5]
4322 */
4323 LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
4324 UINT Msg, LPARAM lParam1, LPARAM lParam2)
4325 {
4326 switch (Msg) {
4327 case DRV_LOAD:
4328 case DRV_FREE:
4329 case DRV_ENABLE:
4330 case DRV_DISABLE:
4331 return 1;
4332 case DRV_INSTALL:
4333 case DRV_REMOVE:
4334 return DRV_SUCCESS;
4335 default:
4336 return 0;
4337 }
4338 }
4339
4340 /**************************************************************************
4341 * mmThreadCreate [MMSYSTEM.1120]
4342 */
4343 LRESULT WINAPI mmThreadCreate16(LPVOID x1, LPWORD x2, DWORD x3, DWORD x4)
4344 {
4345 FIXME(mmsys, "(%p,%p,%08lx,%08lx): stub!\n",x1,x2,x3,x4);
4346 *x2 = 0xbabe;
4347 return 0;
4348 }
4349
4350 /**************************************************************************
4351 * mmThreadSignal [MMSYSTEM.1121]
4352 */
4353 LRESULT WINAPI mmThreadSignal16(HANDLE16 hnd)
4354 {
4355 FIXME(mmsys,"(%04x): stub!\n", hnd);
4356 return 0;
4357 }
4358
4359 /**************************************************************************
4360 * mmThreadBlock [MMSYSTEM.1122]
4361 */
4362 void WINAPI mmThreadBlock16(HANDLE16 hnd)
4363 {
4364 FIXME(mmsys,"(%04x): stub!\n", hnd);
4365 }
4366
4367 /**************************************************************************
4368 * mmThreadIsCurrent [MMSYSTEM.1123]
4369 */
4370 BOOL16 WINAPI mmThreadIsCurrent16(HANDLE16 hnd)
4371 {
4372 FIXME(mmsys,"(%04x): stub!\n", hnd);
4373 return FALSE;
4374 }
4375
4376 /**************************************************************************
4377 * mmThreadGetTask [MMSYSTEM.1125]
4378 */
4379 LRESULT WINAPI mmThreadGetTask16(HANDLE16 hnd)
4380 {
4381 FIXME(mmsys,"(%04x): stub!\n", hnd);
4382 return GetCurrentTask();
4383 }
4384
4385 /**************************************************************************
4386 * mmThreadIsValid [MMSYSTEM.1124]
4387 */
4388 BOOL16 WINAPI mmThreadIsValid16(HANDLE16 handle)
4389 {
4390 FIXME(mmsys, "(%04x): stub!\n", handle);
4391 return 0;
4392 }
4393
4394 /**************************************************************************
4395 * mmTaskCreate [MMSYSTEM.900]
4396 *
4397 * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be
4398 * called upon creation with dwPmt as parameter.
4399 */
4400 HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR lphnd, HINSTANCE16 *hMmTask, DWORD dwPmt)
4401 {
4402 DWORD showCmd = 0x40002;
4403 LPSTR cmdline;
4404 WORD sel1, sel2;
4405 LOADPARAMS16* lp;
4406 HINSTANCE16 ret;
4407 HINSTANCE16 handle;
4408
4409 TRACE(mmsys, "(%08lx,%p,%08lx);\n", lphnd, hMmTask, dwPmt);
4410 cmdline = (LPSTR)HeapAlloc(GetProcessHeap(), 0, 0x0d);
4411 cmdline[0] = 0x0d;
4412 *(LPDWORD)(cmdline + 1) = (DWORD)lphnd;
4413 *(LPDWORD)(cmdline + 5) = dwPmt;
4414 *(LPDWORD)(cmdline + 9) = 0;
4415
4416 sel1 = SELECTOR_AllocBlock(cmdline, 0x0d, SEGMENT_DATA, FALSE, FALSE);
4417 sel2 = SELECTOR_AllocBlock(&showCmd, sizeof(showCmd),
4418 SEGMENT_DATA, FALSE, FALSE);
4419
4420 lp = (LOADPARAMS16 *)HeapAlloc(GetProcessHeap(), 0, sizeof(LOADPARAMS16));
4421 lp->hEnvironment = 0;
4422 lp->cmdLine = PTR_SEG_OFF_TO_SEGPTR(sel1, 0);
4423 lp->showCmd = PTR_SEG_OFF_TO_SEGPTR(sel2, 0);
4424 lp->reserved = 0;
4425
4426 handle = LoadModule16("c:\\windows\\system\\mmtask.tsk", lp);
4427 if (handle < 32) {
4428 ret = (handle) ? 1 : 2;
4429 handle = 0;
4430 } else {
4431 ret = 0;
4432 }
4433 if (hMmTask)
4434 *hMmTask = handle;
4435
4436 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel2, 0));
4437 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel1, 0));
4438
4439 HeapFree(GetProcessHeap(), 0, lp);
4440 HeapFree(GetProcessHeap(), 0, cmdline);
4441
4442 TRACE(mmsys, "=> 0x%04x/%d\n", handle, ret);
4443 return ret;
4444 }
4445
4446 /**************************************************************************
4447 * mmTaskBlock [MMSYSTEM.902]
4448 */
4449 void WINAPI mmTaskBlock16(HINSTANCE16 WINE_UNUSED hInst)
4450 {
4451 MSG msg;
4452
4453 do {
4454 GetMessageA(&msg, 0, 0, 0);
4455 if (msg.hwnd) {
4456 TranslateMessage(&msg);
4457 DispatchMessageA(&msg);
4458 }
4459 } while (msg.message < 0x3A0);
4460 }
4461
4462 /**************************************************************************
4463 * mmTaskSignal [MMSYSTEM.903]
4464 */
4465 LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
4466 {
4467 TRACE(mmsys,"(%04x);\n", ht);
4468 return PostAppMessageA(ht, WM_USER, 0, 0);
4469 }
4470
4471 /**************************************************************************
4472 * mmTaskYield16 [MMSYSTEM.905]
4473 */
4474 void WINAPI mmTaskYield16(void)
4475 {
4476 MSG msg;
4477
4478 if (PeekMessageA(&msg, 0, 0, 0, 0)) {
4479 Yield16();
4480 }
4481 }
4482
4483 /**************************************************************************
4484 * mmShowMMCPLPropertySheet [MMSYSTEM.1150]
4485 */
4486 BOOL16 WINAPI mmShowMMCPLPropertySheet16(WORD w1, WORD w2, WORD w3, WORD w4, WORD w5, WORD w6, WORD w7)
4487 {
4488 FIXME(mmsys, "%04x %04x %04x %04x %04x %04x %04x\n", w1, w2, w3, w4, w5, w6, w7);
4489 return TRUE;
4490 }
4491
4492 /**************************************************************************
4493 * StackEnter & StackLeave [MMSYSTEM.32][MMSYSTEM.33]
4494 */
4495 void WINAPI StackEnterLeave16(void)
4496 {
4497 #ifdef __i386__
4498 /* mmsystem.dll from Win 95 does only this: so does Wine */
4499 __asm__("stc");
4500 #endif
4501 }
Quick hack tree for wine patches julliard doesn't want to commit