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