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