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