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