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