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