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