?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added support for MCI AVI driver
[wine/testsucceed.git] / multimedia / mmsystem.c
blob4e2ad2fa61a86ccf59573c5569dae4a4fcfa3ab2
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 support for Win32 MCI
12 */
13
14 /* FIXME: I think there are some segmented vs. linear pointer weirdnesses
15 * and long term pointers to 16 bit space in here
16 */
17
18 #include <unistd.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <fcntl.h>
22 #include <errno.h>
23 #include <sys/ioctl.h>
24 #include "wine/winuser16.h"
25 #include "win.h"
26 #include "heap.h"
27 #include "ldt.h"
28 #include "user.h"
29 #include "driver.h"
30 #include "file.h"
31 #include "mmsystem.h"
32 #include "multimedia.h"
33 #include "xmalloc.h"
34 #include "callback.h"
35 #include "module.h"
36 #include "selectors.h"
37 #include "debug.h"
38
39 int mciInstalledCount;
40 int mciInstalledListLen;
41 LPSTR lpmciInstallNames = NULL;
42
43 struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
44
45 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
46 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
47 LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
48 DWORD dwParam1, DWORD dwParam2);
49
50 #define MCI_GetDrv(wDevID) (&mciDrv[MCI_DevIDToIndex(wDevID)])
51 #define MCI_GetOpenDrv(wDevID) (&(MCI_GetDrv(wDevID)->mop))
52
53 /* The wDevID's returned by wine were originally in the range
54 * 0 - (MAXMCIDRIVERS - 1) and used directly as array indices.
55 * Unfortunately, ms-windows uses wDevID of zero to indicate
56 * errors. Now, multimedia drivers must pass the wDevID through
57 * MCI_DevIDToIndex to get an index in that range. An
58 * arbitrary value, MCI_MAGIC is added to the wDevID seen
59 * by the windows programs.
60 */
61
62 #define MCI_MAGIC 0x0F00
63
64 /**************************************************************************
65 * MCI_GetProc32 [internal]
66 */
67 MCIPROC32 MCI_GetProc32(UINT16 uDevType)
68 {
69 MCIPROC32 proc = 0;
70
71 switch (uDevType) {
72 case MCI_DEVTYPE_CD_AUDIO: proc = MCICDAUDIO_DriverProc32; break;
73 case MCI_DEVTYPE_WAVEFORM_AUDIO: proc = MCIWAVE_DriverProc32; break;
74 case MCI_DEVTYPE_SEQUENCER: proc = MCIMIDI_DriverProc32; break;
75 case MCI_DEVTYPE_ANIMATION: proc = MCIANIM_DriverProc32; break;
76 case MCI_DEVTYPE_DIGITAL_VIDEO: proc = MCIAVI_DriverProc32; break;
77 default: TRACE(mci, "Unknown device type %u\n", uDevType);
78 }
79 return proc;
80 }
81
82 /**************************************************************************
83 * MCI_GetDevType [internal]
84 */
85 WORD MCI_GetDevType(LPCSTR str)
86 {
87 WORD uDevTyp = 0;
88
89 if (lstrcmpi32A(str, "CDAUDIO") == 0) {
90 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
91 } else if (lstrcmpi32A(str, "WAVEAUDIO") == 0) {
92 uDevTyp = MCI_DEVTYPE_WAVEFORM_AUDIO;
93 } else if (lstrcmpi32A(str, "SEQUENCER") == 0) {
94 uDevTyp = MCI_DEVTYPE_SEQUENCER;
95 } else if (lstrcmpi32A(str, "ANIMATION1") == 0) {
96 uDevTyp = MCI_DEVTYPE_ANIMATION;
97 } else if (lstrcmpi32A(str, "AVIVIDEO") == 0) {
98 uDevTyp = MCI_DEVTYPE_DIGITAL_VIDEO;
99 }
100 TRACE(mci, "str = %s => %u\n", str, uDevTyp);
101 return uDevTyp;
102 }
103
104 /**************************************************************************
105 * MCI_GetDevTypeString [internal]
106 */
107 static LPCSTR MCI_GetDevTypeString(WORD uDevTyp)
108 {
109 LPCSTR str = "??? MCI ???";
110
111 switch (uDevTyp) {
112 case MCI_DEVTYPE_CD_AUDIO: str = "CDAUDIO"; break;
113 case MCI_DEVTYPE_WAVEFORM_AUDIO: str = "WAVEAUDIO"; break;
114 case MCI_DEVTYPE_SEQUENCER: str = "SEQUENCER"; break;
115 case MCI_DEVTYPE_ANIMATION: str = "ANIMATION1"; break;
116 case MCI_DEVTYPE_DIGITAL_VIDEO: str = "AVIVIDEO"; break;
117 default: FIXME(mci, "Incohenrent MCI definitions\n");
118 }
119 TRACE(mci, "devType=%u => %s\n", uDevTyp, str);
120 return str;
121 }
122
123 /**************************************************************************
124 * MCI_DevIDToIndex [internal]
125 */
126 int MCI_DevIDToIndex(UINT16 wDevID)
127 {
128 return wDevID - MCI_MAGIC;
129 }
130
131 /**************************************************************************
132 * MCI_FirstDevId [internal]
133 */
134 UINT16 MCI_FirstDevID(void)
135 {
136 return MCI_MAGIC;
137 }
138
139 /**************************************************************************
140 * MCI_NextDevId [internal]
141 */
142 UINT16 MCI_NextDevID(UINT16 wDevID)
143 {
144 return wDevID + 1;
145 }
146
147 /**************************************************************************
148 * MCI_DevIDValid [internal]
149 */
150 BOOL32 MCI_DevIDValid(UINT16 wDevID)
151 {
152 return wDevID >= MCI_MAGIC && wDevID < (MCI_MAGIC + MAXMCIDRIVERS);
153 }
154
155 /**************************************************************************
156 * MMSYSTEM_WEP [MMSYSTEM.1]
157 */
158 int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
159 WORD cbHeapSize, LPSTR lpCmdLine)
160 {
161 FIXME(mmsys, "STUB: Unloading MMSystem DLL ... hInst=%04X \n", hInstance);
162 return(TRUE);
163 }
164
165 static void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, LPMMTIME32 mmt32)
166 {
167 mmt16->wType = mmt32->wType;
168 /* layout of rest is the same for 32/16 */
169 memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u));
170 }
171
172 static void MMSYSTEM_MMTIME16to32(LPMMTIME32 mmt32, LPMMTIME16 mmt16)
173 {
174 mmt32->wType = mmt16->wType;
175 /* layout of rest is the same for 32/16,
176 * Note: mmt16->u is 2 bytes smaller than mmt32->u
177 */
178 memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u));
179 }
180
181 static HANDLE32 PlaySound_hThread = 0;
182 static HANDLE32 PlaySound_hPlayEvent = 0;
183 static HANDLE32 PlaySound_hReadyEvent = 0;
184 static HANDLE32 PlaySound_hMiddleEvent = 0;
185 static BOOL32 PlaySound_Result = FALSE;
186 static int PlaySound_Stop = FALSE;
187 static int PlaySound_Playing = FALSE;
188
189 static LPCSTR PlaySound_pszSound = NULL;
190 static HMODULE32 PlaySound_hmod = 0;
191 static DWORD PlaySound_fdwSound = 0;
192 static int PlaySound_Loop = FALSE;
193 static int PlaySound_SearchMode = 0; /* 1 - sndPlaySound search order
194 2 - PlaySound order */
195
196 static HMMIO16 get_mmioFromFile(LPCSTR lpszName)
197 {
198 return mmioOpen16((LPSTR)lpszName, NULL,
199 MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
200 }
201
202 static HMMIO16 get_mmioFromProfile(UINT32 uFlags, LPCSTR lpszName)
203 {
204 char str[128];
205 LPSTR ptr;
206 HMMIO16 hmmio;
207
208 TRACE(mmsys, "searching in SystemSound List !\n");
209 GetProfileString32A("Sounds", (LPSTR)lpszName, "", str, sizeof(str));
210 if (strlen(str) == 0) {
211 if (uFlags & SND_NODEFAULT) return 0;
212 GetProfileString32A("Sounds", "Default", "", str, sizeof(str));
213 if (strlen(str) == 0) return 0;
214 }
215 if ((ptr = (LPSTR)strchr(str, ',')) != NULL) *ptr = '\0';
216 hmmio = get_mmioFromFile(str);
217 if (hmmio == 0) {
218 WARN(mmsys, "can't find SystemSound='%s' !\n", str);
219 return 0;
220 }
221 return hmmio;
222 }
223
224 static BOOL16 WINAPI proc_PlaySound(LPCSTR lpszSoundName, UINT32 uFlags)
225 {
226 BOOL16 bRet = FALSE;
227 HMMIO16 hmmio;
228 MMCKINFO ckMainRIFF;
229
230 TRACE(mmsys, "SoundName='%s' uFlags=%04X !\n", lpszSoundName, uFlags);
231 if (lpszSoundName == NULL) {
232 TRACE(mmsys, "Stop !\n");
233 return FALSE;
234 }
235 if (uFlags & SND_MEMORY) {
236 MMIOINFO16 mminfo;
237 memset(&mminfo, 0, sizeof(mminfo));
238 mminfo.fccIOProc = FOURCC_MEM;
239 mminfo.pchBuffer = (LPSTR)lpszSoundName;
240 mminfo.cchBuffer = -1;
241 TRACE(mmsys, "Memory sound %p\n", lpszSoundName);
242 hmmio = mmioOpen16(NULL, &mminfo, MMIO_READ);
243 } else {
244 hmmio = 0;
245 if (uFlags & SND_ALIAS)
246 if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0)
247 return FALSE;
248
249 if (uFlags & SND_FILENAME)
250 if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0) return FALSE;
251
252 if (PlaySound_SearchMode == 1) {
253 PlaySound_SearchMode = 0;
254 if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0)
255 if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0)
256 return FALSE;
257 }
258
259 if (PlaySound_SearchMode == 2) {
260 PlaySound_SearchMode = 0;
261 if ((hmmio=get_mmioFromProfile(uFlags | SND_NODEFAULT, lpszSoundName)) == 0)
262 if ((hmmio=get_mmioFromFile(lpszSoundName)) == 0)
263 if ((hmmio=get_mmioFromProfile(uFlags, lpszSoundName)) == 0) return FALSE;
264 }
265 }
266
267 if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0) == 0)
268 do {
269 TRACE(mmsys, "ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
270 (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
271 ckMainRIFF.cksize);
272
273 if ((ckMainRIFF.ckid == FOURCC_RIFF) &&
274 (ckMainRIFF.fccType == mmioFOURCC('W', 'A', 'V', 'E'))) {
275 MMCKINFO mmckInfo;
276
277 mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
278
279 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
280 PCMWAVEFORMAT pcmWaveFormat;
281
282 TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
283 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
284
285 if (mmioRead32(hmmio, (HPSTR)&pcmWaveFormat,
286 (long) sizeof(PCMWAVEFORMAT)) == (long) sizeof(PCMWAVEFORMAT)) {
287 TRACE(mmsys, "wFormatTag=%04X !\n", pcmWaveFormat.wf.wFormatTag);
288 TRACE(mmsys, "nChannels=%d \n", pcmWaveFormat.wf.nChannels);
289 TRACE(mmsys, "nSamplesPerSec=%ld\n", pcmWaveFormat.wf.nSamplesPerSec);
290 TRACE(mmsys, "nAvgBytesPerSec=%ld\n", pcmWaveFormat.wf.nAvgBytesPerSec);
291 TRACE(mmsys, "nBlockAlign=%d \n", pcmWaveFormat.wf.nBlockAlign);
292 TRACE(mmsys, "wBitsPerSample=%u !\n", pcmWaveFormat.wBitsPerSample);
293
294 mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
295 if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) == 0) {
296 WAVEOPENDESC waveDesc;
297 DWORD dwRet;
298
299 TRACE(mmsys, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
300 (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
301
302 pcmWaveFormat.wf.nAvgBytesPerSec = pcmWaveFormat.wf.nSamplesPerSec *
303 pcmWaveFormat.wf.nBlockAlign;
304 waveDesc.hWave = 0;
305 waveDesc.lpFormat = (LPWAVEFORMAT)&pcmWaveFormat;
306
307 dwRet = wodMessage(0, WODM_OPEN, 0, (DWORD)&waveDesc, CALLBACK_NULL);
308 if (dwRet == MMSYSERR_NOERROR) {
309 WAVEHDR waveHdr;
310 HGLOBAL16 hData;
311 INT32 count, bufsize, left = mmckInfo.cksize;
312
313 bufsize = 64000;
314 hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
315 waveHdr.lpData = (LPSTR)GlobalLock16(hData);
316 waveHdr.dwBufferLength = bufsize;
317 waveHdr.dwUser = 0L;
318 waveHdr.dwFlags = 0L;
319 waveHdr.dwLoops = 0L;
320
321 dwRet = wodMessage(0, WODM_PREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
322 if (dwRet == MMSYSERR_NOERROR) {
323 while (left) {
324 if (PlaySound_Stop) {
325 PlaySound_Stop = FALSE;
326 PlaySound_Loop = FALSE;
327 break;
328 }
329 if (bufsize > left) bufsize = left;
330 count = mmioRead32(hmmio, waveHdr.lpData,bufsize);
331 if (count < 1) break;
332 left -= count;
333 waveHdr.dwBufferLength = count;
334 /* waveHdr.dwBytesRecorded = count; */
335 /* FIXME: doesn't expect async ops */
336 wodMessage(0, WODM_WRITE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
337 }
338 wodMessage(0, WODM_UNPREPARE, 0, (DWORD)&waveHdr, sizeof(WAVEHDR));
339 wodMessage(0, WODM_CLOSE, 0, 0L, 0L);
340
341 bRet = TRUE;
342 } else
343 WARN(mmsys, "can't prepare WaveOut device !\n");
344
345 GlobalUnlock16(hData);
346 GlobalFree16(hData);
347 }
348 }
349 }
350 }
351 }
352 } while (PlaySound_Loop);
353
354 if (hmmio != 0) mmioClose32(hmmio, 0);
355 return bRet;
356 }
357
358 static DWORD WINAPI PlaySound_Thread(LPVOID arg)
359 {
360 DWORD res;
361
362 for (;;) {
363 PlaySound_Playing = FALSE;
364 SetEvent(PlaySound_hReadyEvent);
365 res = WaitForSingleObject(PlaySound_hPlayEvent, INFINITE32);
366 ResetEvent(PlaySound_hReadyEvent);
367 SetEvent(PlaySound_hMiddleEvent);
368 if (res == WAIT_FAILED) ExitThread(2);
369 if (res != WAIT_OBJECT_0) continue;
370 PlaySound_Playing = TRUE;
371
372 if ((PlaySound_fdwSound & SND_RESOURCE) == SND_RESOURCE) {
373 HRSRC32 hRES;
374 HGLOBAL32 hGLOB;
375 void *ptr;
376
377 if ((hRES = FindResource32A(PlaySound_hmod, PlaySound_pszSound, "WAVE")) == 0) {
378 PlaySound_Result = FALSE;
379 continue;
380 }
381 if ((hGLOB = LoadResource32(PlaySound_hmod, hRES)) == 0) {
382 PlaySound_Result = FALSE;
383 continue;
384 }
385 if ((ptr = LockResource32(hGLOB)) == NULL) {
386 FreeResource32(hGLOB);
387 PlaySound_Result = FALSE;
388 continue;
389 }
390 PlaySound_Result = proc_PlaySound(ptr,
391 ((UINT16)PlaySound_fdwSound ^ SND_RESOURCE) | SND_MEMORY);
392 FreeResource32(hGLOB);
393 continue;
394 }
395 PlaySound_Result=proc_PlaySound(PlaySound_pszSound, (UINT16)PlaySound_fdwSound);
396 }
397 }
398
399 /**************************************************************************
400 * PlaySoundA [WINMM.1]
401 */
402 BOOL32 WINAPI PlaySound32A(LPCSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
403 {
404 static LPSTR StrDup = NULL;
405
406 TRACE(mmsys, "pszSound='%p' hmod=%04X fdwSound=%08lX\n",
407 pszSound, hmod, fdwSound);
408
409 if (PlaySound_hThread == 0) { /* This is the first time they called us */
410 DWORD id;
411 if ((PlaySound_hReadyEvent = CreateEvent32A(NULL, TRUE, FALSE, NULL)) == 0)
412 return FALSE;
413 if ((PlaySound_hMiddleEvent = CreateEvent32A(NULL, FALSE, FALSE, NULL)) == 0)
414 return FALSE;
415 if ((PlaySound_hPlayEvent = CreateEvent32A(NULL, FALSE, FALSE, NULL)) == 0)
416 return FALSE;
417 if ((PlaySound_hThread = CreateThread(NULL, 0, PlaySound_Thread, 0, 0, &id)) == 0)
418 return FALSE;
419 }
420
421 /* FIXME? I see no difference between SND_WAIT and SND_NOSTOP ! */
422 if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && PlaySound_Playing)
423 return FALSE;
424
425 /* Trying to stop if playing */
426 if (PlaySound_Playing) PlaySound_Stop = TRUE;
427
428 /* Waiting playing thread to get ready. I think 10 secs is ok & if not then leave*/
429 if (WaitForSingleObject(PlaySound_hReadyEvent, 1000*10) != WAIT_OBJECT_0)
430 return FALSE;
431
432 if (!pszSound || (fdwSound & SND_PURGE))
433 return FALSE; /* We stoped playing so leaving */
434
435 if (PlaySound_SearchMode != 1) PlaySound_SearchMode = 2;
436 if (!(fdwSound & SND_ASYNC)) {
437 if (fdwSound & SND_LOOP)
438 return FALSE;
439 PlaySound_pszSound = pszSound;
440 PlaySound_hmod = hmod;
441 PlaySound_fdwSound = fdwSound;
442 PlaySound_Result = FALSE;
443 SetEvent(PlaySound_hPlayEvent);
444 if (WaitForSingleObject(PlaySound_hMiddleEvent, INFINITE32) != WAIT_OBJECT_0)
445 return FALSE;
446 if (WaitForSingleObject(PlaySound_hReadyEvent, INFINITE32) != WAIT_OBJECT_0)
447 return FALSE;
448 return PlaySound_Result;
449 } else {
450 PlaySound_hmod = hmod;
451 PlaySound_fdwSound = fdwSound;
452 PlaySound_Result = FALSE;
453 if (StrDup) {
454 HeapFree(GetProcessHeap(), 0, StrDup);
455 StrDup = NULL;
456 }
457 if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) &&
458 !((DWORD)pszSound >> 16)) || !pszSound)) {
459 StrDup = HEAP_strdupA(GetProcessHeap(), 0,pszSound);
460 PlaySound_pszSound = StrDup;
461 } else PlaySound_pszSound = pszSound;
462 PlaySound_Loop = fdwSound & SND_LOOP;
463 SetEvent(PlaySound_hPlayEvent);
464 ResetEvent(PlaySound_hMiddleEvent);
465 return TRUE;
466 }
467 return FALSE;
468 }
469
470 /**************************************************************************
471 * PlaySoundW [WINMM.18]
472 */
473 BOOL32 WINAPI PlaySound32W(LPCWSTR pszSound, HMODULE32 hmod, DWORD fdwSound)
474 {
475 LPSTR pszSoundA;
476 BOOL32 bSound;
477
478 if (!((fdwSound & SND_MEMORY) || ((fdwSound & SND_RESOURCE) &&
479 !((DWORD)pszSound >> 16)) || !pszSound)) {
480 pszSoundA = HEAP_strdupWtoA(GetProcessHeap(), 0,pszSound);
481 bSound = PlaySound32A(pszSoundA, hmod, fdwSound);
482 HeapFree(GetProcessHeap(), 0,pszSoundA);
483 } else
484 bSound = PlaySound32A((LPCSTR)pszSound, hmod, fdwSound);
485
486 return bSound;
487 }
488
489 /**************************************************************************
490 * sndPlaySound [MMSYSTEM.2][WINMM135]
491 */
492 BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags)
493 {
494 PlaySound_SearchMode = 1;
495 return PlaySound32A(lpszSoundName, 0, uFlags);
496 }
497
498 /**************************************************************************
499 * sndPlaySound [WINMM.136]
500 */
501 BOOL16 WINAPI sndPlaySound32W(LPCWSTR lpszSoundName, UINT16 uFlags)
502 {
503 PlaySound_SearchMode = 1;
504 return PlaySound32W(lpszSoundName, 0, uFlags);
505 }
506
507 /**************************************************************************
508 * mmsystemGetVersion [WINMM.134]
509 */
510 UINT32 WINAPI mmsystemGetVersion32()
511 {
512 return mmsystemGetVersion16();
513 }
514
515 /**************************************************************************
516 * mmsystemGetVersion [MMSYSTEM.5]
517 * return value borrowed from Win95 winmm.dll ;)
518 */
519 UINT16 WINAPI mmsystemGetVersion16()
520 {
521 TRACE(mmsys, "3.10 (Win95?)\n");
522 return 0x030a;
523 }
524
525 /**************************************************************************
526 * DriverProc [MMSYSTEM.6]
527 */
528 LRESULT WINAPI DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
529 DWORD dwParam1, DWORD dwParam2)
530 {
531 return DrvDefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
532 }
533
534 /**************************************************************************
535 * DriverCallback [MMSYSTEM.31]
536 */
537 BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
538 WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
539 {
540 TRACE(mmsys, "(%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
541 dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
542
543 switch (uFlags & DCB_TYPEMASK) {
544 case DCB_NULL:
545 TRACE(mmsys, "CALLBACK_NULL !\n");
546 break;
547 case DCB_WINDOW:
548 TRACE(mmsys, "CALLBACK_WINDOW = %04lX handle = %04X!\n",
549 dwCallBack, hDev);
550 if (!IsWindow32(dwCallBack) || USER_HEAP_LIN_ADDR(hDev) == NULL)
551 return FALSE;
552
553 PostMessage32A((HWND16)dwCallBack, wMsg, hDev, dwParam1);
554 break;
555 case DCB_TASK:
556 TRACE(mmsys, "CALLBACK_TASK !\n");
557 return FALSE;
558 case DCB_FUNCTION:
559 TRACE(mmsys, "CALLBACK_FUNCTION !\n");
560 Callbacks->CallDriverCallback((FARPROC16)dwCallBack,
561 hDev, wMsg, dwUser,
562 dwParam1, dwParam2 );
563 break;
564 case DCB_FUNC32:
565 TRACE(mmsys, "CALLBACK_FUNCTION !\n");
566 ((LPDRVCALLBACK32)dwCallBack)(hDev, wMsg, dwUser,
567 dwParam1, dwParam2 );
568 break;
569 default:
570 WARN(mmsys, "Unknown callback type\n");
571 break;
572 }
573 return TRUE;
574 }
575
576 /**************************************************************************
577 * Mixer devices. New to Win95
578 */
579 /**************************************************************************
580 * find out the real mixer ID depending on hmix (depends on dwFlags)
581 * FIXME: also fix dwInstance passing to mixMessage
582 */
583 static UINT32 _get_mixerID_from_handle(HMIXEROBJ32 hmix, DWORD dwFlags)
584 {
585 /* FIXME: Check dwFlags for MIXER_OBJECTF_xxxx entries and modify hmix
586 * accordingly. For now we always use mixerdevice 0.
587 */
588 return 0;
589 }
590
591 /**************************************************************************
592 * mixerGetNumDevs [WINMM.108]
593 */
594 UINT32 WINAPI mixerGetNumDevs32()
595 {
596 return mixerGetNumDevs16();
597 }
598
599 /**************************************************************************
600 * mixerGetNumDevs
601 */
602 UINT16 WINAPI mixerGetNumDevs16()
603 {
604 UINT16 count = mixMessage(0, MXDM_GETNUMDEVS, 0L, 0L, 0L);
605
606 TRACE(mmaux,"mixerGetNumDevs returns %d\n",count);
607 return count;
608 }
609
610 /**************************************************************************
611 * mixerGetDevCapsW [WINMM.102]
612 */
613 UINT32 WINAPI mixerGetDevCaps32W(UINT32 devid, LPMIXERCAPS32W mixcaps,UINT32 size)
614 {
615 MIXERCAPS16 mic16;
616 UINT32 ret = mixerGetDevCaps16(devid, &mic16, sizeof(mic16));
617
618 mixcaps->wMid = mic16.wMid;
619 mixcaps->wPid = mic16.wPid;
620 mixcaps->vDriverVersion = mic16.vDriverVersion;
621 lstrcpyAtoW(mixcaps->szPname, mic16.szPname);
622 mixcaps->fdwSupport = mic16.fdwSupport;
623 mixcaps->cDestinations = mic16.cDestinations;
624 return ret;
625 }
626
627 /**************************************************************************
628 * mixerGetDevCaps [WINMM.101]
629 */
630 UINT32 WINAPI mixerGetDevCaps32A(UINT32 devid, LPMIXERCAPS32A mixcaps,UINT32 size)
631 {
632 MIXERCAPS16 mic16;
633 UINT32 ret = mixerGetDevCaps16(devid, &mic16, sizeof(mic16));
634
635 mixcaps->wMid = mic16.wMid;
636 mixcaps->wPid = mic16.wPid;
637 mixcaps->vDriverVersion = mic16.vDriverVersion;
638 strcpy(mixcaps->szPname, mic16.szPname);
639 mixcaps->fdwSupport = mic16.fdwSupport;
640 mixcaps->cDestinations = mic16.cDestinations;
641 return ret;
642 }
643
644 /**************************************************************************
645 * mixerGetDevCaps
646 */
647 UINT16 WINAPI mixerGetDevCaps16(UINT16 devid, LPMIXERCAPS16 mixcaps,UINT16 size)
648 {
649 FIXME(mmsys,"should this be a fixme?\n");
650 return mixMessage(devid, MXDM_GETDEVCAPS, 0L, (DWORD)mixcaps, (DWORD)size);
651 }
652
653 /**************************************************************************
654 * mixerOpen [WINMM.110]
655 */
656 UINT32 WINAPI mixerOpen32(LPHMIXER32 lphmix,UINT32 uDeviceID, DWORD dwCallback,
657 DWORD dwInstance, DWORD fdwOpen)
658 {
659 HMIXER16 hmix16;
660 UINT32 ret;
661
662 FIXME(mmsys,"(%p,%d,%08lx,%08lx,%08lx): semi stub?\n",
663 lphmix,uDeviceID, dwCallback, dwInstance, fdwOpen);
664 ret = mixerOpen16(&hmix16,uDeviceID, dwCallback, dwInstance,fdwOpen);
665 if (lphmix) *lphmix = hmix16;
666 return ret;
667 }
668
669 /**************************************************************************
670 * mixerOpen
671 */
672 UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix,UINT16 uDeviceID, DWORD dwCallback,
673 DWORD dwInstance, DWORD fdwOpen)
674 {
675 HMIXER16 hmix;
676 LPMIXEROPENDESC lpmod;
677 BOOL32 mapperflag = (uDeviceID==0);
678 DWORD dwRet=0;
679
680 TRACE(mmsys,"(%p,%d,%08lx,%08lx,%08lx)\n",
681 lphmix,uDeviceID, dwCallback, dwInstance, fdwOpen);
682 hmix = USER_HEAP_ALLOC(sizeof(MIXEROPENDESC));
683 if (lphmix) *lphmix = hmix;
684 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
685 lpmod->hmx = hmix;
686 lpmod->dwCallback = dwCallback;
687 lpmod->dwInstance = dwInstance;
688 if (uDeviceID >= MAXMIXERDRIVERS)
689 uDeviceID = 0;
690 while (uDeviceID < MAXMIXERDRIVERS) {
691 dwRet=mixMessage(uDeviceID, MXDM_OPEN, dwInstance, (DWORD)lpmod, fdwOpen);
692 if (dwRet == MMSYSERR_NOERROR) break;
693 if (!mapperflag) break;
694 uDeviceID++;
695 }
696 lpmod->uDeviceID = uDeviceID;
697 return dwRet;
698 }
699
700 /**************************************************************************
701 * mixerClose [WINMM.98]
702 */
703 UINT32 WINAPI mixerClose32(HMIXER32 hmix)
704 {
705 return mixerClose16(hmix);
706 }
707
708 /**************************************************************************
709 * mixerClose
710 */
711 UINT16 WINAPI mixerClose16(HMIXER16 hmix)
712 {
713 LPMIXEROPENDESC lpmod;
714
715 FIXME(mmsys,"(%04x): semi-stub?\n", hmix);
716 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
717 return mixMessage(lpmod->uDeviceID, MXDM_CLOSE, lpmod->dwInstance, 0L, 0L);
718 }
719
720 /**************************************************************************
721 * mixerGetID [WINMM.103]
722 */
723 UINT32 WINAPI mixerGetID32(HMIXEROBJ32 hmix, LPUINT32 lpid, DWORD fdwID)
724 {
725 UINT16 xid;
726 UINT32 ret = mixerGetID16(hmix, &xid, fdwID);
727
728 if (lpid) *lpid = xid;
729 return ret;
730 }
731
732 /**************************************************************************
733 * mixerGetID
734 */
735 UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix,LPUINT16 lpid,DWORD fdwID)
736 {
737 FIXME(mmsys,"(%04x): semi-stub\n",hmix);
738 if (lpid)
739 *lpid = _get_mixerID_from_handle(hmix,fdwID);
740 return MMSYSERR_NOERROR; /* FIXME: many error possibilities */
741 }
742
743 /**************************************************************************
744 * mixerGetControlDetailsA [WINMM.99]
745 */
746 UINT32 WINAPI mixerGetControlDetails32A(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails)
747 {
748 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
749 return MMSYSERR_NOTENABLED;
750 }
751
752 /**************************************************************************
753 * mixerGetControlDetailsW [WINMM.100]
754 */
755 UINT32 WINAPI mixerGetControlDetails32W(HMIXEROBJ32 hmix,LPMIXERCONTROLDETAILS32 lpmcd,DWORD fdwDetails)
756 {
757 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix,lpmcd,fdwDetails);
758 return MMSYSERR_NOTENABLED;
759 }
760
761 /**************************************************************************
762 * mixerGetControlDetails [MMSYSTEM.808]
763 */
764 UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,LPMIXERCONTROLDETAILS16 lpmcd,DWORD fdwDetails)
765 {
766 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmcd,fdwDetails);
767 return MMSYSERR_NOTENABLED;
768 }
769
770 /**************************************************************************
771 * mixerGetLineControlsA [WINMM.104]
772 */
773 UINT32 WINAPI mixerGetLineControls32A(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32A lpmlc,DWORD fdwControls)
774 {
775 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
776 return MMSYSERR_NOTENABLED;
777 }
778
779 /**************************************************************************
780 * mixerGetLineControlsW [WINMM.105]
781 */
782 UINT32 WINAPI mixerGetLineControls32W(HMIXEROBJ32 hmix,LPMIXERLINECONTROLS32W lpmlc,DWORD fdwControls)
783 {
784 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
785 return MMSYSERR_NOTENABLED;
786 }
787
788 /**************************************************************************
789 * mixerGetLineControls [MMSYSTEM.807]
790 */
791 UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,LPMIXERLINECONTROLS16 lpmlc,DWORD fdwControls)
792 {
793 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpmlc,fdwControls);
794 return MMSYSERR_NOTENABLED;
795 }
796
797 /**************************************************************************
798 * mixerGetLineInfoA [WINMM.106]
799 */
800 UINT32 WINAPI mixerGetLineInfo32A(HMIXEROBJ32 hmix,LPMIXERLINE32A lpml,DWORD fdwInfo)
801 {
802 MIXERLINE16 ml16;
803 UINT32 ret;
804
805 ml16.dwDestination = lpml->dwDestination;
806 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n",hmix,lpml,fdwInfo);
807 ret = mixerGetLineInfo16(hmix,&ml16,fdwInfo);
808 lpml->cbStruct = sizeof(*lpml);
809 lpml->dwSource = ml16.dwSource;
810 lpml->dwLineID = ml16.dwLineID;
811 lpml->fdwLine = ml16.fdwLine;
812 lpml->dwUser = ml16.dwUser;
813 lpml->dwComponentType = ml16.dwComponentType;
814 lpml->cChannels = ml16.cChannels;
815 lpml->cConnections = ml16.cConnections;
816 lpml->cControls = ml16.cControls;
817 strcpy(lpml->szShortName, ml16.szShortName);
818 strcpy(lpml->szName, ml16.szName);
819 lpml->Target.dwType = ml16.Target.dwType;
820 lpml->Target.dwDeviceID = ml16.Target.dwDeviceID;
821 lpml->Target.wMid = ml16.Target.wMid;
822 lpml->Target.wPid = ml16.Target.wPid;
823 lpml->Target.vDriverVersion = ml16.Target.vDriverVersion;
824 strcpy(lpml->Target.szPname, ml16.Target.szPname);
825 return ret;
826 }
827
828 /**************************************************************************
829 * mixerGetLineInfoW [WINMM.107]
830 */
831 UINT32 WINAPI mixerGetLineInfo32W(HMIXEROBJ32 hmix, LPMIXERLINE32W lpml, DWORD fdwInfo)
832 {
833 MIXERLINE16 ml16;
834 UINT32 ret;
835
836 TRACE(mmsys,"(%04x,%p,%08lx)\n", hmix, lpml, fdwInfo);
837
838 if (lpml == NULL || lpml->cbStruct != sizeof(*lpml))
839 return MMSYSERR_INVALPARAM;
840
841 ml16.cbStruct = sizeof(ml16);
842 ml16.dwDestination = lpml->dwDestination;
843 ml16.dwSource = lpml->dwSource;
844 ml16.dwLineID = lpml->dwLineID;
845 ml16.dwUser = lpml->dwUser;
846 ml16.dwComponentType = lpml->dwComponentType;
847 ml16.cChannels = lpml->cChannels;
848 ml16.cConnections = lpml->cConnections;
849 ml16.cControls = lpml->cControls;
850
851 ret = mixerGetLineInfo16(hmix, &ml16, fdwInfo);
852
853 lpml->dwSource = ml16.dwSource;
854 lpml->dwLineID = ml16.dwLineID;
855 lpml->fdwLine = ml16.fdwLine;
856 lpml->dwUser = ml16.dwUser;
857 lpml->dwComponentType = ml16.dwComponentType;
858 lpml->cChannels = ml16.cChannels;
859 lpml->cConnections = ml16.cConnections;
860 lpml->cControls = ml16.cControls;
861 lstrcpyAtoW(lpml->szShortName, ml16.szShortName);
862 lstrcpyAtoW(lpml->szName, ml16.szName);
863 lpml->Target.dwType = ml16.Target.dwType;
864 lpml->Target.dwDeviceID = ml16.Target.dwDeviceID;
865 lpml->Target.wMid = ml16.Target.wMid;
866 lpml->Target.wPid = ml16.Target.wPid;
867 lpml->Target.vDriverVersion = ml16.Target.vDriverVersion;
868 /*lstrcpyAtoW(lpml->Target.szPname, ml16.Target.szPname);*/
869 return ret;
870 }
871
872 /**************************************************************************
873 * mixerGetLineInfo [MMSYSTEM.805]
874 */
875 UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpml, DWORD fdwInfo)
876 {
877 UINT16 devid = _get_mixerID_from_handle(hmix, fdwInfo);
878
879 FIXME(mmsys, "(%04x, %p[line %08lx], %08lx)\n",
880 hmix, lpml, lpml->dwDestination, fdwInfo);
881 return mixMessage(devid, MXDM_GETLINEINFO, 0, (DWORD)lpml, fdwInfo);
882 }
883
884 /**************************************************************************
885 * mixerSetControlDetails [WINMM.111]
886 */
887 UINT32 WINAPI mixerSetControlDetails32(HMIXEROBJ32 hmix, LPMIXERCONTROLDETAILS32 lpmcd, DWORD fdwDetails)
888 {
889 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
890 return MMSYSERR_NOTENABLED;
891 }
892
893 /**************************************************************************
894 * mixerSetControlDetails [MMSYSTEM.809]
895 */
896 UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails)
897 {
898 FIXME(mmsys,"(%04x,%p,%08lx): stub!\n", hmix, lpmcd, fdwDetails);
899 return MMSYSERR_NOTENABLED;
900 }
901
902 /**************************************************************************
903 * mixerMessage [WINMM.109]
904 */
905 UINT32 WINAPI mixerMessage32(HMIXER32 hmix,UINT32 uMsg, DWORD dwParam1, DWORD dwParam2)
906 {
907 LPMIXEROPENDESC lpmod;
908 UINT16 uDeviceID;
909
910 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
911 if (lpmod)
912 uDeviceID = lpmod->uDeviceID;
913 else
914 uDeviceID = 0;
915 FIXME(mmsys,"(%04lx,%d,%08lx,%08lx): semi-stub?\n",
916 (DWORD)hmix,uMsg, dwParam1, dwParam2);
917 return mixMessage(uDeviceID,uMsg, 0L, dwParam1, dwParam2);
918 }
919
920 /**************************************************************************
921 * mixerMessage [MMSYSTEM.804]
922 */
923 UINT16 WINAPI mixerMessage16(HMIXER16 hmix,UINT16 uMsg, DWORD dwParam1, DWORD dwParam2)
924 {
925 LPMIXEROPENDESC lpmod;
926 UINT16 uDeviceID;
927
928 lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
929 uDeviceID = (lpmod) ? lpmod->uDeviceID : 0;
930 FIXME(mmsys,"(%04x,%d,%08lx,%08lx) - semi-stub?\n",
931 hmix,uMsg, dwParam1, dwParam2);
932 return mixMessage(uDeviceID,uMsg, 0L, dwParam1, dwParam2);
933 }
934
935 /**************************************************************************
936 * auxGetNumDevs [WINMM.22]
937 */
938 UINT32 WINAPI auxGetNumDevs32()
939 {
940 return auxGetNumDevs16();
941 }
942
943 /**************************************************************************
944 * auxGetNumDevs [MMSYSTEM.350]
945 */
946 UINT16 WINAPI auxGetNumDevs16()
947 {
948 UINT16 count;
949
950 TRACE(mmsys, "\n");
951 count = auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
952 TRACE(mmsys, "=> %u\n", count);
953 return count;
954 }
955
956 /**************************************************************************
957 * auxGetDevCaps [WINMM.20]
958 */
959 UINT32 WINAPI auxGetDevCaps32W(UINT32 uDeviceID, LPAUXCAPS32W lpCaps,UINT32 uSize)
960 {
961 AUXCAPS16 ac16;
962 UINT32 ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16));
963
964 lpCaps->wMid = ac16.wMid;
965 lpCaps->wPid = ac16.wPid;
966 lpCaps->vDriverVersion = ac16.vDriverVersion;
967 lstrcpyAtoW(lpCaps->szPname,ac16.szPname);
968 lpCaps->wTechnology = ac16.wTechnology;
969 lpCaps->dwSupport = ac16.dwSupport;
970 return ret;
971 }
972
973 /**************************************************************************
974 * auxGetDevCaps [WINMM.21]
975 */
976 UINT32 WINAPI auxGetDevCaps32A(UINT32 uDeviceID, LPAUXCAPS32A lpCaps,UINT32 uSize)
977 {
978 AUXCAPS16 ac16;
979 UINT32 ret = auxGetDevCaps16(uDeviceID, &ac16, sizeof(ac16));
980
981 lpCaps->wMid = ac16.wMid;
982 lpCaps->wPid = ac16.wPid;
983 lpCaps->vDriverVersion = ac16.vDriverVersion;
984 strcpy(lpCaps->szPname,ac16.szPname);
985 lpCaps->wTechnology = ac16.wTechnology;
986 lpCaps->dwSupport = ac16.dwSupport;
987 return ret;
988 }
989
990 /**************************************************************************
991 * auxGetDevCaps [MMSYSTEM.351]
992 */
993 UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize)
994 {
995 TRACE(mmsys, "(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize);
996
997 return auxMessage(uDeviceID, AUXDM_GETDEVCAPS,
998 0L, (DWORD)lpCaps, (DWORD)uSize);
999 }
1000
1001 /**************************************************************************
1002 * auxGetVolume [WINM.23]
1003 */
1004 UINT32 WINAPI auxGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
1005 {
1006 return auxGetVolume16(uDeviceID, lpdwVolume);
1007 }
1008
1009 /**************************************************************************
1010 * auxGetVolume [MMSYSTEM.352]
1011 */
1012 UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
1013 {
1014 TRACE(mmsys, "(%04X, %p) !\n", uDeviceID, lpdwVolume);
1015
1016 return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
1017 }
1018
1019 /**************************************************************************
1020 * auxSetVolume [WINMM.25]
1021 */
1022 UINT32 WINAPI auxSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
1023 {
1024 return auxSetVolume16(uDeviceID, dwVolume);
1025 }
1026
1027 /**************************************************************************
1028 * auxSetVolume [MMSYSTEM.353]
1029 */
1030 UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
1031 {
1032 TRACE(mmsys, "(%04X, %08lX) !\n", uDeviceID, dwVolume);
1033
1034 return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L);
1035 }
1036
1037 /**************************************************************************
1038 * auxOutMessage [MMSYSTEM.354]
1039 */
1040 DWORD WINAPI auxOutMessage32(UINT32 uDeviceID,UINT32 uMessage, DWORD dw1, DWORD dw2)
1041 {
1042 switch (uMessage) {
1043 case AUXDM_GETNUMDEVS:
1044 case AUXDM_GETVOLUME:
1045 case AUXDM_SETVOLUME:
1046 /* no argument conversion needed */
1047 break;
1048 case AUXDM_GETDEVCAPS:
1049 return auxGetDevCaps32A(uDeviceID, (LPAUXCAPS32A)dw1, dw2);
1050 default:
1051 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
1052 uDeviceID,uMessage, dw1, dw2);
1053 break;
1054 }
1055 return auxMessage(uDeviceID,uMessage, 0L, dw1, dw2);
1056 }
1057
1058 /**************************************************************************
1059 * auxOutMessage [MMSYSTEM.354]
1060 */
1061 DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
1062 {
1063 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", uDeviceID, uMessage, dw1, dw2);
1064
1065 switch (uMessage) {
1066 case AUXDM_GETNUMDEVS:
1067 case AUXDM_SETVOLUME:
1068 /* no argument conversion needed */
1069 break;
1070 case AUXDM_GETVOLUME:
1071 return auxGetVolume16(uDeviceID, (LPDWORD)PTR_SEG_TO_LIN(dw1));
1072 case AUXDM_GETDEVCAPS:
1073 return auxGetDevCaps16(uDeviceID, (LPAUXCAPS16)PTR_SEG_TO_LIN(dw1), dw2);
1074 default:
1075 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
1076 uDeviceID,uMessage, dw1, dw2);
1077 break;
1078 }
1079 return auxMessage(uDeviceID, uMessage, 0L, dw1, dw2);
1080 }
1081
1082 /**************************************************************************
1083 * mciGetErrorStringW [WINMM.46]
1084 */
1085 BOOL32 WINAPI mciGetErrorString32W(DWORD wError, LPWSTR lpstrBuffer,UINT32 uLength)
1086 {
1087 LPSTR bufstr = HeapAlloc(GetProcessHeap(), 0,uLength);
1088 BOOL32 ret = mciGetErrorString32A(wError,bufstr,uLength);
1089
1090 lstrcpyAtoW(lpstrBuffer,bufstr);
1091 HeapFree(GetProcessHeap(), 0,bufstr);
1092 return ret;
1093 }
1094
1095 /**************************************************************************
1096 * mciGetErrorStringA [WINMM.45]
1097 */
1098 BOOL32 WINAPI mciGetErrorString32A(DWORD wError, LPSTR lpstrBuffer,UINT32 uLength)
1099 {
1100 return mciGetErrorString16(wError, lpstrBuffer,uLength);
1101 }
1102
1103 /**************************************************************************
1104 * mciGetErrorString [MMSYSTEM.706]
1105 */
1106 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer,UINT16 uLength)
1107 {
1108 LPSTR msgptr;
1109
1110 TRACE(mmsys, "(%08lX, %p, %d);\n", wError, lpstrBuffer, uLength);
1111
1112 if ((lpstrBuffer == NULL) || (uLength < 1))
1113 return(FALSE);
1114 lpstrBuffer[0] = '\0';
1115
1116 switch (wError) {
1117 case MCIERR_INVALID_DEVICE_ID:
1118 msgptr = "Invalid MCI device ID. Use the ID returned when opening the MCI device.";
1119 break;
1120 case MCIERR_UNRECOGNIZED_KEYWORD:
1121 msgptr = "The driver cannot recognize the specified command parameter.";
1122 break;
1123 case MCIERR_UNRECOGNIZED_COMMAND:
1124 msgptr = "The driver cannot recognize the specified command.";
1125 break;
1126 case MCIERR_HARDWARE:
1127 msgptr = "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer.";
1128 break;
1129 case MCIERR_INVALID_DEVICE_NAME:
1130 msgptr = "The specified device is not open or is not recognized by MCI.";
1131 break;
1132 case MCIERR_OUT_OF_MEMORY:
1133 msgptr = "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again.";
1134 break;
1135 case MCIERR_DEVICE_OPEN:
1136 msgptr = "The device name is already being used as an alias by this application. Use a unique alias.";
1137 break;
1138 case MCIERR_CANNOT_LOAD_DRIVER:
1139 msgptr = "There is an undetectable problem in loading the specified device driver.";
1140 break;
1141 case MCIERR_MISSING_COMMAND_STRING:
1142 msgptr = "No command was specified.";
1143 break;
1144 case MCIERR_PARAM_OVERFLOW:
1145 msgptr = "The output string was to large to fit in the return buffer. Increase the size of the buffer.";
1146 break;
1147 case MCIERR_MISSING_STRING_ARGUMENT:
1148 msgptr = "The specified command requires a character-string parameter. Please provide one.";
1149 break;
1150 case MCIERR_BAD_INTEGER:
1151 msgptr = "The specified integer is invalid for this command.";
1152 break;
1153 case MCIERR_PARSER_INTERNAL:
1154 msgptr = "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver.";
1155 break;
1156 case MCIERR_DRIVER_INTERNAL:
1157 msgptr = "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver.";
1158 break;
1159 case MCIERR_MISSING_PARAMETER:
1160 msgptr = "The specified command requires a parameter. Please supply one.";
1161 break;
1162 case MCIERR_UNSUPPORTED_FUNCTION:
1163 msgptr = "The MCI device you are using does not support the specified command.";
1164 break;
1165 case MCIERR_FILE_NOT_FOUND:
1166 msgptr = "Cannot find the specified file. Make sure the path and filename are correct.";
1167 break;
1168 case MCIERR_DEVICE_NOT_READY:
1169 msgptr = "The device driver is not ready.";
1170 break;
1171 case MCIERR_INTERNAL:
1172 msgptr = "A problem occurred in initializing MCI. Try restarting Windows.";
1173 break;
1174 case MCIERR_DRIVER:
1175 msgptr = "There is a problem with the device driver. The driver has closed. Cannot access error.";
1176 break;
1177 case MCIERR_CANNOT_USE_ALL:
1178 msgptr = "Cannot use 'all' as the device name with the specified command.";
1179 break;
1180 case MCIERR_MULTIPLE:
1181 msgptr = "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error";
1182 break;
1183 case MCIERR_EXTENSION_NOT_FOUND:
1184 msgptr = "Cannot determine the device type from the given filename extension.";
1185 break;
1186 case MCIERR_OUTOFRANGE:
1187 msgptr = "The specified parameter is out of range for the specified command.";
1188 break;
1189 case MCIERR_FLAGS_NOT_COMPATIBLE:
1190 msgptr = "The specified parameters cannot be used together.";
1191 break;
1192 case MCIERR_FILE_NOT_SAVED:
1193 msgptr = "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network.";
1194 break;
1195 case MCIERR_DEVICE_TYPE_REQUIRED:
1196 msgptr = "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly.";
1197 break;
1198 case MCIERR_DEVICE_LOCKED:
1199 msgptr = "The specified device is now being closed. Wait a few seconds, and then try again.";
1200 break;
1201 case MCIERR_DUPLICATE_ALIAS:
1202 msgptr = "The specified alias is already being used in this application. Use a unique alias.";
1203 break;
1204 case MCIERR_BAD_CONSTANT:
1205 msgptr = "The specified parameter is invalid for this command.";
1206 break;
1207 case MCIERR_MUST_USE_SHAREABLE:
1208 msgptr = "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command.";
1209 break;
1210 case MCIERR_MISSING_DEVICE_NAME:
1211 msgptr = "The specified command requires an alias, file, driver, or device name. Please supply one.";
1212 break;
1213 case MCIERR_BAD_TIME_FORMAT:
1214 msgptr = "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats.";
1215 break;
1216 case MCIERR_NO_CLOSING_QUOTE:
1217 msgptr = "A closing double-quotation mark is missing from the parameter value. Please supply one.";
1218 break;
1219 case MCIERR_DUPLICATE_FLAGS:
1220 msgptr = "A parameter or value was specified twice. Only specify it once.";
1221 break;
1222 case MCIERR_INVALID_FILE:
1223 msgptr = "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format.";
1224 break;
1225 case MCIERR_NULL_PARAMETER_BLOCK:
1226 msgptr = "A null parameter block was passed to MCI.";
1227 break;
1228 case MCIERR_UNNAMED_RESOURCE:
1229 msgptr = "Cannot save an unnamed file. Supply a filename.";
1230 break;
1231 case MCIERR_NEW_REQUIRES_ALIAS:
1232 msgptr = "You must specify an alias when using the 'new' parameter.";
1233 break;
1234 case MCIERR_NOTIFY_ON_AUTO_OPEN:
1235 msgptr = "Cannot use the 'notify' flag with auto-opened devices.";
1236 break;
1237 case MCIERR_NO_ELEMENT_ALLOWED:
1238 msgptr = "Cannot use a filename with the specified device.";
1239 break;
1240 case MCIERR_NONAPPLICABLE_FUNCTION:
1241 msgptr = "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again.";
1242 break;
1243 case MCIERR_ILLEGAL_FOR_AUTO_OPEN:
1244 msgptr = "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again.";
1245 break;
1246 case MCIERR_FILENAME_REQUIRED:
1247 msgptr = "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension.";
1248 break;
1249 case MCIERR_EXTRA_CHARACTERS:
1250 msgptr = "Cannot specify extra characters after a string enclosed in quotation marks.";
1251 break;
1252 case MCIERR_DEVICE_NOT_INSTALLED:
1253 msgptr = "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device.";
1254 break;
1255 case MCIERR_GET_CD:
1256 msgptr = "Cannot access the specified file or MCI device. Try changing directories or restarting your computer.";
1257 break;
1258 case MCIERR_SET_CD:
1259 msgptr = "Cannot access the specified file or MCI device because the application cannot change directories.";
1260 break;
1261 case MCIERR_SET_DRIVE:
1262 msgptr = "Cannot access specified file or MCI device because the application cannot change drives.";
1263 break;
1264 case MCIERR_DEVICE_LENGTH:
1265 msgptr = "Specify a device or driver name that is less than 79 characters.";
1266 break;
1267 case MCIERR_DEVICE_ORD_LENGTH:
1268 msgptr = "Specify a device or driver name that is less than 69 characters.";
1269 break;
1270 case MCIERR_NO_INTEGER:
1271 msgptr = "The specified command requires an integer parameter. Please provide one.";
1272 break;
1273 case MCIERR_WAVE_OUTPUTSINUSE:
1274 msgptr = "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again.";
1275 break;
1276 case MCIERR_WAVE_SETOUTPUTINUSE:
1277 msgptr = "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again.";
1278 break;
1279 case MCIERR_WAVE_INPUTSINUSE:
1280 msgptr = "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again.";
1281 break;
1282 case MCIERR_WAVE_SETINPUTINUSE:
1283 msgptr = "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again.";
1284 break;
1285 case MCIERR_WAVE_OUTPUTUNSPECIFIED:
1286 msgptr = "Any compatible waveform playback device may be used.";
1287 break;
1288 case MCIERR_WAVE_INPUTUNSPECIFIED:
1289 msgptr = "Any compatible waveform recording device may be used.";
1290 break;
1291 case MCIERR_WAVE_OUTPUTSUNSUITABLE:
1292 msgptr = "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device.";
1293 break;
1294 case MCIERR_WAVE_SETOUTPUTUNSUITABLE:
1295 msgptr = "The device you are trying to play to cannot recognize the current file format.";
1296 break;
1297 case MCIERR_WAVE_INPUTSUNSUITABLE:
1298 msgptr = "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device.";
1299 break;
1300 case MCIERR_WAVE_SETINPUTUNSUITABLE:
1301 msgptr = "The device you are trying to record from cannot recognize the current file format.";
1302 break;
1303 case MCIERR_NO_WINDOW:
1304 msgptr = "There is no display window.";
1305 break;
1306 case MCIERR_CREATEWINDOW:
1307 msgptr = "Could not create or use window.";
1308 break;
1309 case MCIERR_FILE_READ:
1310 msgptr = "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection.";
1311 break;
1312 case MCIERR_FILE_WRITE:
1313 msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network.";
1314 break;
1315 case MCIERR_SEQ_DIV_INCOMPATIBLE:
1316 msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together.";
1317 break;
1318 case MCIERR_SEQ_NOMIDIPRESENT:
1319 msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver.";
1320 break;
1321 case MCIERR_SEQ_PORT_INUSE:
1322 msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again.";
1323 break;
1324 case MCIERR_SEQ_PORT_MAPNODEVICE:
1325 msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup.";
1326 break;
1327 case MCIERR_SEQ_PORT_MISCERROR:
1328 msgptr = "An error occurred with the specified port.";
1329 break;
1330 case MCIERR_SEQ_PORT_NONEXISTENT:
1331 msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device.";
1332 break;
1333 case MCIERR_SEQ_PORTUNSPECIFIED:
1334 msgptr = "The system doesnot have a current MIDI port specified.";
1335 break;
1336 case MCIERR_SEQ_TIMER:
1337 msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again.";
1338 break;
1339
1340 /*
1341 msg# 513 : vcr
1342 msg# 514 : videodisc
1343 msg# 515 : overlay
1344 msg# 516 : cdaudio
1345 msg# 517 : dat
1346 msg# 518 : scanner
1347 msg# 519 : animation
1348 msg# 520 : digitalvideo
1349 msg# 521 : other
1350 msg# 522 : waveaudio
1351 msg# 523 : sequencer
1352 msg# 524 : not ready
1353 msg# 525 : stopped
1354 msg# 526 : playing
1355 msg# 527 : recording
1356 msg# 528 : seeking
1357 msg# 529 : paused
1358 msg# 530 : open
1359 msg# 531 : false
1360 msg# 532 : true
1361 msg# 533 : milliseconds
1362 msg# 534 : hms
1363 msg# 535 : msf
1364 msg# 536 : frames
1365 msg# 537 : smpte 24
1366 msg# 538 : smpte 25
1367 msg# 539 : smpte 30
1368 msg# 540 : smpte 30 drop
1369 msg# 541 : bytes
1370 msg# 542 : samples
1371 msg# 543 : tmsf
1372 */
1373 default:
1374 msgptr = "Unknown MCI Error !\n";
1375 break;
1376 }
1377 lstrcpyn32A(lpstrBuffer, msgptr, uLength);
1378 TRACE(mmsys, "msg = %s;\n", msgptr);
1379 return TRUE;
1380 }
1381
1382 /**************************************************************************
1383 * mciDriverNotify [MMSYSTEM.711]
1384 */
1385 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
1386 {
1387 TRACE(mmsys, "(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
1388
1389 if (!IsWindow32(hWndCallBack)) return FALSE;
1390 TRACE(mmsys, "before PostMessage\n");
1391 PostMessage32A(hWndCallBack, MM_MCINOTIFY, wStatus, MAKELONG(wDevID, 0));
1392 return TRUE;
1393 }
1394
1395 /**************************************************************************
1396 * mciDriverNotify32 [WINMM.36]
1397 */
1398 BOOL32 WINAPI mciDriverNotify32(HWND32 hWndCallBack, UINT32 wDevID, UINT32 wStatus)
1399 {
1400 FIXME(mmsys, "stub(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
1401
1402 return FALSE;
1403 }
1404
1405 /**************************************************************************
1406 * mciGetDriverData [MMSYSTEM.708]
1407 */
1408 DWORD WINAPI mciGetDriverData16(HDRVR16 hdrv)
1409 {
1410 FIXME(mmsys,"(%04x): stub!\n", hdrv);
1411
1412 return 0x42;
1413 }
1414
1415 /**************************************************************************
1416 * mciGetDriverData [WINMM.44]
1417 */
1418 DWORD WINAPI mciGetDriverData32(HDRVR32 hdrv)
1419 {
1420 FIXME(mmsys,"(%04x): stub!\n", hdrv);
1421
1422 return 0x42;
1423 }
1424
1425 /**************************************************************************
1426 * mciSetDriverData [MMSYSTEM.707]
1427 */
1428 BOOL16 WINAPI mciSetDriverData16(HDRVR16 hdrv, DWORD data)
1429 {
1430 FIXME(mmsys,"(%04x,%08lx): stub!\n", hdrv, data);
1431
1432 return 0;
1433 }
1434
1435 /**************************************************************************
1436 * mciSetDriverData [WINMM.53]
1437 */
1438 BOOL32 WINAPI mciSetDriverData32(HDRVR32 hdrv, DWORD data)
1439 {
1440 FIXME(mmsys,"(%04x,%08lx): stub!\n", hdrv, data);
1441
1442 return 0;
1443 }
1444
1445 /**************************************************************************
1446 * mciLoadCommandResource [MMSYSTEM.705]
1447 */
1448 UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hinst, LPCSTR resname,UINT16 type)
1449 {
1450 char buf[200];
1451 OFSTRUCT ofs;
1452 HANDLE16 xhinst;
1453 HRSRC16 hrsrc;
1454 HGLOBAL16 hmem;
1455 LPSTR segstr;
1456 SEGPTR xmem;
1457 LPBYTE lmem;
1458 static UINT16 mcidevtype = 0;
1459
1460 FIXME(mmsys,"(%04x,%s,%d): stub!\n", hinst, resname, type);
1461 if (!lstrcmpi32A(resname,"core")) {
1462 FIXME(mmsys, "(...,\"core\",...), have to use internal tables... (not there yet)\n");
1463 return 0;
1464 }
1465 /* if file exists "resname.mci", then load resource "resname" from it
1466 * otherwise directly from driver
1467 */
1468 strcpy(buf,resname);
1469 strcat(buf,".mci");
1470 if (OpenFile32(buf, &ofs,OF_EXIST) != HFILE_ERROR32) {
1471 xhinst = LoadLibrary16(buf);
1472 if (xhinst >32)
1473 hinst = xhinst;
1474 } /* else use passed hinst */
1475 segstr = SEGPTR_STRDUP(resname);
1476 hrsrc = FindResource16(hinst, SEGPTR_GET(segstr), type);
1477 SEGPTR_FREE(segstr);
1478 if (!hrsrc) {
1479 WARN(mmsys,"no special commandlist found in resource\n");
1480 return MCI_NO_COMMAND_TABLE;
1481 }
1482 hmem = LoadResource16(hinst, hrsrc);
1483 if (!hmem) {
1484 WARN(mmsys,"couldn't load resource??\n");
1485 return MCI_NO_COMMAND_TABLE;
1486 }
1487 xmem = WIN16_LockResource16(hmem);
1488 if (!xmem) {
1489 WARN(mmsys,"couldn't lock resource??\n");
1490 FreeResource16(hmem);
1491 return MCI_NO_COMMAND_TABLE;
1492 }
1493 lmem = PTR_SEG_TO_LIN(xmem);
1494 TRACE(mmsys, "first resource entry is %s\n", (char*)lmem);
1495 /* parse resource, register stuff, return unique id */
1496 return ++mcidevtype;
1497 }
1498
1499 /**************************************************************************
1500 * mciFreeCommandResource [MMSYSTEM.713]
1501 */
1502 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
1503 {
1504 FIXME(mci, "(%04x) stub\n", uTable);
1505 return 0;
1506 }
1507
1508 /**************************************************************************
1509 * mciFreeCommandResource [WINMM.39]
1510 */
1511 BOOL32 WINAPI mciFreeCommandResource32(UINT32 uTable)
1512 {
1513 FIXME(mci, "(%08x) stub\n", uTable);
1514 return 0;
1515 }
1516
1517 /**************************************************************************
1518 * mciLoadCommandResource [WINMM.48]
1519 */
1520 UINT32 WINAPI mciLoadCommandResource32(HANDLE32 hinst, LPCSTR resname,UINT32 type)
1521 {
1522 return mciLoadCommandResource16(hinst, resname, type);
1523 }
1524
1525 const char* MCI_CommandToString(UINT16 wMsg)
1526 {
1527 static char buffer[100];
1528
1529 #define CASE(s) case (s): return #s
1530
1531 switch (wMsg) {
1532 CASE(MCI_OPEN);
1533 CASE(MCI_CLOSE);
1534 CASE(MCI_ESCAPE);
1535 CASE(MCI_PLAY);
1536 CASE(MCI_SEEK);
1537 CASE(MCI_STOP);
1538 CASE(MCI_PAUSE);
1539 CASE(MCI_INFO);
1540 CASE(MCI_GETDEVCAPS);
1541 CASE(MCI_SPIN);
1542 CASE(MCI_SET);
1543 CASE(MCI_STEP);
1544 CASE(MCI_RECORD);
1545 CASE(MCI_SYSINFO);
1546 CASE(MCI_BREAK);
1547 CASE(MCI_SAVE);
1548 CASE(MCI_STATUS);
1549 CASE(MCI_CUE);
1550 CASE(MCI_REALIZE);
1551 CASE(MCI_WINDOW);
1552 CASE(MCI_PUT);
1553 CASE(MCI_WHERE);
1554 CASE(MCI_FREEZE);
1555 CASE(MCI_UNFREEZE);
1556 CASE(MCI_LOAD);
1557 CASE(MCI_CUT);
1558 CASE(MCI_COPY);
1559 CASE(MCI_PASTE);
1560 CASE(MCI_UPDATE);
1561 CASE(MCI_RESUME);
1562 CASE(MCI_DELETE);
1563 default:
1564 sprintf(buffer, "MCI_<<%04X>>", wMsg);
1565 return buffer;
1566 }
1567 }
1568
1569 /**************************************************************************
1570 * MCI_SendCommand32 [internal]
1571 */
1572 DWORD MCI_SendCommand32(UINT32 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1573 {
1574 DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
1575
1576 if (!MCI_DevIDValid(wDevID)) {
1577 dwRet = MCIERR_INVALID_DEVICE_ID;
1578 } else {
1579 MCIPROC32 proc = MCI_GetProc32(MCI_GetDrv(wDevID)->modp.wType);
1580
1581 if (proc) {
1582 dwRet = (*proc)(MCI_GetDrv(wDevID)->modp.wDeviceID,
1583 MCI_GetDrv(wDevID)->hDrv,
1584 wMsg, dwParam1, dwParam2);
1585 } else if (MCI_GetDrv(wDevID)->driverProc) {
1586 FIXME(mmsys, "is that correct ?\n");
1587 dwRet = Callbacks->CallDriverProc(MCI_GetDrv(wDevID)->driverProc,
1588 MCI_GetDrv(wDevID)->modp.wDeviceID,
1589 MCI_GetDrv(wDevID)->hDrv,
1590 wMsg, dwParam1, dwParam2);
1591 } else {
1592 WARN(mmsys, "unknown device type=%04X !\n", MCI_GetDrv(wDevID)->modp.wType);
1593 }
1594 }
1595 return dwRet;
1596 }
1597
1598 /**************************************************************************
1599 * MCI_Open [internal]
1600 */
1601 static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMS32A lpParms)
1602 {
1603 char str[128];
1604 UINT16 uDevTyp = 0;
1605 UINT16 wDevID = MCI_FirstDevID();
1606 DWORD dwRet;
1607
1608 TRACE(mmsys, "(%08lX, %p)\n", dwParam, lpParms);
1609 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1610
1611 if ((dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)) != 0) {
1612 FIXME(mmsys, "unsupported yet dwFlags=%08lX\n",
1613 (dwParam & ~(MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)));
1614 }
1615
1616 while (MCI_GetDrv(wDevID)->modp.wType != 0) {
1617 wDevID = MCI_NextDevID(wDevID);
1618 if (!MCI_DevIDValid(wDevID)) {
1619 TRACE(mmsys, "MAXMCIDRIVERS reached !\n");
1620 return MCIERR_OUT_OF_MEMORY;
1621 }
1622 }
1623
1624 TRACE(mmsys, "wDevID=%04X \n", wDevID);
1625 memcpy(MCI_GetOpenDrv(wDevID), lpParms, sizeof(*lpParms));
1626
1627 if (dwParam & MCI_OPEN_ELEMENT) {
1628 char *s,*t;
1629
1630 TRACE(mmsys,"lpstrElementName='%s'\n", lpParms->lpstrElementName);
1631 s = lpParms->lpstrElementName;
1632 t = strrchr(s, '.');
1633 if (t) {
1634 GetProfileString32A("mci extensions", t+1, "*", str, sizeof(str));
1635 CharUpper32A(str);
1636 uDevTyp = MCI_GetDevType(str);
1637 if (uDevTyp == 0) {
1638 if (strcmp(str,"*") == 0) {
1639 TRACE(mmsys,"No [mci extensions] entry for %s found.\n", t);
1640 return MCIERR_EXTENSION_NOT_FOUND;
1641 }
1642 #if testing32
1643 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
1644 else {
1645 HDRVR16 hdrv = OpenDriver32(str, "mci", NULL);
1646 if (hdrv) {
1647 HMODULE16 hmod;
1648
1649 hmod = GetDriverModuleHandle(hdrv);
1650 MCI_GetDrv(wDevID)->hDrv = hdrv;
1651 MCI_GetDrv(wDevID)->driverProc = GetProcAddress32(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DriverProc")));
1652 uDevTyp = MCI_DEVTYPE_OTHER;
1653 } else {
1654 FIXME(mmsys, "[mci extensions] entry %s for %s not supported.\n", str, t);
1655 return MCIERR_DEVICE_NOT_INSTALLED;
1656 }
1657 }
1658 #endif
1659 }
1660 } else if (GetDriveType32A(s) == DRIVE_CDROM) {
1661 /* FIXME: this will not work if several CDROM drives are installed on the machine */
1662 uDevTyp = MCI_DEVTYPE_CD_AUDIO;
1663 } else {
1664 return MCIERR_EXTENSION_NOT_FOUND;
1665 }
1666 }
1667
1668 if (dwParam & MCI_OPEN_ALIAS) {
1669 TRACE(mmsys, "Alias='%s' !\n", lpParms->lpstrAlias);
1670 /* FIXME is there any memory leak here ? */
1671 MCI_GetOpenDrv(wDevID)->lpstrAlias = strdup(lpParms->lpstrAlias);
1672 /* mplayer does allocate alias to CDAUDIO */
1673 }
1674 if (dwParam & MCI_OPEN_TYPE) {
1675 if (dwParam & MCI_OPEN_TYPE_ID) {
1676 TRACE(mmsys, "Dev=%08lx!\n", (DWORD)lpParms->lpstrDeviceType);
1677 uDevTyp = LOWORD((DWORD)lpParms->lpstrDeviceType);
1678 MCI_GetOpenDrv(wDevID)->lpstrDeviceType = lpParms->lpstrDeviceType;
1679 } else {
1680 if (lpParms->lpstrDeviceType == NULL)
1681 return MCIERR_NULL_PARAMETER_BLOCK;
1682 TRACE(mmsys, "Dev='%s' !\n", lpParms->lpstrDeviceType);
1683 /* FIXME is there any memory leak here ? */
1684 MCI_GetOpenDrv(wDevID)->lpstrDeviceType = strdup(lpParms->lpstrDeviceType);
1685 strcpy(str, lpParms->lpstrDeviceType);
1686 CharUpper32A(str);
1687 uDevTyp = MCI_GetDevType(str);
1688 if (uDevTyp == 0) {
1689 #if testing32
1690 /* FIXME has to be re-written, seems to be experimental 16 bit code anyway */
1691 HDRVR16 hdrv;
1692 TRACE(mmsys,"trying to load driver...\n");
1693 hdrv = OpenDriver32(str,"mci",NULL);
1694 if (hdrv) {
1695 HMODULE16 hmod;
1696
1697 hmod = GetDriverModuleHandle(hdrv);
1698 MCI_GetDrv(wDevID)->hDrv = hdrv;
1699 MCI_GetDrv(wDevID)->driverProc = GetProcAddress32(hmod,oouch SEGPTR_GET(SEGPTR_STRDUP("DriverProc")));
1700 uDevTyp = MCI_DEVTYPE_OTHER;
1701 } else
1702 #endif
1703 return MCIERR_DEVICE_NOT_INSTALLED;
1704 }
1705 }
1706 }
1707 MCI_GetDrv(wDevID)->modp.wType = uDevTyp;
1708 MCI_GetDrv(wDevID)->modp.wDeviceID = 0; /* FIXME? for multiple devices */
1709 lpParms->wDeviceID = wDevID;
1710 TRACE(mmsys, "mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
1711 wDevID, uDevTyp, lpParms->wDeviceID);
1712 dwRet = MCI_SendCommand32(wDevID, MCI_OPEN_DRIVER, dwParam, (DWORD)lpParms);
1713
1714 if (dwRet == 0) {
1715 /* only handled devices fall through */
1716 TRACE(mmsys, "wDevID = %04X wDeviceID = %d dwRet = %ld\n", wDevID, lpParms->wDeviceID, dwRet);
1717 } else {
1718 TRACE(mmsys, "failed to open driver (MCI_OPEN_DRIVER msg) [%08lx], closing\n", dwRet);
1719 MCI_GetDrv(wDevID)->modp.wType = 0;
1720 }
1721 if (dwParam & MCI_NOTIFY)
1722 mciDriverNotify16(lpParms->dwCallback, wDevID, dwRet == 0 ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
1723
1724 return dwRet;
1725 }
1726
1727 /**************************************************************************
1728 * MCI_Close [internal]
1729 */
1730 static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
1731 {
1732 DWORD dwRet;
1733
1734 TRACE(mmsys, "(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
1735
1736 if (wDevID == MCI_ALL_DEVICE_ID) {
1737 FIXME(mmsys, "unhandled MCI_ALL_DEVICE_ID\n");
1738 return MCIERR_CANNOT_USE_ALL;
1739 }
1740
1741 dwRet = MCI_SendCommand32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
1742 MCI_GetDrv(wDevID)->modp.wType = 0;
1743
1744 if (dwParam&MCI_NOTIFY)
1745 mciDriverNotify16(lpParms->dwCallback, wDevID,
1746 (dwRet==0?MCI_NOTIFY_SUCCESSFUL:MCI_NOTIFY_FAILURE));
1747
1748 TRACE(mmsys, "returns %ld\n", dwRet);
1749 return dwRet;
1750 }
1751
1752 /**************************************************************************
1753 * MCI_WriteString [internal]
1754 */
1755 DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
1756 {
1757 DWORD ret;
1758
1759 if (dstSize <= strlen(lpSrcStr)) {
1760 lstrcpyn32A(lpDstStr, lpSrcStr, dstSize - 1);
1761 ret = MCIERR_PARAM_OVERFLOW;
1762 } else {
1763 strcpy(lpDstStr, lpSrcStr);
1764 ret = 0;
1765 }
1766 return ret;
1767 }
1768
1769 /**************************************************************************
1770 * MCI_Sysinfo [internal]
1771 */
1772 static DWORD MCI_SysInfo(UINT32 uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMS32A lpParms)
1773 {
1774 DWORD ret = MCIERR_INVALID_DEVICE_ID;
1775
1776 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1777
1778 TRACE(mci, "(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
1779 uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
1780
1781 switch (dwFlags & ~MCI_SYSINFO_OPEN) {
1782 case MCI_SYSINFO_QUANTITY:
1783 {
1784 DWORD cnt = 0;
1785 WORD i;
1786
1787 if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
1788 if (dwFlags & MCI_SYSINFO_OPEN) {
1789 TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1790 for (i = 0; i < MAXMCIDRIVERS; i++) {
1791 if (mciDrv[i].modp.wType != 0) cnt++;
1792 }
1793 } else {
1794 TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1795 cnt = mciInstalledCount;
1796 }
1797 } else {
1798 if (dwFlags & MCI_SYSINFO_OPEN) {
1799 TRACE(mci, "MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms->wDeviceType);
1800 for (i = 0; i < MAXMCIDRIVERS; i++) {
1801 if (mciDrv[i].modp.wType == lpParms->wDeviceType) cnt++;
1802 }
1803 } else {
1804 TRACE(mci, "MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms->wDeviceType);
1805 FIXME(mci, "Don't know how to get # of MCI devices of a given type\n");
1806 cnt = 1;
1807 }
1808 }
1809 *(DWORD*)lpParms->lpstrReturn = cnt;
1810 }
1811 TRACE(mci, "(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
1812 ret = 0;
1813 break;
1814 case MCI_SYSINFO_INSTALLNAME:
1815 TRACE(mci, "MCI_SYSINFO_INSTALLNAME \n");
1816 if (MCI_DevIDValid(uDevID)) {
1817 LPCSTR str = MCI_GetDevTypeString(MCI_GetDrv(uDevID)->modp.wType);
1818 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, str);
1819 } else {
1820 *lpParms->lpstrReturn = 0;
1821 ret = MCIERR_INVALID_DEVICE_ID;
1822 }
1823 TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
1824 break;
1825 case MCI_SYSINFO_NAME:
1826 TRACE(mci, "MCI_SYSINFO_NAME\n");
1827 if (dwFlags & MCI_SYSINFO_OPEN) {
1828 FIXME(mci, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
1829 ret = MCIERR_UNRECOGNIZED_COMMAND;
1830 } else if (lpParms->dwNumber > mciInstalledCount) {
1831 ret = MCIERR_OUTOFRANGE;
1832 } else {
1833 DWORD count = lpParms->dwNumber;
1834 LPSTR ptr = lpmciInstallNames;
1835
1836 while (--count > 0) ptr += strlen(ptr) + 1;
1837 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
1838 }
1839 TRACE(mci, "(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
1840 break;
1841 default:
1842 TRACE(mci, "Unsupported flag value=%08lx\n", dwFlags);
1843 ret = MCIERR_UNRECOGNIZED_COMMAND;
1844 }
1845 return ret;
1846 }
1847
1848 struct SCA32 {
1849 UINT32 wDevID;
1850 UINT32 wMsg;
1851 DWORD dwParam1;
1852 DWORD dwParam2;
1853 };
1854
1855 DWORD WINAPI mciSendCommand32A(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2);
1856
1857 /**************************************************************************
1858 * MCI_SCAStarter32 [internal]
1859 */
1860 static DWORD WINAPI MCI_SCAStarter32(LPVOID arg)
1861 {
1862 struct SCA32* sca = (struct SCA32*)arg;
1863 DWORD ret;
1864
1865 TRACE(mci, "In thread before async command (%08x,%s,%08lx,%08lx)\n",
1866 sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
1867 ret = mciSendCommand32A(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
1868 TRACE(mci, "In thread after async command (%08x,%s,%08lx,%08lx)\n",
1869 sca->wDevID, MCI_CommandToString(sca->wMsg), sca->dwParam1, sca->dwParam2);
1870 free(sca);
1871 ExitThread(ret);
1872 WARN(mci, "Should not happen ? what's wrong \n");
1873 /* should not go after this point */
1874 return ret;
1875 }
1876
1877 /**************************************************************************
1878 * MCI_SendCommandAsync32 [internal]
1879 */
1880 DWORD MCI_SendCommandAsync32(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2)
1881 {
1882 struct SCA32* sca = malloc(sizeof(struct SCA32));
1883
1884 if (sca == 0) return MCIERR_OUT_OF_MEMORY;
1885
1886 sca->wDevID = wDevID;
1887 sca->wMsg = wMsg;
1888 sca->dwParam1 = dwParam1;
1889 sca->dwParam2 = dwParam2;
1890
1891 if (CreateThread(NULL, 0, MCI_SCAStarter32, sca, 0, NULL) == 0) {
1892 WARN(mci, "Couldn't allocate thread for async command handling, sending synchonously\n");
1893 return MCI_SCAStarter32(&sca);
1894 }
1895 return 0;
1896 }
1897
1898 /**************************************************************************
1899 * MCI_MapMsg16To32A [internal]
1900 */
1901 int MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
1902 {
1903 if (*lParam == 0)
1904 return 0;
1905 /* FIXME: to add also (with seg/linear modifications to do):
1906 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1907 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO, MCI_WINDOW
1908 */
1909 switch (wMsg) {
1910 /* case MCI_CAPTURE */
1911 case MCI_CLOSE:
1912 case MCI_CLOSE_DRIVER:
1913 /* case MCI_CONFIGURE:*/
1914 case MCI_COPY:
1915 case MCI_CUE:
1916 case MCI_CUT:
1917 case MCI_DELETE:
1918 case MCI_FREEZE:
1919 case MCI_GETDEVCAPS:
1920 /* case MCI_INDEX: */
1921 /* case MCI_MARK: */
1922 /* case MCI_MONITOR: */
1923 case MCI_PASTE:
1924 case MCI_PAUSE:
1925 case MCI_PLAY:
1926 case MCI_PUT:
1927 case MCI_REALIZE:
1928 case MCI_RECORD:
1929 case MCI_RESUME:
1930 case MCI_SEEK:
1931 case MCI_SET:
1932 /* case MCI_SETTIMECODE:*/
1933 /* case MCI_SIGNAL:*/
1934 case MCI_SPIN:
1935 case MCI_STATUS: /* FIXME: is wrong for digital video */
1936 case MCI_STEP:
1937 case MCI_STOP:
1938 /* case MCI_UNDO: */
1939 case MCI_UNFREEZE:
1940 case MCI_UPDATE:
1941 case MCI_WHERE:
1942 *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
1943 return 0;
1944 case MCI_BREAK:
1945 {
1946 LPMCI_BREAK_PARMS32 mbp32 = HeapAlloc(SystemHeap, 0, sizeof(MCI_BREAK_PARMS32));
1947 LPMCI_BREAK_PARMS16 mbp16 = PTR_SEG_TO_LIN(*lParam);
1948
1949 if (mbp32) {
1950 mbp32->dwCallback = mbp16->dwCallback;
1951 mbp32->nVirtKey = mbp16->nVirtKey;
1952 mbp32->hwndBreak = mbp16->hwndBreak;
1953 } else {
1954 return -2;
1955 }
1956 *lParam = (DWORD)mbp32;
1957 }
1958 return 1;
1959 case MCI_ESCAPE:
1960 {
1961 LPMCI_VD_ESCAPE_PARMS32A mvep32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_VD_ESCAPE_PARMS32A));
1962 LPMCI_VD_ESCAPE_PARMS16 mvep16 = PTR_SEG_TO_LIN(*lParam);
1963
1964 if (mvep32a) {
1965 mvep32a->dwCallback = mvep16->dwCallback;
1966 mvep32a->lpstrCommand = PTR_SEG_TO_LIN(mvep16->lpstrCommand);
1967 } else {
1968 return -2;
1969 }
1970 *lParam = (DWORD)mvep32a;
1971 }
1972 return 1;
1973 case MCI_INFO:
1974 {
1975 LPMCI_INFO_PARMS32A mip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_INFO_PARMS32A));
1976 LPMCI_INFO_PARMS16 mip16 = PTR_SEG_TO_LIN(*lParam);
1977
1978 /* FIXME this is wrong if device is of type
1979 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1980 */
1981 if (mip32a) {
1982 mip32a->dwCallback = mip16->dwCallback;
1983 mip32a->lpstrReturn = PTR_SEG_TO_LIN(mip16->lpstrReturn);
1984 mip32a->dwRetSize = mip16->dwRetSize;
1985 } else {
1986 return -2;
1987 }
1988 *lParam = (DWORD)mip32a;
1989 }
1990 return 1;
1991 case MCI_OPEN:
1992 case MCI_OPEN_DRIVER:
1993 {
1994 LPMCI_OPEN_PARMS32A mop32a = HeapAlloc(SystemHeap, 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMS32A) + 2 * sizeof(DWORD));
1995 LPMCI_OPEN_PARMS16 mop16 = PTR_SEG_TO_LIN(*lParam);
1996
1997 if (mop32a) {
1998 *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
1999 mop32a = (LPMCI_OPEN_PARMS32A)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
2000 mop32a->dwCallback = mop16->dwCallback;
2001 mop32a->wDeviceID = mop16->wDeviceID;
2002 mop32a->lpstrDeviceType = PTR_SEG_TO_LIN(mop16->lpstrDeviceType);
2003 mop32a->lpstrElementName = PTR_SEG_TO_LIN(mop16->lpstrElementName);
2004 mop32a->lpstrAlias = PTR_SEG_TO_LIN(mop16->lpstrAlias);
2005 /* copy extended information if any...
2006 * FIXME: this may seg fault if initial structure does not contain them and
2007 * the reads after msip16 fail under LDT limits...
2008 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
2009 * should not take care of extended parameters, and should be used by MCI_Open
2010 * to fetch uDevTyp. When, this is known, the mapping for sending the
2011 * MCI_OPEN_DRIVER shall be done depending on uDevTyp.
2012 */
2013 ((DWORD*)(mop32a + 1))[0] = ((DWORD*)(mop16 + 1))[0];
2014 ((DWORD*)(mop32a + 1))[1] = ((DWORD*)(mop16 + 1))[1];
2015 } else {
2016 return -2;
2017 }
2018 *lParam = (DWORD)mop32a;
2019 }
2020 return 1;
2021 case MCI_SYSINFO:
2022 {
2023 LPMCI_SYSINFO_PARMS32A msip32a = HeapAlloc(SystemHeap, 0, sizeof(MCI_SYSINFO_PARMS32A));
2024 LPMCI_SYSINFO_PARMS16 msip16 = PTR_SEG_TO_LIN(*lParam);
2025
2026 if (msip32a) {
2027 msip32a->dwCallback = msip16->dwCallback;
2028 msip32a->lpstrReturn = PTR_SEG_TO_LIN(msip16->lpstrReturn);
2029 msip32a->dwRetSize = msip16->dwRetSize;
2030 msip32a->dwNumber = msip16->dwNumber;
2031 msip32a->wDeviceType = msip16->wDeviceType;
2032 } else {
2033 return -2;
2034 }
2035 *lParam = (DWORD)msip32a;
2036 }
2037 return 1;
2038 case DRV_LOAD:
2039 case DRV_ENABLE:
2040 case DRV_OPEN:
2041 case DRV_CLOSE:
2042 case DRV_DISABLE:
2043 case DRV_FREE:
2044 case DRV_CONFIGURE:
2045 case DRV_QUERYCONFIGURE:
2046 case DRV_INSTALL:
2047 case DRV_REMOVE:
2048 case DRV_EXITSESSION:
2049 case DRV_EXITAPPLICATION:
2050 case DRV_POWER:
2051 FIXME(mci, "This is a hack\n");
2052 return 0;
2053
2054 default:
2055 WARN(mci, "Don't know how to map msg=%s\n", MCI_CommandToString(wMsg));
2056 }
2057 return -1;
2058 }
2059
2060 /**************************************************************************
2061 * MCI_UnMapMsg16To32A [internal]
2062 */
2063 int MCI_UnMapMsg16To32A(WORD uDevTyp, WORD wMsg, DWORD lParam)
2064 {
2065 switch (wMsg) {
2066 /* case MCI_CAPTURE */
2067 case MCI_CLOSE:
2068 case MCI_CLOSE_DRIVER:
2069 /* case MCI_CONFIGURE:*/
2070 case MCI_COPY:
2071 case MCI_CUE:
2072 case MCI_CUT:
2073 case MCI_DELETE:
2074 case MCI_FREEZE:
2075 case MCI_GETDEVCAPS:
2076 /* case MCI_INDEX: */
2077 /* case MCI_MARK: */
2078 /* case MCI_MONITOR: */
2079 case MCI_PASTE:
2080 case MCI_PAUSE:
2081 case MCI_PLAY:
2082 case MCI_PUT:
2083 case MCI_REALIZE:
2084 case MCI_RECORD:
2085 case MCI_RESUME:
2086 case MCI_SEEK:
2087 case MCI_SET:
2088 /* case MCI_SETTIMECODE:*/
2089 /* case MCI_SIGNAL:*/
2090 case MCI_SPIN:
2091 case MCI_STATUS:
2092 case MCI_STEP:
2093 case MCI_STOP:
2094 /* case MCI_UNDO: */
2095 case MCI_UNFREEZE:
2096 case MCI_UPDATE:
2097 case MCI_WHERE:
2098 return 0;
2099
2100 case MCI_BREAK:
2101 case MCI_ESCAPE:
2102 case MCI_INFO:
2103 case MCI_SYSINFO:
2104 HeapFree(SystemHeap, 0, (LPVOID)lParam);
2105 return 0;
2106 case MCI_OPEN:
2107 case MCI_OPEN_DRIVER:
2108 if (lParam) {
2109 LPMCI_OPEN_PARMS32A mop32a = (MCI_OPEN_PARMS32A*)lParam;
2110 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16*));
2111
2112 mop16->wDeviceID = mop32a->wDeviceID;
2113 HeapFree(SystemHeap, 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16)));
2114 }
2115 return 0;
2116 case DRV_LOAD:
2117 case DRV_ENABLE:
2118 case DRV_OPEN:
2119 case DRV_CLOSE:
2120 case DRV_DISABLE:
2121 case DRV_FREE:
2122 case DRV_CONFIGURE:
2123 case DRV_QUERYCONFIGURE:
2124 case DRV_INSTALL:
2125 case DRV_REMOVE:
2126 case DRV_EXITSESSION:
2127 case DRV_EXITAPPLICATION:
2128 case DRV_POWER:
2129 FIXME(mci, "This is a hack\n");
2130 return 0;
2131 default:
2132 FIXME(mci, "Map/Unmap internal error on msg=%s\n", MCI_CommandToString(wMsg));
2133 }
2134 return -1;
2135 }
2136
2137 /**************************************************************************
2138 * mciSendCommandA [WINMM.49]
2139 */
2140 DWORD WINAPI mciSendCommand32A(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2)
2141 {
2142 TRACE(mci, "(%08x,%s,%08lx,%08lx)\n", wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
2143
2144 switch (wMsg) {
2145 case MCI_OPEN:
2146 return MCI_Open(dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2);
2147 case MCI_CLOSE:
2148 return MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2149 case MCI_SYSINFO:
2150 return MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMS32A)dwParam2);
2151 default:
2152 if (wDevID == MCI_ALL_DEVICE_ID) {
2153 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
2154 return MCIERR_CANNOT_USE_ALL;
2155 }
2156
2157 return MCI_SendCommand32(wDevID, wMsg, dwParam1, dwParam2);
2158 }
2159 }
2160
2161 /**************************************************************************
2162 * mciSendCommandW [WINMM.50]
2163 */
2164 DWORD WINAPI mciSendCommand32W(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2)
2165 {
2166 return 0x1; /* !ok */
2167 }
2168
2169 /**************************************************************************
2170 * mciSendCommand [MMSYSTEM.701]
2171 */
2172 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
2173 {
2174 DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND;
2175
2176 TRACE(mmsys, "(%04X, %s, %08lX, %08lX)\n",
2177 wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
2178
2179 switch (wMsg) {
2180 case MCI_OPEN:
2181 if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) {
2182 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2);
2183 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
2184 }
2185 break;
2186 case MCI_CLOSE:
2187 if (wDevID == MCI_ALL_DEVICE_ID) {
2188 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
2189 dwRet = MCIERR_CANNOT_USE_ALL;
2190 } else if (!MCI_DevIDValid(wDevID)) {
2191 dwRet = MCIERR_INVALID_DEVICE_ID;
2192 } else if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) {
2193 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2194 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
2195 }
2196 break;
2197 case MCI_SYSINFO:
2198 if (MCI_MapMsg16To32A(0, wDevID, &dwParam2) >= 0) {
2199 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMS32A)dwParam2);
2200 MCI_UnMapMsg16To32A(0, wDevID, dwParam2);
2201 }
2202 break;
2203 default:
2204 if (wDevID == MCI_ALL_DEVICE_ID) {
2205 FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
2206 dwRet = MCIERR_CANNOT_USE_ALL;
2207 } else if (!MCI_DevIDValid(wDevID)) {
2208 dwRet = MCIERR_INVALID_DEVICE_ID;
2209 } else {
2210 int res;
2211
2212 switch (res = MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2)) {
2213 case -1:
2214 TRACE(mci, "Not handled yet (%s)\n", MCI_CommandToString(wMsg));
2215 break;
2216 case -2:
2217 TRACE(mci, "Problem mapping msg=%s from 16 to 32a\n", MCI_CommandToString(wMsg));
2218 case 0:
2219 case 1:
2220 dwRet = MCI_SendCommand32(wDevID, wMsg, dwParam1, dwParam2);
2221 if (res)
2222 MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
2223 break;
2224 }
2225 }
2226 }
2227 return dwRet;
2228 }
2229
2230 /**************************************************************************
2231 * mciGetDeviceID [MMSYSTEM.703]
2232 */
2233 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
2234 {
2235 UINT16 wDevID;
2236
2237 TRACE(mmsys, "(\"%s\")\n", lpstrName);
2238
2239 if (!lpstrName)
2240 return 0;
2241
2242 if (!lstrcmpi32A(lpstrName, "ALL"))
2243 return MCI_ALL_DEVICE_ID;
2244
2245 wDevID = MCI_FirstDevID();
2246 while (MCI_DevIDValid(wDevID) && MCI_GetDrv(wDevID)->modp.wType) {
2247 if (MCI_GetOpenDrv(wDevID)->lpstrDeviceType &&
2248 strcmp(MCI_GetOpenDrv(wDevID)->lpstrDeviceType, lpstrName) == 0)
2249 return wDevID;
2250
2251 if (MCI_GetOpenDrv(wDevID)->lpstrAlias &&
2252 strcmp(MCI_GetOpenDrv(wDevID)->lpstrAlias, lpstrName) == 0)
2253 return wDevID;
2254
2255 wDevID = MCI_NextDevID(wDevID);
2256 }
2257
2258 return 0;
2259 }
2260
2261 /**************************************************************************
2262 * mciGetDeviceIDA [WINMM.41]
2263 */
2264 UINT32 WINAPI mciGetDeviceID32A(LPCSTR lpstrName)
2265 {
2266 return mciGetDeviceID16(lpstrName);
2267 }
2268
2269 /**************************************************************************
2270 * mciGetDeviceIDW [WINMM.43]
2271 */
2272 UINT32 WINAPI mciGetDeviceID32W(LPCWSTR lpwstrName)
2273 {
2274 LPSTR lpstrName;
2275 UINT32 ret;
2276
2277 lpstrName = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrName);
2278 ret = mciGetDeviceID16(lpstrName);
2279 HeapFree(GetProcessHeap(), 0, lpstrName);
2280 return ret;
2281 }
2282
2283 /**************************************************************************
2284 * mciSetYieldProc [MMSYSTEM.714]
2285 */
2286 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID,
2287 YIELDPROC fpYieldProc, DWORD dwYieldData)
2288 {
2289 FIXME(mci, "(%u, %p, %08lx) stub\n", uDeviceID, fpYieldProc, dwYieldData);
2290 return FALSE;
2291 }
2292
2293 /**************************************************************************
2294 * mciSetYieldProc [WINMM.54]
2295 */
2296 BOOL32 WINAPI mciSetYieldProc32(UINT32 uDeviceID,
2297 YIELDPROC fpYieldProc, DWORD dwYieldData)
2298 {
2299 FIXME(mci, "(%u, %p, %08lx) stub\n", uDeviceID, fpYieldProc, dwYieldData);
2300 return FALSE;
2301 }
2302
2303 /**************************************************************************
2304 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
2305 */
2306 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
2307 {
2308 FIXME(mci, "(%lu, %s) stub\n", dwElementID, lpstrType);
2309 return 0;
2310 }
2311
2312 /**************************************************************************
2313 * mciGetDeviceIDFromElementIDW [WINMM.42]
2314 */
2315 UINT32 WINAPI mciGetDeviceIDFromElementID32W(DWORD dwElementID, LPCWSTR lpstrType)
2316 {
2317 /* FIXME: that's rather strange, there is no
2318 * mciGetDeviceIDFromElementID32A in winmm.spec
2319 */
2320 FIXME(mci, "(%lu, %p) stub\n", dwElementID, lpstrType);
2321 return 0;
2322 }
2323
2324 /**************************************************************************
2325 * mciGetYieldProc [MMSYSTEM.716]
2326 */
2327 YIELDPROC WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
2328 {
2329 FIXME(mci, "(%u, %p) stub\n", uDeviceID, lpdwYieldData);
2330 return NULL;
2331 }
2332
2333 /**************************************************************************
2334 * mciGetYieldProc [WINMM.47]
2335 */
2336 YIELDPROC WINAPI mciGetYieldProc32(UINT32 uDeviceID, DWORD* lpdwYieldData)
2337 {
2338 FIXME(mci, "(%u, %p) stub\n", uDeviceID, lpdwYieldData);
2339 return NULL;
2340 }
2341
2342 /**************************************************************************
2343 * mciGetCreatorTask [MMSYSTEM.717]
2344 */
2345 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
2346 {
2347 FIXME(mci, "(%u) stub\n", uDeviceID);
2348 return 0;
2349 }
2350
2351 /**************************************************************************
2352 * mciGetCreatorTask [WINMM.40]
2353 */
2354 HTASK32 WINAPI mciGetCreatorTask32(UINT32 uDeviceID)
2355 {
2356 FIXME(mci, "(%u) stub\n", uDeviceID);
2357 return 0;
2358 }
2359
2360 /**************************************************************************
2361 * mciDriverYield [MMSYSTEM.710]
2362 */
2363 UINT16 WINAPI mciDriverYield16(HANDLE16 hnd)
2364 {
2365 FIXME(mmsys,"(%04x): stub!\n", hnd);
2366 return 0;
2367 }
2368
2369 /**************************************************************************
2370 * mciDriverYield [WINMM.37]
2371 */
2372 UINT32 WINAPI mciDriverYield32(HANDLE32 hnd)
2373 {
2374 FIXME(mmsys,"(%04x): stub!\n", hnd);
2375 return 0;
2376 }
2377
2378 /**************************************************************************
2379 * midiOutGetNumDevs [WINMM.80]
2380 */
2381 UINT32 WINAPI midiOutGetNumDevs32(void)
2382 {
2383 return midiOutGetNumDevs16();
2384 }
2385
2386 /**************************************************************************
2387 * midiOutGetNumDevs [MMSYSTEM.201]
2388 */
2389 UINT16 WINAPI midiOutGetNumDevs16(void)
2390 {
2391 UINT16 count = modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
2392
2393 TRACE(mmsys, "returns %u\n", count);
2394 return count;
2395 }
2396
2397 /**************************************************************************
2398 * midiOutGetDevCapsW [WINMM.76]
2399 */
2400 UINT32 WINAPI midiOutGetDevCaps32W(UINT32 uDeviceID, LPMIDIOUTCAPS32W lpCaps, UINT32 uSize)
2401 {
2402 MIDIOUTCAPS16 moc16;
2403 UINT32 ret;
2404
2405 ret = midiOutGetDevCaps16(uDeviceID, &moc16, sizeof(moc16));
2406 lpCaps->wMid = moc16.wMid;
2407 lpCaps->wPid = moc16.wPid;
2408 lpCaps->vDriverVersion = moc16.vDriverVersion;
2409 lstrcpyAtoW(lpCaps->szPname, moc16.szPname);
2410 lpCaps->wTechnology = moc16.wTechnology;
2411 lpCaps->wVoices = moc16.wVoices;
2412 lpCaps->wNotes = moc16.wNotes;
2413 lpCaps->wChannelMask = moc16.wChannelMask;
2414 lpCaps->dwSupport = moc16.dwSupport;
2415 return ret;
2416 }
2417
2418 /**************************************************************************
2419 * midiOutGetDevCapsA [WINMM.75]
2420 */
2421 UINT32 WINAPI midiOutGetDevCaps32A(UINT32 uDeviceID, LPMIDIOUTCAPS32A lpCaps, UINT32 uSize)
2422 {
2423 MIDIOUTCAPS16 moc16;
2424 UINT32 ret;
2425
2426 ret = midiOutGetDevCaps16(uDeviceID, &moc16, sizeof(moc16));
2427 lpCaps->wMid = moc16.wMid;
2428 lpCaps->wPid = moc16.wPid;
2429 lpCaps->vDriverVersion = moc16.vDriverVersion;
2430 strcpy(lpCaps->szPname, moc16.szPname);
2431 lpCaps->wTechnology = moc16.wTechnology;
2432 lpCaps->wVoices = moc16.wVoices;
2433 lpCaps->wNotes = moc16.wNotes;
2434 lpCaps->wChannelMask = moc16.wChannelMask;
2435 lpCaps->dwSupport = moc16.dwSupport;
2436 return ret;
2437 }
2438
2439 /**************************************************************************
2440 * midiOutGetDevCaps [MMSYSTEM.202]
2441 */
2442 UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps, UINT16 uSize)
2443 {
2444 TRACE(mmsys, "midiOutGetDevCaps\n");
2445 return modMessage(uDeviceID, MODM_GETDEVCAPS, 0, (DWORD)lpCaps,uSize);
2446 }
2447
2448 /**************************************************************************
2449 * midiOutGetErrorTextA [WINMM.77]
2450 */
2451 UINT32 WINAPI midiOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2452 {
2453 TRACE(mmsys, "midiOutGetErrorText\n");
2454 return midiGetErrorText(uError, lpText, uSize);
2455 }
2456
2457 /**************************************************************************
2458 * midiOutGetErrorTextW [WINMM.78]
2459 */
2460 UINT32 WINAPI midiOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2461 {
2462 LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize);
2463 UINT32 ret;
2464
2465 TRACE(mmsys, "midiOutGetErrorText\n");
2466 ret = midiGetErrorText(uError, xstr, uSize);
2467 lstrcpyAtoW(lpText,xstr);
2468 HeapFree(GetProcessHeap(), 0,xstr);
2469 return ret;
2470 }
2471
2472 /**************************************************************************
2473 * midiOutGetErrorText [MMSYSTEM.203]
2474 */
2475 UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2476 {
2477 TRACE(mmsys, "midiOutGetErrorText\n");
2478 return midiGetErrorText(uError, lpText, uSize);
2479 }
2480
2481 /**************************************************************************
2482 * midiGetErrorText [internal]
2483 */
2484 UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
2485 {
2486 LPSTR msgptr;
2487 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
2488 lpText[0] = '\0';
2489 switch (uError) {
2490 case MIDIERR_UNPREPARED:
2491 msgptr = "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again.";
2492 break;
2493 case MIDIERR_STILLPLAYING:
2494 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
2495 break;
2496 case MIDIERR_NOMAP:
2497 msgptr = "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing.";
2498 break;
2499 case MIDIERR_NOTREADY:
2500 msgptr = "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again.";
2501 break;
2502 case MIDIERR_NODEVICE:
2503 msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.";
2504 break;
2505 case MIDIERR_INVALIDSETUP:
2506 msgptr = "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again.";
2507 break;
2508 /*
2509 msg# 336 : Cannot use the song-pointer time format and the SMPTE time-format together.
2510 msg# 337 : The specified MIDI device is already in use. Wait until it is free, and then try again.
2511 msg# 338 : The specified MIDI device is not installed on the system. Use the Drivers option in Control Panel to install the driver.
2512 msg# 339 : The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup.
2513 msg# 340 : An error occurred using the specified port.
2514 msg# 341 : All multimedia timers are being used by other applications. Quit one of these applications, and then try again.
2515 msg# 342 : There is no current MIDI port.
2516 msg# 343 : There are no MIDI devices installed on the system. Use the Drivers option in Control Panel to install the driver.
2517 */
2518 default:
2519 msgptr = "Unknown MIDI Error !\n";
2520 break;
2521 }
2522 lstrcpyn32A(lpText, msgptr, uSize);
2523 return TRUE;
2524 }
2525
2526 /**************************************************************************
2527 * midiOutOpen [WINM.84]
2528 */
2529 UINT32 WINAPI midiOutOpen32(HMIDIOUT32 * lphMidiOut, UINT32 uDeviceID,
2530 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2531 {
2532 HMIDIOUT16 hmo16;
2533 UINT32 ret;
2534
2535 ret = midiOutOpen16(&hmo16,uDeviceID, dwCallback, dwInstance,
2536 CALLBACK32CONV(dwFlags));
2537 if (lphMidiOut) *lphMidiOut = hmo16;
2538 return ret;
2539 }
2540
2541 /**************************************************************************
2542 * midiOutOpen [MMSYSTEM.204]
2543 */
2544 UINT16 WINAPI midiOutOpen16(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
2545 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2546 {
2547 HMIDI16 hMidiOut;
2548 LPMIDIOPENDESC lpDesc;
2549 DWORD dwRet = 0;
2550 BOOL32 bMapperFlg = FALSE;
2551
2552 if (lphMidiOut != NULL) *lphMidiOut = 0;
2553 TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
2554 lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
2555 if (uDeviceID == (UINT16)MIDI_MAPPER) {
2556 TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
2557 bMapperFlg = TRUE;
2558 uDeviceID = 0;
2559 }
2560 hMidiOut = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
2561 if (lphMidiOut != NULL)
2562 *lphMidiOut = hMidiOut;
2563 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2564 if (lpDesc == NULL)
2565 return MMSYSERR_NOMEM;
2566 lpDesc->hMidi = hMidiOut;
2567 lpDesc->dwCallback = dwCallback;
2568 lpDesc->dwInstance = dwInstance;
2569
2570 while (uDeviceID < MAXMIDIDRIVERS) {
2571 dwRet = modMessage(uDeviceID, MODM_OPEN,
2572 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
2573 if (dwRet == MMSYSERR_NOERROR) break;
2574 if (!bMapperFlg) break;
2575 uDeviceID++;
2576 TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
2577 }
2578 lpDesc->wDevID = uDeviceID;
2579 return dwRet;
2580 }
2581
2582 /**************************************************************************
2583 * midiOutClose [WINMM.74]
2584 */
2585 UINT32 WINAPI midiOutClose32(HMIDIOUT32 hMidiOut)
2586 {
2587 return midiOutClose16(hMidiOut);
2588 }
2589
2590 /**************************************************************************
2591 * midiOutClose [MMSYSTEM.205]
2592 */
2593 UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
2594 {
2595 LPMIDIOPENDESC lpDesc;
2596
2597 TRACE(mmsys, "(%04X)\n", hMidiOut);
2598
2599 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2600 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2601 return modMessage(lpDesc->wDevID, MODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
2602 }
2603
2604 /**************************************************************************
2605 * midiOutPrepareHeader [WINMM.85]
2606 */
2607 UINT32 WINAPI midiOutPrepareHeader32(HMIDIOUT32 hMidiOut,
2608 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
2609 {
2610 LPMIDIOPENDESC lpDesc;
2611
2612 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2613
2614 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2615 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2616 lpMidiOutHdr->reserved = (DWORD)lpMidiOutHdr->lpData;
2617 return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance,
2618 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2619 }
2620
2621 /**************************************************************************
2622 * midiOutPrepareHeader [MMSYSTEM.206]
2623 */
2624 UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,
2625 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
2626 {
2627 LPMIDIOPENDESC lpDesc;
2628
2629 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2630
2631 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2632 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2633 lpMidiOutHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiOutHdr->lpData);
2634 return modMessage(lpDesc->wDevID, MODM_PREPARE, lpDesc->dwInstance,
2635 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2636 }
2637
2638 /**************************************************************************
2639 * midiOutUnprepareHeader [WINMM.89]
2640 */
2641 UINT32 WINAPI midiOutUnprepareHeader32(HMIDIOUT32 hMidiOut,
2642 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
2643 {
2644 return midiOutUnprepareHeader16(hMidiOut, lpMidiOutHdr,uSize);
2645 }
2646
2647 /**************************************************************************
2648 * midiOutUnprepareHeader [MMSYSTEM.207]
2649 */
2650 UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,
2651 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
2652 {
2653 LPMIDIOPENDESC lpDesc;
2654
2655 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2656
2657 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2658 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2659 return modMessage(lpDesc->wDevID, MODM_UNPREPARE, lpDesc->dwInstance,
2660 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2661 }
2662
2663 /**************************************************************************
2664 * midiOutShortMsg [WINMM.88]
2665 */
2666 UINT32 WINAPI midiOutShortMsg32(HMIDIOUT32 hMidiOut, DWORD dwMsg)
2667 {
2668 return midiOutShortMsg16(hMidiOut, dwMsg);
2669 }
2670
2671 /**************************************************************************
2672 * midiOutShortMsg [MMSYSTEM.208]
2673 */
2674 UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
2675 {
2676 LPMIDIOPENDESC lpDesc;
2677
2678 TRACE(mmsys, "(%04X, %08lX)\n", hMidiOut, dwMsg);
2679
2680 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2681 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2682 return modMessage(lpDesc->wDevID, MODM_DATA, lpDesc->dwInstance, dwMsg, 0L);
2683 }
2684
2685 /**************************************************************************
2686 * midiOutLongMsg [WINMM.82]
2687 */
2688 UINT32 WINAPI midiOutLongMsg32(HMIDIOUT32 hMidiOut,
2689 MIDIHDR * lpMidiOutHdr, UINT32 uSize)
2690 {
2691 return midiOutLongMsg16(hMidiOut, lpMidiOutHdr,uSize);
2692 }
2693
2694 /**************************************************************************
2695 * midiOutLongMsg [MMSYSTEM.209]
2696 */
2697 UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut,
2698 MIDIHDR * lpMidiOutHdr, UINT16 uSize)
2699 {
2700 LPMIDIOPENDESC lpDesc;
2701
2702 TRACE(mmsys, "(%04X, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
2703
2704 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2705 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2706 return modMessage(lpDesc->wDevID, MODM_LONGDATA, lpDesc->dwInstance,
2707 (DWORD)lpMidiOutHdr, (DWORD)uSize);
2708 }
2709
2710 /**************************************************************************
2711 * midiOutReset [WINMM.86]
2712 */
2713 UINT32 WINAPI midiOutReset32(HMIDIOUT32 hMidiOut)
2714 {
2715 return midiOutReset16(hMidiOut);
2716 }
2717
2718 /**************************************************************************
2719 * midiOutReset [MMSYSTEM.210]
2720 */
2721 UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
2722 {
2723 LPMIDIOPENDESC lpDesc;
2724
2725 TRACE(mmsys, "(%04X)\n", hMidiOut);
2726
2727 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2728 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2729 return modMessage(lpDesc->wDevID, MODM_RESET, lpDesc->dwInstance, 0L, 0L);
2730 }
2731
2732 /**************************************************************************
2733 * midiOutGetVolume [WINM.81]
2734 */
2735 UINT32 WINAPI midiOutGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
2736 {
2737 return midiOutGetVolume16(uDeviceID, lpdwVolume);
2738 }
2739
2740 /**************************************************************************
2741 * midiOutGetVolume [MMSYSTEM.211]
2742 */
2743 UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
2744 {
2745 TRACE(mmsys, "(%04X, %p);\n", uDeviceID, lpdwVolume);
2746 return modMessage(uDeviceID, MODM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
2747 }
2748
2749 /**************************************************************************
2750 * midiOutSetVolume [WINMM.87]
2751 */
2752 UINT32 WINAPI midiOutSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
2753 {
2754 return midiOutSetVolume16(uDeviceID, dwVolume);
2755 }
2756
2757 /**************************************************************************
2758 * midiOutSetVolume [MMSYSTEM.212]
2759 */
2760 UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
2761 {
2762 TRACE(mmsys, "(%04X, %08lX);\n", uDeviceID, dwVolume);
2763 return modMessage(uDeviceID, MODM_SETVOLUME, 0L, dwVolume, 0L);
2764 }
2765
2766 /**************************************************************************
2767 * midiOutCachePatches [WINMM.73]
2768 */
2769 UINT32 WINAPI midiOutCachePatches32(HMIDIOUT32 hMidiOut, UINT32 uBank,
2770 WORD * lpwPatchArray, UINT32 uFlags)
2771 {
2772 return midiOutCachePatches16(hMidiOut,uBank, lpwPatchArray,uFlags);
2773 }
2774
2775 /**************************************************************************
2776 * midiOutCachePatches [MMSYSTEM.213]
2777 */
2778 UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
2779 WORD * lpwPatchArray, UINT16 uFlags)
2780 {
2781 /* not really necessary to support this */
2782 FIXME(mmsys, "not supported yet\n");
2783 return MMSYSERR_NOTSUPPORTED;
2784 }
2785
2786 /**************************************************************************
2787 * midiOutCacheDrumPatches [WINMM.72]
2788 */
2789 UINT32 WINAPI midiOutCacheDrumPatches32(HMIDIOUT32 hMidiOut, UINT32 uPatch,
2790 WORD * lpwKeyArray, UINT32 uFlags)
2791 {
2792 return midiOutCacheDrumPatches16(hMidiOut,uPatch, lpwKeyArray,uFlags);
2793 }
2794
2795 /**************************************************************************
2796 * midiOutCacheDrumPatches [MMSYSTEM.214]
2797 */
2798 UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
2799 WORD * lpwKeyArray, UINT16 uFlags)
2800 {
2801 FIXME(mmsys, "not supported yet\n");
2802 return MMSYSERR_NOTSUPPORTED;
2803 }
2804
2805 /**************************************************************************
2806 * midiOutGetID [WINMM.79]
2807 */
2808 UINT32 WINAPI midiOutGetID32(HMIDIOUT32 hMidiOut, UINT32 * lpuDeviceID)
2809 {
2810 UINT16 xid;
2811 UINT32 ret;
2812
2813 ret = midiOutGetID16(hMidiOut, &xid);
2814 *lpuDeviceID = xid;
2815 return ret;
2816 }
2817
2818 /**************************************************************************
2819 * midiOutGetID [MMSYSTEM.215]
2820 */
2821 UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID)
2822 {
2823 TRACE(mmsys, "midiOutGetID\n");
2824 return 0;
2825 }
2826
2827 /**************************************************************************
2828 * midiOutMessage [WINMM.83]
2829 */
2830 DWORD WINAPI midiOutMessage32(HMIDIOUT32 hMidiOut, UINT32 uMessage,
2831 DWORD dwParam1, DWORD dwParam2)
2832 {
2833 LPMIDIOPENDESC lpDesc;
2834
2835 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2836 hMidiOut, uMessage, dwParam1, dwParam2);
2837 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2838 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2839 switch (uMessage) {
2840 case MODM_OPEN:
2841 FIXME(mmsys,"can't handle MODM_OPEN!\n");
2842 return 0;
2843 case MODM_GETDEVCAPS:
2844 return midiOutGetDevCaps32A(hMidiOut, (LPMIDIOUTCAPS32A)dwParam1, dwParam2);
2845 case MODM_GETNUMDEVS:
2846 case MODM_RESET:
2847 case MODM_CLOSE:
2848 case MODM_GETVOLUME:
2849 case MODM_SETVOLUME:
2850 case MODM_LONGDATA:
2851 case MODM_PREPARE:
2852 case MODM_UNPREPARE:
2853 /* no argument conversion needed */
2854 break;
2855 default:
2856 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2857 hMidiOut,uMessage, dwParam1, dwParam2);
2858 break;
2859 }
2860 return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2861 }
2862
2863 /**************************************************************************
2864 * midiOutMessage [MMSYSTEM.216]
2865 */
2866 DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
2867 DWORD dwParam1, DWORD dwParam2)
2868 {
2869 LPMIDIOPENDESC lpDesc;
2870
2871 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
2872 hMidiOut, uMessage, dwParam1, dwParam2);
2873 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiOut);
2874 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
2875 switch (uMessage) {
2876 case MODM_OPEN:
2877 FIXME(mmsys,"can't handle MODM_OPEN!\n");
2878 return 0;
2879 case MODM_GETNUMDEVS:
2880 case MODM_RESET:
2881 case MODM_CLOSE:
2882 case MODM_SETVOLUME:
2883 /* no argument conversion needed */
2884 break;
2885 case MODM_GETVOLUME:
2886 return midiOutGetVolume16(hMidiOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
2887 case MODM_LONGDATA:
2888 return midiOutLongMsg16(hMidiOut, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2889 case MODM_PREPARE:
2890 return midiOutPrepareHeader16(hMidiOut, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2891 case MODM_UNPREPARE:
2892 return midiOutUnprepareHeader16(hMidiOut, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
2893 default:
2894 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
2895 hMidiOut,uMessage, dwParam1, dwParam2);
2896 break;
2897 }
2898 return modMessage(lpDesc->wDevID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
2899 }
2900
2901 /**************************************************************************
2902 * midiInGetNumDevs [WINMM.64]
2903 */
2904 UINT32 WINAPI midiInGetNumDevs32(void)
2905 {
2906 return midiInGetNumDevs16();
2907 }
2908
2909 /**************************************************************************
2910 * midiInGetNumDevs [MMSYSTEM.301]
2911 */
2912 UINT16 WINAPI midiInGetNumDevs16(void)
2913 {
2914 UINT16 count = 0;
2915 TRACE(mmsys, "midiInGetNumDevs\n");
2916 count += midMessage(0, MIDM_GETNUMDEVS, 0L, 0L, 0L);
2917 TRACE(mmsys, "midiInGetNumDevs return %u \n", count);
2918 return count;
2919 }
2920
2921 /**************************************************************************
2922 * midiInGetDevCaps [WINMM.60]
2923 */
2924 UINT32 WINAPI midiInGetDevCaps32W(UINT32 uDeviceID,
2925 LPMIDIINCAPS32W lpCaps, UINT32 uSize)
2926 {
2927 MIDIINCAPS16 mic16;
2928 UINT32 ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize);
2929
2930 lpCaps->wMid = mic16.wMid;
2931 lpCaps->wPid = mic16.wPid;
2932 lpCaps->vDriverVersion = mic16.vDriverVersion;
2933 lstrcpyAtoW(lpCaps->szPname, mic16.szPname);
2934 lpCaps->dwSupport = mic16.dwSupport;
2935 return ret;
2936 }
2937
2938 /**************************************************************************
2939 * midiInGetDevCaps [WINMM.59]
2940 */
2941 UINT32 WINAPI midiInGetDevCaps32A(UINT32 uDeviceID,
2942 LPMIDIINCAPS32A lpCaps, UINT32 uSize)
2943 {
2944 MIDIINCAPS16 mic16;
2945 UINT32 ret = midiInGetDevCaps16(uDeviceID, &mic16,uSize);
2946
2947 lpCaps->wMid = mic16.wMid;
2948 lpCaps->wPid = mic16.wPid;
2949 lpCaps->vDriverVersion = mic16.vDriverVersion;
2950 strcpy(lpCaps->szPname, mic16.szPname);
2951 lpCaps->dwSupport = mic16.dwSupport;
2952 return ret;
2953 }
2954
2955 /**************************************************************************
2956 * midiInGetDevCaps [MMSYSTEM.302]
2957 */
2958 UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID,
2959 LPMIDIINCAPS16 lpCaps, UINT16 uSize)
2960 {
2961 TRACE(mmsys, "midiInGetDevCaps\n");
2962 return midMessage(uDeviceID, MIDM_GETDEVCAPS, 0, (DWORD)lpCaps, uSize);
2963 }
2964
2965 /**************************************************************************
2966 * midiInGetErrorText [WINMM.62]
2967 */
2968 UINT32 WINAPI midiInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
2969 {
2970 LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize);
2971 UINT32 ret = midiInGetErrorText16(uError,xstr,uSize);
2972 lstrcpyAtoW(lpText,xstr);
2973 HeapFree(GetProcessHeap(), 0,xstr);
2974 return ret;
2975 }
2976
2977 /**************************************************************************
2978 * midiInGetErrorText [WINMM.61]
2979 */
2980 UINT32 WINAPI midiInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
2981 {
2982 return midiInGetErrorText16(uError, lpText,uSize);
2983 }
2984
2985 /**************************************************************************
2986 * midiInGetErrorText [MMSYSTEM.303]
2987 */
2988 UINT16 WINAPI midiInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
2989 {
2990 TRACE(mmsys, "midiInGetErrorText\n");
2991 return (midiGetErrorText(uError, lpText, uSize));
2992 }
2993
2994 /**************************************************************************
2995 * midiInOpen [WINMM.66]
2996 */
2997 UINT32 WINAPI midiInOpen32(HMIDIIN32 * lphMidiIn, UINT32 uDeviceID,
2998 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
2999 {
3000 HMIDIIN16 xhmid16;
3001 UINT32 ret = midiInOpen16(&xhmid16,uDeviceID, dwCallback, dwInstance,
3002 CALLBACK32CONV(dwFlags));
3003 if (lphMidiIn)
3004 *lphMidiIn = xhmid16;
3005 return ret;
3006 }
3007
3008 /**************************************************************************
3009 * midiInOpen [MMSYSTEM.304]
3010 */
3011 UINT16 WINAPI midiInOpen16(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
3012 DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
3013 {
3014 HMIDI16 hMidiIn;
3015 LPMIDIOPENDESC lpDesc;
3016 DWORD dwRet = 0;
3017 BOOL32 bMapperFlg = FALSE;
3018
3019 if (lphMidiIn != NULL)
3020 *lphMidiIn = 0;
3021 TRACE(mmsys, "(%p, %d, %08lX, %08lX, %08lX);\n",
3022 lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
3023 if (uDeviceID == (UINT16)MIDI_MAPPER) {
3024 TRACE(mmsys, "MIDI_MAPPER mode requested !\n");
3025 bMapperFlg = TRUE;
3026 uDeviceID = 0;
3027 }
3028 hMidiIn = USER_HEAP_ALLOC(sizeof(MIDIOPENDESC));
3029 if (lphMidiIn != NULL)
3030 *lphMidiIn = hMidiIn;
3031 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3032 if (lpDesc == NULL)
3033 return MMSYSERR_NOMEM;
3034 lpDesc->hMidi = hMidiIn;
3035 lpDesc->dwCallback = dwCallback;
3036 lpDesc->dwInstance = dwInstance;
3037
3038 while (uDeviceID < MAXMIDIDRIVERS) {
3039 dwRet = midMessage(uDeviceID, MIDM_OPEN,
3040 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
3041 if (dwRet == MMSYSERR_NOERROR)
3042 break;
3043 if (!bMapperFlg)
3044 break;
3045 uDeviceID++;
3046 TRACE(mmsys, "MIDI_MAPPER mode ! try next driver...\n");
3047 }
3048 lpDesc->wDevID = uDeviceID;
3049 return dwRet;
3050 }
3051
3052 /**************************************************************************
3053 * midiInClose [WINMM.58]
3054 */
3055 UINT32 WINAPI midiInClose32(HMIDIIN32 hMidiIn)
3056 {
3057 return midiInClose16(hMidiIn);
3058 }
3059
3060 /**************************************************************************
3061 * midiInClose [MMSYSTEM.305]
3062 */
3063 UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
3064 {
3065 LPMIDIOPENDESC lpDesc;
3066 TRACE(mmsys, "(%04X)\n", hMidiIn);
3067 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3068 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3069 return midMessage(lpDesc->wDevID, MIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3070 }
3071
3072 /**************************************************************************
3073 * midiInPrepareHeader [WINMM.67]
3074 */
3075 UINT32 WINAPI midiInPrepareHeader32(HMIDIIN32 hMidiIn,
3076 MIDIHDR * lpMidiInHdr, UINT32 uSize)
3077 {
3078 LPMIDIOPENDESC lpDesc;
3079
3080 TRACE(mmsys, "(%04X, %p, %d)\n",
3081 hMidiIn, lpMidiInHdr, uSize);
3082 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3083 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3084 lpMidiInHdr->reserved = (DWORD)lpMidiInHdr->lpData;
3085 return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance,
3086 (DWORD)lpMidiInHdr, (DWORD)uSize);
3087 }
3088
3089 /**************************************************************************
3090 * midiInPrepareHeader [MMSYSTEM.306]
3091 */
3092 UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,
3093 MIDIHDR * lpMidiInHdr, UINT16 uSize)
3094 {
3095 LPMIDIOPENDESC lpDesc;
3096
3097 TRACE(mmsys, "(%04X, %p, %d)\n",
3098 hMidiIn, lpMidiInHdr, uSize);
3099 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3100 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3101 lpMidiInHdr->reserved = (DWORD)PTR_SEG_TO_LIN(lpMidiInHdr->lpData);
3102 return midMessage(lpDesc->wDevID, MIDM_PREPARE, lpDesc->dwInstance,
3103 (DWORD)lpMidiInHdr, (DWORD)uSize);
3104 }
3105
3106 /**************************************************************************
3107 * midiInUnprepareHeader [WINMM.71]
3108 */
3109 UINT32 WINAPI midiInUnprepareHeader32(HMIDIIN32 hMidiIn,
3110 MIDIHDR * lpMidiInHdr, UINT32 uSize)
3111 {
3112 return midiInUnprepareHeader16(hMidiIn, lpMidiInHdr,uSize);
3113 }
3114
3115 /**************************************************************************
3116 * midiInUnprepareHeader [MMSYSTEM.307]
3117 */
3118 UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,
3119 MIDIHDR * lpMidiInHdr, UINT16 uSize)
3120 {
3121 LPMIDIOPENDESC lpDesc;
3122 TRACE(mmsys, "(%04X, %p, %d)\n",
3123 hMidiIn, lpMidiInHdr, uSize);
3124 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3125 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3126 return midMessage(lpDesc->wDevID, MIDM_UNPREPARE, lpDesc->dwInstance,
3127 (DWORD)lpMidiInHdr, (DWORD)uSize);
3128 }
3129
3130 /**************************************************************************
3131 * midiInAddBuffer [WINMM.57]
3132 */
3133 UINT32 WINAPI midiInAddBuffer32(HMIDIIN32 hMidiIn,
3134 MIDIHDR * lpMidiInHdr, UINT32 uSize)
3135 {
3136 return midiInAddBuffer16(hMidiIn, lpMidiInHdr,uSize);
3137 }
3138
3139 /**************************************************************************
3140 * midiInAddBuffer [MMSYSTEM.308]
3141 */
3142 UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,
3143 MIDIHDR * lpMidiInHdr, UINT16 uSize)
3144 {
3145 TRACE(mmsys, "midiInAddBuffer\n");
3146 return 0;
3147 }
3148
3149 /**************************************************************************
3150 * midiInStart [WINMM.69]
3151 */
3152 UINT32 WINAPI midiInStart32(HMIDIIN32 hMidiIn)
3153 {
3154 return midiInStart16(hMidiIn);
3155 }
3156
3157 /**************************************************************************
3158 * midiInStart [MMSYSTEM.309]
3159 */
3160 UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
3161 {
3162 LPMIDIOPENDESC lpDesc;
3163
3164 TRACE(mmsys, "(%04X)\n", hMidiIn);
3165 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3166 if (lpDesc == NULL)
3167 return MMSYSERR_INVALHANDLE;
3168 return midMessage(lpDesc->wDevID, MIDM_START, lpDesc->dwInstance, 0L, 0L);
3169 }
3170
3171 /**************************************************************************
3172 * midiInStop [WINMM.70]
3173 */
3174 UINT32 WINAPI midiInStop32(HMIDIIN32 hMidiIn)
3175 {
3176 return midiInStop16(hMidiIn);
3177 }
3178
3179 /**************************************************************************
3180 * midiInStop [MMSYSTEM.310]
3181 */
3182 UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
3183 {
3184 LPMIDIOPENDESC lpDesc;
3185
3186 TRACE(mmsys, "(%04X)\n", hMidiIn);
3187 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3188 if (lpDesc == NULL)
3189 return MMSYSERR_INVALHANDLE;
3190 return midMessage(lpDesc->wDevID, MIDM_STOP, lpDesc->dwInstance, 0L, 0L);
3191 }
3192
3193 /**************************************************************************
3194 * midiInReset [WINMM.68]
3195 */
3196 UINT32 WINAPI midiInReset32(HMIDIIN32 hMidiIn)
3197 {
3198 return midiInReset16(hMidiIn);
3199 }
3200
3201 /**************************************************************************
3202 * midiInReset [MMSYSTEM.311]
3203 */
3204 UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
3205 {
3206 LPMIDIOPENDESC lpDesc;
3207
3208 TRACE(mmsys, "(%04X)\n", hMidiIn);
3209 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3210 if (lpDesc == NULL)
3211 return MMSYSERR_INVALHANDLE;
3212 return midMessage(lpDesc->wDevID, MIDM_RESET, lpDesc->dwInstance, 0L, 0L);
3213 }
3214
3215 /**************************************************************************
3216 * midiInGetID [WINMM.63]
3217 */
3218 UINT32 WINAPI midiInGetID32(HMIDIIN32 hMidiIn, UINT32* lpuDeviceID)
3219 {
3220 LPMIDIOPENDESC lpDesc;
3221
3222 TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID);
3223 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3224 if (lpDesc == NULL)
3225 return MMSYSERR_INVALHANDLE;
3226 if (lpuDeviceID == NULL)
3227 return MMSYSERR_INVALPARAM;
3228 *lpuDeviceID = lpDesc->wDevID;
3229
3230 return MMSYSERR_NOERROR;
3231 }
3232
3233 /**************************************************************************
3234 * midiInGetID [MMSYSTEM.312]
3235 */
3236 UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
3237 {
3238 LPMIDIOPENDESC lpDesc;
3239
3240 TRACE(mmsys, "(%04X, %p)\n", hMidiIn, lpuDeviceID);
3241 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3242 if (lpDesc == NULL)
3243 return MMSYSERR_INVALHANDLE;
3244 if (lpuDeviceID == NULL)
3245 return MMSYSERR_INVALPARAM;
3246 *lpuDeviceID = lpDesc->wDevID;
3247
3248 return MMSYSERR_NOERROR;
3249 }
3250
3251 /**************************************************************************
3252 * midiInMessage [WINMM.65]
3253 */
3254 DWORD WINAPI midiInMessage32(HMIDIIN32 hMidiIn, UINT32 uMessage,
3255 DWORD dwParam1, DWORD dwParam2)
3256 {
3257 LPMIDIOPENDESC lpDesc;
3258
3259 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
3260 hMidiIn, uMessage, dwParam1, dwParam2);
3261 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3262 if (lpDesc == NULL)
3263 return MMSYSERR_INVALHANDLE;
3264
3265 switch (uMessage) {
3266 case MIDM_OPEN:
3267 FIXME(mmsys,"can't handle MIDM_OPEN!\n");
3268 return 0;
3269 case MIDM_GETDEVCAPS:
3270 return midiInGetDevCaps32A(hMidiIn, (LPMIDIINCAPS32A)dwParam1, dwParam2);
3271 case MIDM_GETNUMDEVS:
3272 case MIDM_RESET:
3273 case MIDM_STOP:
3274 case MIDM_START:
3275 case MIDM_CLOSE:
3276 /* no argument conversion needed */
3277 break;
3278 case MIDM_PREPARE:
3279 return midiInPrepareHeader32(hMidiIn, (LPMIDIHDR)dwParam1, dwParam2);
3280 case MIDM_UNPREPARE:
3281 return midiInUnprepareHeader32(hMidiIn, (LPMIDIHDR)dwParam1, dwParam2);
3282 case MIDM_ADDBUFFER:
3283 return midiInAddBuffer32(hMidiIn, (LPMIDIHDR)dwParam1, dwParam2);
3284 default:
3285 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
3286 hMidiIn,uMessage, dwParam1, dwParam2);
3287 break;
3288 }
3289 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3290 }
3291
3292 /**************************************************************************
3293 * midiInMessage [MMSYSTEM.313]
3294 */
3295 DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
3296 DWORD dwParam1, DWORD dwParam2)
3297 {
3298 LPMIDIOPENDESC lpDesc;
3299
3300 TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
3301
3302 lpDesc = (LPMIDIOPENDESC) USER_HEAP_LIN_ADDR(hMidiIn);
3303 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3304 switch (uMessage) {
3305 case MIDM_OPEN:
3306 WARN(mmsys,"can't handle MIDM_OPEN!\n");
3307 return 0;
3308 case MIDM_GETDEVCAPS:
3309 return midiInGetDevCaps16(hMidiIn, (LPMIDIINCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3310 case MIDM_GETNUMDEVS:
3311 case MIDM_RESET:
3312 case MIDM_STOP:
3313 case MIDM_START:
3314 case MIDM_CLOSE:
3315 /* no argument conversion needed */
3316 break;
3317 case MIDM_PREPARE:
3318 return midiInPrepareHeader16(hMidiIn, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3319 case MIDM_UNPREPARE:
3320 return midiInUnprepareHeader16(hMidiIn, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3321 case MIDM_ADDBUFFER:
3322 return midiInAddBuffer16(hMidiIn, (LPMIDIHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
3323 default:
3324 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
3325 hMidiIn,uMessage, dwParam1, dwParam2);
3326 break;
3327 }
3328 return midMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
3329 }
3330
3331 #define MIDI_STREAM_MAGIC 0xC9080F17
3332
3333 typedef struct {
3334 DWORD dwMagic;
3335 HMIDIOUT32 hDevice;
3336 /* thread ID */
3337 DWORD dwTempo;
3338 DWORD dwTimeDiv;
3339 DWORD dwMS;
3340 DWORD dwStatus;
3341 LPMIDIHDR_WIN32 lpMidiHdr;
3342 } WINE_MIDIStream;
3343
3344 /**************************************************************************
3345 * MMSYSTEM_MidiStreamPlayer [internal]
3346 */
3347 static void MMSYSTEM_MidiStreamPlayer(WINE_MIDIStream* ms)
3348 {
3349 /* FIXME: should I sleep a bit when there is no pending lpMidiHdr ?
3350 * => provide a better synchronization system
3351 * midiStreamPause/midiStreamRestart should freeze/thaw this thread
3352 * global resource should guard access to ms->lpMidiHdr list, or
3353 * use a MB to send new LPMIDIHDR
3354 * an empty ms->lpMidiHdr list should freeze this thread
3355 */
3356 for (;;) {
3357 if (ms->dwStatus && ms->lpMidiHdr) {
3358 LPMIDIEVENT me = (LPMIDIEVENT)(ms->lpMidiHdr->lpData + ms->lpMidiHdr->dwOffset);
3359
3360 FIXME(mmsys, "Should wait for current time to be in sync with me->dwDeltaTime\n");
3361
3362 if (me->dwEvent & MEVT_F_CALLBACK) {
3363 WARN(mmsys, "Should generate callback when encountering F_CALLBACK flagged midi events...\n");
3364 }
3365 switch (MEVT_EVENTTYPE(me->dwEvent)) {
3366 case MEVT_COMMENT:
3367 /* do nothing, skip bytes */
3368 break;
3369 case MEVT_LONGMSG:
3370 WARN(mmsys, "NIY: sending Sysex Event");
3371 break;
3372 case MEVT_NOP:
3373 break;
3374 case MEVT_SHORTMSG:
3375 midiOutShortMsg32(ms->hDevice, MEVT_EVENTPARM(me->dwEvent));
3376 break;
3377 case MEVT_TEMPO:
3378 ms->dwTempo = MEVT_EVENTPARM(me->dwEvent);
3379 break;
3380 case MEVT_VERSION:
3381 break;
3382 }
3383 ms->lpMidiHdr->dwOffset += sizeof(MIDIEVENT);
3384 if (me->dwEvent & MEVT_F_LONG) {
3385 ms->lpMidiHdr->dwOffset += MEVT_EVENTPARM(me->dwEvent);
3386 }
3387 if (ms->lpMidiHdr->dwOffset >= ms->lpMidiHdr->dwBufferLength) {
3388 ms->lpMidiHdr->dwFlags |= MHDR_DONE;
3389 ms->lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
3390 ms->lpMidiHdr = (LPMIDIHDR_WIN32)ms->lpMidiHdr->lpNext;
3391 WARN(mmsys, "Should generate callback when done with MIDIHDR...\n");
3392 }
3393 FIXME(mmsys, "Should accordingly update ms->dwMS with me->dwDeltaTime\n");
3394 }
3395 }
3396 }
3397
3398 /**************************************************************************
3399 * midiStreamClose [WINMM.90]
3400 */
3401 MMRESULT32 WINAPI midiStreamClose32(HMIDISTRM32 hms)
3402 {
3403 WINE_MIDIStream* ms;
3404
3405 TRACE(midi, "(%08x)!\n", hms);
3406
3407 ms = (WINE_MIDIStream*)hms;
3408 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
3409 return MMSYSERR_INVALHANDLE;
3410
3411 free(ms);
3412
3413 return MMSYSERR_NOTSUPPORTED;
3414 }
3415
3416 /**************************************************************************
3417 * midiStreamOpen [WINMM.91]
3418 */
3419 MMRESULT32 WINAPI midiStreamOpen32(HMIDISTRM32* phms, LPUINT32 lpuDeviceID,
3420 DWORD cMidi, DWORD dwCallback,
3421 DWORD dwInstance, DWORD fdwOpen)
3422 {
3423 WINE_MIDIStream* ms;
3424
3425 TRACE(midi, "(%p,%p,%ld, 0x%08lx, 0x%08lx, 0x%08lx), stub!\n",
3426 phms, lpuDeviceID,cMidi, dwCallback, dwInstance, fdwOpen);
3427
3428 if (cMidi != 1 || phms == NULL || lpuDeviceID == NULL)
3429 return MMSYSERR_INVALPARAM;
3430
3431 ms = malloc(sizeof(WINE_MIDIStream));
3432 *phms = (HMIDISTRM32)ms;
3433 ms->dwMagic = MIDI_STREAM_MAGIC;
3434 ms->dwTempo = 50000; /* FIXME */
3435 ms->dwTimeDiv = 1; /* FIXME */
3436 ms->dwMS = 0;
3437 ms->dwStatus = 0;
3438
3439 /* FIXME is this correct ? */
3440 *lpuDeviceID = 0;
3441 /* FIXME is this correct ? */
3442 return midiOutOpen32(&(ms->hDevice), *lpuDeviceID, dwCallback, dwInstance, fdwOpen);
3443 }
3444
3445 /**************************************************************************
3446 * midiStreamOut [WINMM.92]
3447 */
3448 MMRESULT32 WINAPI midiStreamOut32(HMIDISTRM32 hms, LPMIDIHDR lpMidiHdr, UINT32 cbMidiHdr)
3449 {
3450 FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMidiHdr, cbMidiHdr);
3451 return MMSYSERR_NOTSUPPORTED;
3452 }
3453
3454 /**************************************************************************
3455 * midiStreamPause [WINMM.93]
3456 */
3457 MMRESULT32 WINAPI midiStreamPause32(HMIDISTRM32 hms)
3458 {
3459 WINE_MIDIStream* ms;
3460
3461 TRACE(midi, "(%08x)!\n", hms);
3462
3463 ms = (WINE_MIDIStream*)hms;
3464 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
3465 return MMSYSERR_INVALHANDLE;
3466
3467 ms->dwStatus = 0;
3468 return MMSYSERR_NOERROR;
3469 }
3470
3471 /**************************************************************************
3472 * midiStreamPosition [WINMM.94]
3473 */
3474 MMRESULT32 WINAPI midiStreamPosition32(HMIDISTRM32 hms, LPMMTIME32 lpMMT, UINT32 cbmmt)
3475 {
3476 WINE_MIDIStream* ms;
3477 DWORD ret = MMSYSERR_NOERROR;
3478
3479 FIXME(midi, "(%08x, %p, %u) stub!\n", hms, lpMMT, cbmmt);
3480
3481 ms = (WINE_MIDIStream*)hms;
3482
3483 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) {
3484 ret = MMSYSERR_INVALHANDLE;
3485 } else if (lpMMT == NULL || cbmmt != sizeof(MMTIME32)) {
3486 ret = MMSYSERR_INVALPARAM;
3487 } else {
3488 switch (lpMMT->wType) {
3489 case TIME_MS:
3490 lpMMT->u.ms = ms->dwMS;
3491 break;
3492 default:
3493 lpMMT->wType = TIME_MS;
3494 ret = MMSYSERR_INVALPARAM;
3495 }
3496 }
3497 return ret;
3498 }
3499
3500 /**************************************************************************
3501 * midiStreamProperty [WINMM.95]
3502 */
3503 MMRESULT32 WINAPI midiStreamProperty32(HMIDISTRM32 hms, LPBYTE lpPropData, DWORD dwProperty)
3504 {
3505 WINE_MIDIStream* ms = (WINE_MIDIStream*)hms;
3506 MMRESULT32 ret = MMSYSERR_NOERROR;
3507
3508 TRACE(midi, "(%08x, %p, %lx)\n", hms, lpPropData, dwProperty);
3509
3510 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC) {
3511 ret = MMSYSERR_INVALHANDLE;
3512 } else if ((dwProperty & (MIDIPROP_GET|MIDIPROP_SET)) == 0) {
3513 return MMSYSERR_INVALPARAM;
3514 } else if (dwProperty & MIDIPROP_TEMPO) {
3515 MIDIPROPTEMPO* mpt = (MIDIPROPTEMPO*)lpPropData;
3516
3517 if (sizeof(MIDIPROPTEMPO) != mpt->cbStruct) {
3518 ret = MMSYSERR_INVALPARAM;
3519 } else if (dwProperty & MIDIPROP_GET) {
3520 ms->dwTempo = mpt->dwTempo;
3521 } else if (dwProperty & MIDIPROP_SET) {
3522 mpt->dwTempo = ms->dwTempo;
3523 }
3524 } else if (dwProperty & MIDIPROP_TIMEDIV) {
3525 MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData;
3526
3527 if (sizeof(MIDIPROPTIMEDIV) != mptd->cbStruct) {
3528 ret = MMSYSERR_INVALPARAM;
3529 } else if (dwProperty & MIDIPROP_GET) {
3530 ms->dwTimeDiv = mptd->dwTimeDiv;
3531 } else if (dwProperty & MIDIPROP_SET) {
3532 mptd->dwTimeDiv = ms->dwTimeDiv;
3533 }
3534 } else {
3535 ret = MMSYSERR_INVALPARAM;
3536 }
3537
3538 return ret;
3539 }
3540
3541 /**************************************************************************
3542 * midiStreamRestart [WINMM.96]
3543 */
3544 MMRESULT32 WINAPI midiStreamRestart32(HMIDISTRM32 hms)
3545 {
3546 WINE_MIDIStream* ms;
3547
3548 TRACE(midi, "(%08x)!\n", hms);
3549
3550 ms = (WINE_MIDIStream*)hms;
3551 if (!ms || ms->dwMagic != MIDI_STREAM_MAGIC)
3552 return MMSYSERR_INVALHANDLE;
3553
3554 ms->dwStatus = 1;
3555 return MMSYSERR_NOERROR;
3556 }
3557
3558 /**************************************************************************
3559 * midiStreamStop [WINMM.97]
3560 */
3561 MMRESULT32 WINAPI midiStreamStop32(HMIDISTRM32 hms)
3562 {
3563 FIXME(midi, "(%08x stub!)\n", hms);
3564 return MMSYSERR_NOTSUPPORTED;
3565 }
3566
3567 /**************************************************************************
3568 * midiStreamClose [MMSYSTEM.252]
3569 */
3570 MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms)
3571 {
3572 return midiStreamClose32(hms);
3573 }
3574
3575 /**************************************************************************
3576 * midiStreamOpen [MMSYSTEM.251]
3577 */
3578 MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phms, LPUINT16 devid,
3579 DWORD cMidi, DWORD dwCallback,
3580 DWORD dwInstance, DWORD fdwOpen)
3581 {
3582 HMIDISTRM32 hms32;
3583 MMRESULT32 ret;
3584 UINT32 devid32;
3585
3586 if (!phms || !devid)
3587 return MMSYSERR_INVALPARAM;
3588 devid32 = *devid;
3589 ret = midiStreamOpen32(&hms32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen);
3590 *phms = hms32;
3591 *devid = devid32;
3592 return ret;
3593 }
3594
3595 /**************************************************************************
3596 * midiStreamOut [MMSYSTEM.254]
3597 */
3598 MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hms, LPMIDIHDR lpMidiHdr, UINT16 cbMidiHdr)
3599 {
3600 return midiStreamOut32(hms, lpMidiHdr, cbMidiHdr);
3601 }
3602
3603 /**************************************************************************
3604 * midiStreamPause [MMSYSTEM.255]
3605 */
3606 MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hms)
3607 {
3608 return midiStreamPause32(hms);
3609 }
3610
3611 /**************************************************************************
3612 * midiStreamPosition [MMSYSTEM.253]
3613 */
3614 MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hms, LPMMTIME16 lpmmt, UINT16 cbmmt)
3615 {
3616 MMTIME32 mmt32;
3617 MMRESULT32 ret;
3618
3619 if (!lpmmt)
3620 return MMSYSERR_INVALPARAM;
3621 MMSYSTEM_MMTIME16to32(&mmt32, lpmmt);
3622 ret = midiStreamPosition32(hms, &mmt32, cbmmt);
3623 MMSYSTEM_MMTIME32to16(lpmmt, &mmt32);
3624 return ret;
3625 }
3626
3627 /**************************************************************************
3628 * midiStreamProperty [MMSYSTEM.250]
3629 */
3630 MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hms, LPBYTE lpPropData, DWORD dwProperty)
3631 {
3632 return midiStreamProperty32(hms, lpPropData, dwProperty);
3633 }
3634
3635 /**************************************************************************
3636 * midiStreamRestart [MMSYSTEM.256]
3637 */
3638 MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hms)
3639 {
3640 return midiStreamRestart32(hms);
3641 }
3642
3643 /**************************************************************************
3644 * midiStreamStop [MMSYSTEM.257]
3645 */
3646 MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hms)
3647 {
3648 return midiStreamStop32(hms);
3649 }
3650
3651 /**************************************************************************
3652 * waveOutGetNumDevs [MMSYSTEM.401]
3653 */
3654 UINT32 WINAPI waveOutGetNumDevs32() {
3655 return waveOutGetNumDevs16();
3656 }
3657
3658 /**************************************************************************
3659 * waveOutGetNumDevs [WINMM.167]
3660 */
3661 UINT16 WINAPI waveOutGetNumDevs16()
3662 {
3663 UINT16 count = 0;
3664 TRACE(mmsys, "waveOutGetNumDevs\n");
3665 /* FIXME: I'm not sure MCI_FirstDevID() is correct */
3666 count += wodMessage(MCI_FirstDevID(), WODM_GETNUMDEVS, 0L, 0L, 0L);
3667 TRACE(mmsys, "waveOutGetNumDevs return %u \n", count);
3668 return count;
3669 }
3670
3671 /**************************************************************************
3672 * waveOutGetDevCaps [MMSYSTEM.402]
3673 */
3674 UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID, WAVEOUTCAPS16 * lpCaps,
3675 UINT16 uSize)
3676 {
3677 if (uDeviceID > waveOutGetNumDevs16() - 1) return MMSYSERR_BADDEVICEID;
3678 if (uDeviceID == (UINT16)WAVE_MAPPER) return MMSYSERR_BADDEVICEID; /* FIXME: do we have a wave mapper ? */
3679 TRACE(mmsys, "waveOutGetDevCaps\n");
3680 return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
3681 }
3682
3683 /**************************************************************************
3684 * waveOutGetDevCapsA [WINMM.162]
3685 */
3686 UINT32 WINAPI waveOutGetDevCaps32A(UINT32 uDeviceID, LPWAVEOUTCAPS32A lpCaps,
3687 UINT32 uSize)
3688 {
3689 WAVEOUTCAPS16 woc16;
3690 UINT16 ret = waveOutGetDevCaps16(uDeviceID, &woc16, sizeof(woc16));
3691
3692 lpCaps->wMid = woc16.wMid;
3693 lpCaps->wPid = woc16.wPid;
3694 lpCaps->vDriverVersion = woc16.vDriverVersion;
3695 strcpy(lpCaps->szPname, woc16.szPname);
3696 lpCaps->dwFormats = woc16.dwFormats;
3697 lpCaps->wChannels = woc16.wChannels;
3698 lpCaps->dwSupport = woc16.dwSupport;
3699 return ret;
3700 }
3701
3702 /**************************************************************************
3703 * waveOutGetDevCapsW [WINMM.163]
3704 */
3705 UINT32 WINAPI waveOutGetDevCaps32W(UINT32 uDeviceID, LPWAVEOUTCAPS32W lpCaps,
3706 UINT32 uSize)
3707 {
3708 WAVEOUTCAPS16 woc16;
3709 UINT32 ret = waveOutGetDevCaps16(uDeviceID, &woc16, sizeof(woc16));
3710
3711 lpCaps->wMid = woc16.wMid;
3712 lpCaps->wPid = woc16.wPid;
3713 lpCaps->vDriverVersion = woc16.vDriverVersion;
3714 lstrcpyAtoW(lpCaps->szPname, woc16.szPname);
3715 lpCaps->dwFormats = woc16.dwFormats;
3716 lpCaps->wChannels = woc16.wChannels;
3717 lpCaps->dwSupport = woc16.dwSupport;
3718 return ret;
3719 }
3720
3721 /**************************************************************************
3722 * waveOutGetErrorText [MMSYSTEM.403]
3723 */
3724 UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
3725 {
3726 TRACE(mmsys, "waveOutGetErrorText\n");
3727 return(waveGetErrorText(uError, lpText, uSize));
3728 }
3729
3730 /**************************************************************************
3731 * waveOutGetErrorTextA [WINMM.164]
3732 */
3733 UINT32 WINAPI waveOutGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
3734 {
3735 return(waveOutGetErrorText16(uError, lpText, uSize));
3736 }
3737
3738 /**************************************************************************
3739 * waveOutGetErrorTextW [WINMM.165]
3740 */
3741 UINT32 WINAPI waveOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
3742 {
3743 LPSTR xstr = HeapAlloc(GetProcessHeap(), 0,uSize);
3744 UINT32 ret = waveOutGetErrorText32A(uError, xstr, uSize);
3745
3746 lstrcpyAtoW(lpText,xstr);
3747 HeapFree(GetProcessHeap(), 0,xstr);
3748 return ret;
3749 }
3750
3751 /**************************************************************************
3752 * waveGetErrorText [internal]
3753 */
3754 static UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize)
3755 {
3756 LPSTR msgptr;
3757 TRACE(mmsys, "(%04X, %p, %d);\n",
3758 uError, lpText, uSize);
3759 if ((lpText == NULL) || (uSize < 1)) return(FALSE);
3760 lpText[0] = '\0';
3761 switch (uError) {
3762 case MMSYSERR_NOERROR:
3763 msgptr = "The specified command was carried out.";
3764 break;
3765 case MMSYSERR_ERROR:
3766 msgptr = "Undefined external error.";
3767 break;
3768 case MMSYSERR_BADDEVICEID:
3769 msgptr = "A device ID has been used that is out of range for your system.";
3770 break;
3771 case MMSYSERR_NOTENABLED:
3772 msgptr = "The driver was not enabled.";
3773 break;
3774 case MMSYSERR_ALLOCATED:
3775 msgptr = "The specified device is already in use. Wait until it is free, and then try again.";
3776 break;
3777 case MMSYSERR_INVALHANDLE:
3778 msgptr = "The specified device handle is invalid.";
3779 break;
3780 case MMSYSERR_NODRIVER:
3781 msgptr = "There is no driver installed on your system !\n";
3782 break;
3783 case MMSYSERR_NOMEM:
3784 msgptr = "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again.";
3785 break;
3786 case MMSYSERR_NOTSUPPORTED:
3787 msgptr = "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports.";
3788 break;
3789 case MMSYSERR_BADERRNUM:
3790 msgptr = "An error number was specified that is not defined in the system.";
3791 break;
3792 case MMSYSERR_INVALFLAG:
3793 msgptr = "An invalid flag was passed to a system function.";
3794 break;
3795 case MMSYSERR_INVALPARAM:
3796 msgptr = "An invalid parameter was passed to a system function.";
3797 break;
3798 case WAVERR_BADFORMAT:
3799 msgptr = "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats";
3800 break;
3801 case WAVERR_STILLPLAYING:
3802 msgptr = "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing.";
3803 break;
3804 case WAVERR_UNPREPARED:
3805 msgptr = "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again.";
3806 break;
3807 case WAVERR_SYNC:
3808 msgptr = "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again.";
3809 break;
3810 default:
3811 msgptr = "Unknown MMSYSTEM Error !\n";
3812 break;
3813 }
3814 lstrcpyn32A(lpText, msgptr, uSize);
3815 return TRUE;
3816 }
3817
3818 /**************************************************************************
3819 * waveOutOpen [WINMM.173]
3820 * All the args/structs have the same layout as the win16 equivalents
3821 */
3822 UINT32 WINAPI waveOutOpen32(HWAVEOUT32 * lphWaveOut, UINT32 uDeviceID,
3823 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3824 DWORD dwInstance, DWORD dwFlags)
3825 {
3826 HWAVEOUT16 hwo16;
3827 UINT32 ret = waveOutOpen16(&hwo16,uDeviceID, lpFormat, dwCallback, dwInstance,
3828 CALLBACK32CONV(dwFlags));
3829
3830 if (lphWaveOut) *lphWaveOut=hwo16;
3831 return ret;
3832 }
3833
3834 /**************************************************************************
3835 * waveOutOpen [MMSYSTEM.404]
3836 */
3837 UINT16 WINAPI waveOutOpen16(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
3838 const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
3839 DWORD dwInstance, DWORD dwFlags)
3840 {
3841 HWAVEOUT16 hWaveOut;
3842 LPWAVEOPENDESC lpDesc;
3843 DWORD dwRet = 0;
3844 BOOL32 bMapperFlg = FALSE;
3845
3846 TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
3847 lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
3848 if (dwFlags & WAVE_FORMAT_QUERY)
3849 TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
3850 if (uDeviceID == (UINT16)WAVE_MAPPER) {
3851 TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
3852 bMapperFlg = TRUE;
3853 uDeviceID = 0;
3854 }
3855 if (lpFormat == NULL) return WAVERR_BADFORMAT;
3856
3857 hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
3858 if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
3859 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3860 if (lpDesc == NULL) return MMSYSERR_NOMEM;
3861 lpDesc->hWave = hWaveOut;
3862 lpDesc->lpFormat = (LPWAVEFORMAT)lpFormat; /* should the struct be copied iso pointer? */
3863 lpDesc->dwCallBack = dwCallback;
3864 lpDesc->dwInstance = dwInstance;
3865 if (uDeviceID >= MAXWAVEDRIVERS)
3866 uDeviceID = 0;
3867 while (uDeviceID < MAXWAVEDRIVERS) {
3868 dwRet = wodMessage(uDeviceID, WODM_OPEN,
3869 lpDesc->dwInstance, (DWORD)lpDesc, dwFlags);
3870 if (dwRet == MMSYSERR_NOERROR) break;
3871 if (!bMapperFlg) break;
3872 uDeviceID++;
3873 TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
3874 }
3875 lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */
3876 if (dwFlags & WAVE_FORMAT_QUERY) {
3877 TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
3878 dwRet = waveOutClose32(hWaveOut);
3879 }
3880 return dwRet;
3881 }
3882
3883 /**************************************************************************
3884 * waveOutClose [WINMM.161]
3885 */
3886 UINT32 WINAPI waveOutClose32(HWAVEOUT32 hWaveOut)
3887 {
3888 return waveOutClose16(hWaveOut);
3889 }
3890
3891 /**************************************************************************
3892 * waveOutClose [MMSYSTEM.405]
3893 */
3894 UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
3895 {
3896 LPWAVEOPENDESC lpDesc;
3897
3898 TRACE(mmsys, "(%04X)\n", hWaveOut);
3899
3900 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3901 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3902 return wodMessage(lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
3903 }
3904
3905 /**************************************************************************
3906 * waveOutPrepareHeader [WINMM.175]
3907 */
3908 UINT32 WINAPI waveOutPrepareHeader32(HWAVEOUT32 hWaveOut,
3909 WAVEHDR* lpWaveOutHdr, UINT32 uSize)
3910 {
3911 LPWAVEOPENDESC lpDesc;
3912
3913 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3914
3915 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3916 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3917 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3918 return wodMessage(lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
3919 (DWORD)lpWaveOutHdr,uSize);
3920 }
3921
3922 /**************************************************************************
3923 * waveOutPrepareHeader [MMSYSTEM.406]
3924 */
3925 UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,
3926 WAVEHDR* lpWaveOutHdr, UINT16 uSize)
3927 {
3928 LPWAVEOPENDESC lpDesc;
3929 UINT16 ret;
3930
3931 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3932
3933 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3934 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3935 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3936 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3937 ret = wodMessage(lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
3938 (DWORD)lpWaveOutHdr,uSize);
3939 lpWaveOutHdr->lpData = lpWaveOutHdr->lpData;
3940 return ret;
3941 }
3942
3943 /**************************************************************************
3944 * waveOutUnprepareHeader [WINMM.181]
3945 */
3946 UINT32 WINAPI waveOutUnprepareHeader32(HWAVEOUT32 hWaveOut,
3947 WAVEHDR* lpWaveOutHdr, UINT32 uSize)
3948 {
3949 LPWAVEOPENDESC lpDesc;
3950
3951 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3952
3953 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3954 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3955 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3956 return wodMessage(lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance,
3957 (DWORD)lpWaveOutHdr, uSize);
3958 }
3959
3960 /**************************************************************************
3961 * waveOutUnprepareHeader [MMSYSTEM.407]
3962 */
3963 UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,
3964 WAVEHDR* lpWaveOutHdr, UINT16 uSize)
3965 {
3966 LPWAVEOPENDESC lpDesc;
3967 UINT16 ret;
3968
3969 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3970
3971 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3972 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3973 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3974 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
3975 ret = wodMessage(lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance,
3976 (DWORD)lpWaveOutHdr, uSize);
3977 lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved;
3978 return ret;
3979 }
3980
3981 /**************************************************************************
3982 * waveOutWrite [MMSYSTEM.408]
3983 */
3984 UINT32 WINAPI waveOutWrite32(HWAVEOUT32 hWaveOut, WAVEHDR* lpWaveOutHdr,
3985 UINT32 uSize)
3986 {
3987 LPWAVEOPENDESC lpDesc;
3988
3989 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
3990
3991 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
3992 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
3993 lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
3994 return wodMessage(lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
3995 }
3996
3997 /**************************************************************************
3998 * waveOutWrite [MMSYSTEM.408]
3999 */
4000 UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
4001 UINT16 uSize)
4002 {
4003 LPWAVEOPENDESC lpDesc;
4004 UINT16 ret;
4005
4006 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
4007
4008 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4009 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4010 lpWaveOutHdr->reserved =(DWORD)lpWaveOutHdr->lpData;/*save original ptr*/
4011 lpWaveOutHdr->lpData = PTR_SEG_TO_LIN(lpWaveOutHdr->lpData);
4012 ret = wodMessage(lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
4013 lpWaveOutHdr->lpData = (LPBYTE)lpWaveOutHdr->reserved;
4014 return ret;
4015 }
4016
4017 /**************************************************************************
4018 * waveOutPause [WINMM.174]
4019 */
4020 UINT32 WINAPI waveOutPause32(HWAVEOUT32 hWaveOut)
4021 {
4022 return waveOutPause16(hWaveOut);
4023 }
4024
4025 /**************************************************************************
4026 * waveOutPause [MMSYSTEM.409]
4027 */
4028 UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut)
4029 {
4030 LPWAVEOPENDESC lpDesc;
4031
4032 TRACE(mmsys, "(%04X)\n", hWaveOut);
4033
4034 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4035 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4036 return wodMessage(lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L);
4037 }
4038
4039 /**************************************************************************
4040 * waveOutRestart [WINMM.177]
4041 */
4042 UINT32 WINAPI waveOutRestart32(HWAVEOUT32 hWaveOut)
4043 {
4044 return waveOutRestart16(hWaveOut);
4045 }
4046
4047 /**************************************************************************
4048 * waveOutRestart [MMSYSTEM.410]
4049 */
4050 UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut)
4051 {
4052 LPWAVEOPENDESC lpDesc;
4053
4054 TRACE(mmsys, "(%04X)\n", hWaveOut);
4055
4056 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4057 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4058 return wodMessage(lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L);
4059 }
4060
4061 /**************************************************************************
4062 * waveOutReset [WINMM.176]
4063 */
4064 UINT32 WINAPI waveOutReset32(HWAVEOUT32 hWaveOut)
4065 {
4066 return waveOutReset16(hWaveOut);
4067 }
4068
4069 /**************************************************************************
4070 * waveOutReset [MMSYSTEM.411]
4071 */
4072 UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut)
4073 {
4074 LPWAVEOPENDESC lpDesc;
4075
4076 TRACE(mmsys, "(%04X)\n", hWaveOut);
4077
4078 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4079 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4080 return wodMessage(lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L);
4081 }
4082
4083 /**************************************************************************
4084 * waveOutGetPosition [WINMM.170]
4085 */
4086 UINT32 WINAPI waveOutGetPosition32(HWAVEOUT32 hWaveOut, LPMMTIME32 lpTime,
4087 UINT32 uSize)
4088 {
4089 MMTIME16 mmt16;
4090 UINT32 ret;
4091
4092 mmt16.wType = lpTime->wType;
4093 ret = waveOutGetPosition16(hWaveOut, &mmt16, sizeof(mmt16));
4094 MMSYSTEM_MMTIME16to32(lpTime, &mmt16);
4095 return ret;
4096 }
4097
4098 /**************************************************************************
4099 * waveOutGetPosition [MMSYSTEM.412]
4100 */
4101 UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime,
4102 UINT16 uSize)
4103 {
4104 LPWAVEOPENDESC lpDesc;
4105 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveOut, lpTime, uSize);
4106 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4107 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4108 return wodMessage(lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance,
4109 (DWORD)lpTime, (DWORD)uSize);
4110 }
4111
4112 #define WAVEOUT_SHORTCUT_1(xx,XX,atype) \
4113 UINT32 WINAPI waveOut##xx##32(HWAVEOUT32 hWaveOut, atype x) \
4114 { \
4115 return waveOut##xx##16(hWaveOut,x); \
4116 } \
4117 UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \
4118 { \
4119 LPWAVEOPENDESC lpDesc; \
4120 TRACE(mmsys, "(%04X, %08lx);\n", hWaveOut, (DWORD)x); \
4121 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \
4122 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \
4123 return wodMessage(lpDesc->uDeviceID, WODM_##XX, \
4124 lpDesc->dwInstance, (DWORD)x, 0L); \
4125 }
4126
4127 WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH, DWORD*)
4128 WAVEOUT_SHORTCUT_1(SetPitch,SETPITCH, DWORD)
4129 WAVEOUT_SHORTCUT_1(GetPlaybackRate,GETPLAYBACKRATE, DWORD*)
4130 WAVEOUT_SHORTCUT_1(SetPlaybackRate,SETPLAYBACKRATE, DWORD)
4131
4132 #define WAVEOUT_SHORTCUT_2(xx,XX,atype) \
4133 UINT32 WINAPI waveOut##xx##32(UINT32 devid, atype x) \
4134 { \
4135 return waveOut##xx##16(devid,x); \
4136 } \
4137 UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \
4138 { \
4139 TRACE(mmsys, "(%04X, %08lx);\n", devid, (DWORD)x); \
4140 return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \
4141 }
4142
4143 WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME, DWORD*)
4144 WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME, DWORD)
4145
4146 /**************************************************************************
4147 * waveOutBreakLoop [MMSYSTEM.419]
4148 */
4149 UINT32 WINAPI waveOutBreakLoop32(HWAVEOUT32 hWaveOut)
4150 {
4151 return waveOutBreakLoop16(hWaveOut);
4152 }
4153
4154 /**************************************************************************
4155 * waveOutBreakLoop [MMSYSTEM.419]
4156 */
4157 UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut)
4158 {
4159 TRACE(mmsys, "(%04X)\n", hWaveOut);
4160 return MMSYSERR_INVALHANDLE;
4161 }
4162
4163 /**************************************************************************
4164 * waveOutGetID [MMSYSTEM.420]
4165 */
4166 UINT32 WINAPI waveOutGetID32(HWAVEOUT32 hWaveOut, UINT32 * lpuDeviceID)
4167 {
4168 LPWAVEOPENDESC lpDesc;
4169
4170 TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
4171
4172 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4173 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4174 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4175 *lpuDeviceID = lpDesc->uDeviceID;
4176 return 0;
4177 }
4178
4179 /**************************************************************************
4180 * waveOutGetID [MMSYSTEM.420]
4181 */
4182 UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID)
4183 {
4184 LPWAVEOPENDESC lpDesc;
4185
4186 TRACE(mmsys, "(%04X, %p);\n", hWaveOut, lpuDeviceID);
4187
4188 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4189 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4190 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4191 *lpuDeviceID = lpDesc->uDeviceID;
4192 return 0;
4193 }
4194
4195 /**************************************************************************
4196 * waveOutMessage [MMSYSTEM.421]
4197 */
4198 DWORD WINAPI waveOutMessage32(HWAVEOUT32 hWaveOut, UINT32 uMessage,
4199 DWORD dwParam1, DWORD dwParam2)
4200 {
4201 LPWAVEOPENDESC lpDesc;
4202
4203 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4204 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4205 switch (uMessage) {
4206 case WODM_GETNUMDEVS:
4207 case WODM_GETPOS:
4208 case WODM_GETVOLUME:
4209 case WODM_GETPITCH:
4210 case WODM_GETPLAYBACKRATE:
4211 case WODM_SETVOLUME:
4212 case WODM_SETPITCH:
4213 case WODM_SETPLAYBACKRATE:
4214 case WODM_RESET:
4215 case WODM_PAUSE:
4216 case WODM_PREPARE:
4217 case WODM_UNPREPARE:
4218 case WODM_STOP:
4219 case WODM_CLOSE:
4220 /* no argument conversion needed */
4221 break;
4222 case WODM_WRITE:
4223 return waveOutWrite32(hWaveOut, (LPWAVEHDR)dwParam1, dwParam2);
4224 case WODM_GETDEVCAPS:
4225 /* FIXME: UNICODE/ANSI? */
4226 return waveOutGetDevCaps32A(hWaveOut, (LPWAVEOUTCAPS32A)dwParam1, dwParam2);
4227 case WODM_OPEN:
4228 FIXME(mmsys,"can't handle WODM_OPEN, please report.\n");
4229 break;
4230 default:
4231 ERR(mmsys,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n",
4232 hWaveOut,uMessage, dwParam1, dwParam2);
4233 break;
4234 }
4235 return wodMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4236 }
4237
4238 /**************************************************************************
4239 * waveOutMessage [MMSYSTEM.421]
4240 */
4241 DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
4242 DWORD dwParam1, DWORD dwParam2)
4243 {
4244 LPWAVEOPENDESC lpDesc;
4245
4246 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut);
4247 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4248 switch (uMessage) {
4249 case WODM_GETNUMDEVS:
4250 case WODM_SETVOLUME:
4251 case WODM_SETPITCH:
4252 case WODM_SETPLAYBACKRATE:
4253 case WODM_RESET:
4254 case WODM_PAUSE:
4255 case WODM_STOP:
4256 case WODM_CLOSE:
4257 /* no argument conversion needed */
4258 break;
4259 case WODM_GETPOS:
4260 return waveOutGetPosition16(hWaveOut, (LPMMTIME16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4261 case WODM_GETVOLUME:
4262 return waveOutGetVolume16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
4263 case WODM_GETPITCH:
4264 return waveOutGetPitch16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
4265 case WODM_GETPLAYBACKRATE:
4266 return waveOutGetPlaybackRate16(hWaveOut, (LPDWORD)PTR_SEG_TO_LIN(dwParam1));
4267 case WODM_GETDEVCAPS:
4268 return waveOutGetDevCaps16(hWaveOut, (LPWAVEOUTCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4269 case WODM_PREPARE:
4270 return waveOutPrepareHeader16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4271 case WODM_UNPREPARE:
4272 return waveOutUnprepareHeader16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4273 case WODM_WRITE:
4274 return waveOutWrite16(hWaveOut, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4275 case WODM_OPEN:
4276 FIXME(mmsys,"can't handle WODM_OPEN, please report.\n");
4277 break;
4278 default:
4279 ERR(mmsys,"(0x%04x, 0x%04x,%08lx,%08lx): unhandled message\n",
4280 hWaveOut,uMessage, dwParam1, dwParam2);
4281 }
4282 return wodMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4283 }
4284
4285 /**************************************************************************
4286 * waveInGetNumDevs [WINMM.151]
4287 */
4288 UINT32 WINAPI waveInGetNumDevs32()
4289 {
4290 return waveInGetNumDevs16();
4291 }
4292
4293 /**************************************************************************
4294 * waveInGetNumDevs [MMSYSTEM.501]
4295 */
4296 UINT16 WINAPI waveInGetNumDevs16()
4297 {
4298 UINT16 count = 0;
4299
4300 TRACE(mmsys, "waveInGetNumDevs\n");
4301 count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
4302 TRACE(mmsys, "waveInGetNumDevs return %u \n", count);
4303 return count;
4304 }
4305
4306 /**************************************************************************
4307 * waveInGetDevCapsA [WINMM.147]
4308 */
4309 UINT32 WINAPI waveInGetDevCaps32W(UINT32 uDeviceID, LPWAVEINCAPS32W lpCaps, UINT32 uSize)
4310 {
4311 WAVEINCAPS16 wic16;
4312 UINT32 ret = waveInGetDevCaps16(uDeviceID, &wic16,uSize);
4313
4314 lpCaps->wMid = wic16.wMid;
4315 lpCaps->wPid = wic16.wPid;
4316 lpCaps->vDriverVersion = wic16.vDriverVersion;
4317 lstrcpyAtoW(lpCaps->szPname, wic16.szPname);
4318 lpCaps->dwFormats = wic16.dwFormats;
4319 lpCaps->wChannels = wic16.wChannels;
4320
4321 return ret;
4322 }
4323
4324 /**************************************************************************
4325 * waveInGetDevCapsA [WINMM.146]
4326 */
4327 UINT32 WINAPI waveInGetDevCaps32A(UINT32 uDeviceID, LPWAVEINCAPS32A lpCaps, UINT32 uSize)
4328 {
4329 WAVEINCAPS16 wic16;
4330 UINT32 ret = waveInGetDevCaps16(uDeviceID, &wic16,uSize);
4331
4332 lpCaps->wMid = wic16.wMid;
4333 lpCaps->wPid = wic16.wPid;
4334 lpCaps->vDriverVersion = wic16.vDriverVersion;
4335 strcpy(lpCaps->szPname, wic16.szPname);
4336 lpCaps->dwFormats = wic16.dwFormats;
4337 lpCaps->wChannels = wic16.wChannels;
4338 return ret;
4339 }
4340
4341 /**************************************************************************
4342 * waveInGetDevCaps [MMSYSTEM.502]
4343 */
4344 UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize)
4345 {
4346 TRACE(mmsys, "waveInGetDevCaps\n");
4347
4348 return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
4349 }
4350
4351 /**************************************************************************
4352 * waveInGetErrorTextA [WINMM.148]
4353 */
4354 UINT32 WINAPI waveInGetErrorText32A(UINT32 uError, LPSTR lpText, UINT32 uSize)
4355 {
4356 TRACE(mmsys, "waveInGetErrorText\n");
4357 return(waveGetErrorText(uError, lpText, uSize));
4358 }
4359
4360 /**************************************************************************
4361 * waveInGetErrorTextW [WINMM.149]
4362 */
4363 UINT32 WINAPI waveInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
4364 {
4365 LPSTR txt = HeapAlloc(GetProcessHeap(), 0,uSize);
4366 UINT32 ret = waveGetErrorText(uError, txt, uSize);
4367
4368 lstrcpyAtoW(lpText, txt);
4369 HeapFree(GetProcessHeap(), 0, txt);
4370 return ret;
4371 }
4372
4373 /**************************************************************************
4374 * waveInGetErrorText [MMSYSTEM.503]
4375 */
4376 UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
4377 {
4378 TRACE(mmsys, "waveInGetErrorText\n");
4379 return(waveGetErrorText(uError, lpText, uSize));
4380 }
4381
4382 /**************************************************************************
4383 * waveInOpen [WINMM.154]
4384 */
4385 UINT32 WINAPI waveInOpen32(HWAVEIN32 * lphWaveIn, UINT32 uDeviceID,
4386 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
4387 DWORD dwInstance, DWORD dwFlags)
4388 {
4389 HWAVEIN16 hwin16;
4390 UINT32 ret = waveInOpen16(&hwin16,uDeviceID, lpFormat, dwCallback, dwInstance,
4391 CALLBACK32CONV(dwFlags));
4392 if (lphWaveIn) *lphWaveIn = hwin16;
4393 return ret;
4394 }
4395
4396 /**************************************************************************
4397 * waveInOpen [MMSYSTEM.504]
4398 */
4399 UINT16 WINAPI waveInOpen16(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
4400 const LPWAVEFORMAT lpFormat, DWORD dwCallback,
4401 DWORD dwInstance, DWORD dwFlags)
4402 {
4403 HWAVEIN16 hWaveIn;
4404 LPWAVEOPENDESC lpDesc;
4405 DWORD dwRet = 0;
4406 BOOL32 bMapperFlg = FALSE;
4407
4408 TRACE(mmsys, "(%p, %d, %p, %08lX, %08lX, %08lX);\n",
4409 lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
4410 if (dwFlags & WAVE_FORMAT_QUERY)
4411 TRACE(mmsys, "WAVE_FORMAT_QUERY requested !\n");
4412 if (uDeviceID == (UINT16)WAVE_MAPPER) {
4413 TRACE(mmsys, "WAVE_MAPPER mode requested !\n");
4414 bMapperFlg = TRUE;
4415 uDeviceID = 0;
4416 }
4417 if (lpFormat == NULL) return WAVERR_BADFORMAT;
4418 hWaveIn = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC));
4419 if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
4420 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4421 if (lpDesc == NULL) return MMSYSERR_NOMEM;
4422 lpDesc->hWave = hWaveIn;
4423 lpDesc->lpFormat = lpFormat;
4424 lpDesc->dwCallBack = dwCallback;
4425 lpDesc->dwInstance = dwInstance;
4426 while (uDeviceID < MAXWAVEDRIVERS) {
4427 dwRet = widMessage(uDeviceID, WIDM_OPEN,
4428 lpDesc->dwInstance, (DWORD)lpDesc, 0L);
4429 if (dwRet == MMSYSERR_NOERROR) break;
4430 if (!bMapperFlg) break;
4431 uDeviceID++;
4432 TRACE(mmsys, "WAVE_MAPPER mode ! try next driver...\n");
4433 }
4434 lpDesc->uDeviceID = uDeviceID;
4435 if (dwFlags & WAVE_FORMAT_QUERY) {
4436 TRACE(mmsys, "End of WAVE_FORMAT_QUERY !\n");
4437 dwRet = waveInClose16(hWaveIn);
4438 }
4439 return dwRet;
4440 }
4441
4442 /**************************************************************************
4443 * waveInClose [WINMM.145]
4444 */
4445 UINT32 WINAPI waveInClose32(HWAVEIN32 hWaveIn)
4446 {
4447 return waveInClose16(hWaveIn);
4448 }
4449
4450 /**************************************************************************
4451 * waveInClose [MMSYSTEM.505]
4452 */
4453 UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
4454 {
4455 LPWAVEOPENDESC lpDesc;
4456
4457 TRACE(mmsys, "(%04X)\n", hWaveIn);
4458 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4459 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4460 return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
4461 }
4462
4463 /**************************************************************************
4464 * waveInPrepareHeader [WINMM.155]
4465 */
4466 UINT32 WINAPI waveInPrepareHeader32(HWAVEIN32 hWaveIn,
4467 WAVEHDR * lpWaveInHdr, UINT32 uSize)
4468 {
4469 LPWAVEOPENDESC lpDesc;
4470
4471 TRACE(mmsys, "(%04X, %p, %u);\n",
4472 hWaveIn, lpWaveInHdr, uSize);
4473 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4474 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4475 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4476 lpWaveInHdr = lpWaveInHdr;
4477 lpWaveInHdr->lpNext = NULL;
4478 lpWaveInHdr->dwBytesRecorded = 0;
4479 TRACE(mmsys, "lpData=%p size=%lu \n",
4480 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4481 return widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance,
4482 (DWORD)lpWaveInHdr, uSize);
4483 }
4484
4485 /**************************************************************************
4486 * waveInPrepareHeader [MMSYSTEM.506]
4487 */
4488 UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,
4489 WAVEHDR * lpWaveInHdr, UINT16 uSize)
4490 {
4491 LPWAVEOPENDESC lpDesc;
4492 LPBYTE saveddata = lpWaveInHdr->lpData;
4493 UINT16 ret;
4494
4495 TRACE(mmsys, "(%04X, %p, %u);\n",
4496 hWaveIn, lpWaveInHdr, uSize);
4497 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4498 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4499 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4500 lpWaveInHdr = lpWaveInHdr;
4501 lpWaveInHdr->lpNext = NULL;
4502 lpWaveInHdr->dwBytesRecorded = 0;
4503
4504 TRACE(mmsys, "lpData=%p size=%lu \n",
4505 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4506 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
4507 ret = widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance,
4508 (DWORD)lpWaveInHdr,uSize);
4509 lpWaveInHdr->lpData = saveddata;
4510 return ret;
4511 }
4512
4513 /**************************************************************************
4514 * waveInUnprepareHeader [WINMM.159]
4515 */
4516 UINT32 WINAPI waveInUnprepareHeader32(HWAVEIN32 hWaveIn,
4517 WAVEHDR * lpWaveInHdr, UINT32 uSize)
4518 {
4519 LPWAVEOPENDESC lpDesc;
4520
4521 TRACE(mmsys, "(%04X, %p, %u);\n",
4522 hWaveIn, lpWaveInHdr, uSize);
4523 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4524 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4525 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4526 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
4527 lpWaveInHdr->lpData = NULL;
4528 lpWaveInHdr->lpNext = NULL;
4529 return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance,
4530 (DWORD)lpWaveInHdr, uSize);
4531 }
4532
4533 /**************************************************************************
4534 * waveInUnprepareHeader [MMSYSTEM.507]
4535 */
4536 UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,
4537 WAVEHDR * lpWaveInHdr, UINT16 uSize)
4538 {
4539 LPWAVEOPENDESC lpDesc;
4540
4541 TRACE(mmsys, "(%04X, %p, %u);\n",
4542 hWaveIn, lpWaveInHdr, uSize);
4543 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4544 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4545 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4546 /*USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData)); FIXME */
4547 lpWaveInHdr->lpData = NULL;
4548 lpWaveInHdr->lpNext = NULL;
4549 return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance,
4550 (DWORD)lpWaveInHdr, uSize);
4551 }
4552
4553 /**************************************************************************
4554 * waveInAddBuffer [WINMM.144]
4555 */
4556 UINT32 WINAPI waveInAddBuffer32(HWAVEIN32 hWaveIn,
4557 WAVEHDR * lpWaveInHdr, UINT32 uSize)
4558 {
4559 LPWAVEOPENDESC lpDesc;
4560
4561 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4562 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4563 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4564 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4565 lpWaveInHdr->lpNext = NULL;
4566 lpWaveInHdr->dwBytesRecorded = 0;
4567 TRACE(mmsys, "lpData=%p size=%lu \n",
4568 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4569 return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
4570 (DWORD)lpWaveInHdr, uSize);
4571
4572 }
4573
4574 /**************************************************************************
4575 * waveInAddBuffer [MMSYSTEM.508]
4576 */
4577 UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,
4578 WAVEHDR * lpWaveInHdr, UINT16 uSize)
4579 {
4580 LPWAVEOPENDESC lpDesc;
4581 UINT16 ret;
4582
4583 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
4584 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4585 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4586 if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
4587 lpWaveInHdr->lpNext = NULL;
4588 lpWaveInHdr->dwBytesRecorded = 0;
4589 lpWaveInHdr->lpData = PTR_SEG_TO_LIN(lpWaveInHdr->lpData);
4590 TRACE(mmsys, "lpData=%p size=%lu \n",
4591 lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
4592 ret = widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance,
4593 (DWORD)lpWaveInHdr, uSize);
4594 /*lpWaveInHdr->lpData = saveddata;*/
4595 return ret;
4596 }
4597
4598 /**************************************************************************
4599 * waveInStart [WINMM.157]
4600 */
4601 UINT32 WINAPI waveInStart32(HWAVEIN32 hWaveIn)
4602 {
4603 return waveInStart16(hWaveIn);
4604 }
4605
4606 /**************************************************************************
4607 * waveInStart [MMSYSTEM.509]
4608 */
4609 UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn)
4610 {
4611 LPWAVEOPENDESC lpDesc;
4612
4613 TRACE(mmsys, "(%04X)\n", hWaveIn);
4614 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4615 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4616 return widMessage(lpDesc->uDeviceID, WIDM_START, lpDesc->dwInstance, 0, 0);
4617 }
4618
4619 /**************************************************************************
4620 * waveInStop [WINMM.158]
4621 */
4622 UINT32 WINAPI waveInStop32(HWAVEIN32 hWaveIn)
4623 {
4624 return waveInStop16(hWaveIn);
4625 }
4626
4627 /**************************************************************************
4628 * waveInStop [MMSYSTEM.510]
4629 */
4630 UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn)
4631 {
4632 LPWAVEOPENDESC lpDesc;
4633
4634 TRACE(mmsys, "(%04X)\n", hWaveIn);
4635 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4636 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4637 return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
4638 }
4639
4640 /**************************************************************************
4641 * waveInReset [WINMM.156]
4642 */
4643 UINT32 WINAPI waveInReset32(HWAVEIN32 hWaveIn)
4644 {
4645 return waveInReset16(hWaveIn);
4646 }
4647
4648 /**************************************************************************
4649 * waveInReset [MMSYSTEM.511]
4650 */
4651 UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn)
4652 {
4653 LPWAVEOPENDESC lpDesc;
4654
4655 TRACE(mmsys, "(%04X)\n", hWaveIn);
4656 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4657 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4658 return widMessage(lpDesc->uDeviceID, WIDM_RESET, lpDesc->dwInstance, 0, 0);
4659 }
4660
4661 /**************************************************************************
4662 * waveInGetPosition [WINMM.152]
4663 */
4664 UINT32 WINAPI waveInGetPosition32(HWAVEIN32 hWaveIn, LPMMTIME32 lpTime,
4665 UINT32 uSize)
4666 {
4667 MMTIME16 mmt16;
4668 UINT32 ret;
4669
4670 mmt16.wType = lpTime->wType;
4671 ret = waveInGetPosition16(hWaveIn, &mmt16,uSize);
4672
4673 MMSYSTEM_MMTIME16to32(lpTime, &mmt16);
4674 return ret;
4675 }
4676
4677 /**************************************************************************
4678 * waveInGetPosition [MMSYSTEM.512]
4679 */
4680 UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime,
4681 UINT16 uSize)
4682 {
4683 LPWAVEOPENDESC lpDesc;
4684
4685 TRACE(mmsys, "(%04X, %p, %u);\n", hWaveIn, lpTime, uSize);
4686 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4687 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4688 return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance,
4689 (DWORD)lpTime, (DWORD)uSize);
4690 }
4691
4692 /**************************************************************************
4693 * waveInGetID [WINMM.150]
4694 */
4695 UINT32 WINAPI waveInGetID32(HWAVEIN32 hWaveIn, UINT32 * lpuDeviceID)
4696 {
4697 LPWAVEOPENDESC lpDesc;
4698
4699 TRACE(mmsys, "waveInGetID\n");
4700 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4701 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4702 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4703 *lpuDeviceID = lpDesc->uDeviceID;
4704 return 0;
4705 }
4706
4707 /**************************************************************************
4708 * waveInGetID [MMSYSTEM.513]
4709 */
4710 UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID)
4711 {
4712 LPWAVEOPENDESC lpDesc;
4713
4714 TRACE(mmsys, "waveInGetID\n");
4715 if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
4716 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4717 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4718 *lpuDeviceID = lpDesc->uDeviceID;
4719 return 0;
4720 }
4721
4722 /**************************************************************************
4723 * waveInMessage [WINMM.153]
4724 */
4725 DWORD WINAPI waveInMessage32(HWAVEIN32 hWaveIn, UINT32 uMessage,
4726 DWORD dwParam1, DWORD dwParam2)
4727 {
4728 LPWAVEOPENDESC lpDesc;
4729
4730 FIXME(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
4731 hWaveIn, uMessage, dwParam1, dwParam2);
4732 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4733 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4734 switch (uMessage) {
4735 case WIDM_OPEN:
4736 FIXME(mmsys, "cannot handle WIDM_OPEN, please report.\n");
4737 break;
4738 case WIDM_GETNUMDEVS:
4739 case WIDM_GETPOS:
4740 case WIDM_CLOSE:
4741 case WIDM_STOP:
4742 case WIDM_RESET:
4743 case WIDM_START:
4744 case WIDM_PREPARE:
4745 case WIDM_UNPREPARE:
4746 case WIDM_ADDBUFFER:
4747 case WIDM_PAUSE:
4748 /* no argument conversion needed */
4749 break;
4750 case WIDM_GETDEVCAPS:
4751 /*FIXME: ANSI/UNICODE */
4752 return waveInGetDevCaps32A(hWaveIn, (LPWAVEINCAPS32A)dwParam1, dwParam2);
4753 default:
4754 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4755 hWaveIn,uMessage, dwParam1, dwParam2);
4756 break;
4757 }
4758 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4759 }
4760
4761 /**************************************************************************
4762 * waveInMessage [MMSYSTEM.514]
4763 */
4764 DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
4765 DWORD dwParam1, DWORD dwParam2)
4766 {
4767 LPWAVEOPENDESC lpDesc;
4768
4769 FIXME(mmsys, "(%04X, %04X, %08lX, %08lX)\n",
4770 hWaveIn, uMessage, dwParam1, dwParam2);
4771 lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn);
4772 if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
4773 switch (uMessage) {
4774 case WIDM_OPEN:
4775 FIXME(mmsys,"cannot handle WIDM_OPEN, please report.\n");
4776 break;
4777 case WIDM_GETNUMDEVS:
4778 case WIDM_CLOSE:
4779 case WIDM_STOP :
4780 case WIDM_RESET:
4781 case WIDM_START:
4782 case WIDM_PAUSE:
4783 /* no argument conversion needed */
4784 break;
4785 case WIDM_GETDEVCAPS:
4786 return waveInGetDevCaps16(hWaveIn, (LPWAVEINCAPS16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4787 case WIDM_GETPOS:
4788 return waveInGetPosition16(hWaveIn, (LPMMTIME16)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4789 case WIDM_PREPARE:
4790 return waveInPrepareHeader16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4791 case WIDM_UNPREPARE:
4792 return waveInUnprepareHeader16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4793 case WIDM_ADDBUFFER:
4794 return waveInAddBuffer16(hWaveIn, (LPWAVEHDR)PTR_SEG_TO_LIN(dwParam1), dwParam2);
4795 default:
4796 ERR(mmsys,"(%04x,%04x,%08lx,%08lx): unhandled message\n",
4797 hWaveIn,uMessage, dwParam1, dwParam2);
4798 break;
4799 }
4800 return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2);
4801 }
4802
4803 /**************************************************************************
4804 * DrvOpen [MMSYSTEM.1100]
4805 */
4806 HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
4807 {
4808 TRACE(mmsys,"('%s','%s',%08lX);\n", lpDriverName, lpSectionName, lParam);
4809
4810 return OpenDriver16(lpDriverName, lpSectionName, lParam);
4811 }
4812
4813 /**************************************************************************
4814 * DrvClose [MMSYSTEM.1101]
4815 */
4816 LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
4817 {
4818 TRACE(mmsys, "(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
4819
4820 return CloseDriver16(hDrvr, lParam1, lParam2);
4821 }
4822
4823 /**************************************************************************
4824 * DrvSendMessage [MMSYSTEM.1102]
4825 */
4826 LRESULT WINAPI DrvSendMessage(HDRVR16 hDriver, WORD msg, LPARAM lParam1,
4827 LPARAM lParam2)
4828 {
4829 /* DWORD dwDriverID = 0; */
4830
4831 FIXME(mmsys, "(%04X, %04X, %08lX, %08lX);\n", hDriver, msg, lParam1, lParam2);
4832 return MMSYSERR_NOTENABLED;
4833 /* FIXME: wrong ... */
4834 /* should known the mapping between hDrv and wDevIDs */
4835 /* MCICDAUDIO_DriverProc16(dwDriverID, hDriver, msg, lParam1, lParam2); */
4836 }
4837
4838 /**************************************************************************
4839 * DrvGetModuleHandle [MMSYSTEM.1103]
4840 */
4841 HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrvr)
4842 {
4843 return GetDriverModuleHandle16(hDrvr);
4844 }
4845
4846 /**************************************************************************
4847 * DrvDefDriverProc [MMSYSTEM.1104]
4848 */
4849 LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverID, HDRVR16 hDriv, WORD wMsg,
4850 DWORD dwParam1, DWORD dwParam2)
4851 {
4852 return DefDriverProc16(dwDriverID, hDriv, wMsg, dwParam1, dwParam2);
4853 }
4854
4855 /**************************************************************************
4856 * DefDriverProc32 [WINMM.5]
4857 */
4858 LRESULT WINAPI DefDriverProc32(DWORD dwDriverIdentifier, HDRVR32 hdrvr,
4859 UINT32 Msg, LPARAM lParam1, LPARAM lParam2)
4860 {
4861 switch (Msg) {
4862 case DRV_LOAD:
4863 case DRV_DISABLE:
4864 case DRV_INSTALL:
4865 return 0;
4866 case DRV_ENABLE:
4867 case DRV_FREE:
4868 case DRV_REMOVE:
4869 return 1;
4870 default:
4871 return 0;
4872 }
4873 }
4874
4875 /**************************************************************************
4876 * mmThreadCreate [MMSYSTEM.1120]
4877 */
4878 LRESULT WINAPI mmThreadCreate16(LPVOID x1, LPWORD x2, DWORD x3, DWORD x4)
4879 {
4880 FIXME(mmsys,"(%p,%p,%08lx,%08lx): stub!\n",x1,x2,x3,x4);
4881 *x2 = 0xbabe;
4882 return 0;
4883 }
4884
4885 /**************************************************************************
4886 * mmThreadGetTask [MMSYSTEM.1125]
4887 */
4888 LRESULT WINAPI mmThreadGetTask16(WORD hnd)
4889 {
4890 FIXME(mmsys,"(%04x): stub!\n", hnd);
4891 return GetCurrentTask();
4892 }
4893
4894 /**************************************************************************
4895 * mmThreadSignal [MMSYSTEM.1121]
4896 */
4897 LRESULT WINAPI mmThreadSignal16(WORD hnd)
4898 {
4899 FIXME(mmsys,"(%04x): stub!\n", hnd);
4900 return 0;
4901 }
4902
4903 /**************************************************************************
4904 * mmTaskCreate [MMSYSTEM.900]
4905 */
4906 HINSTANCE16 WINAPI mmTaskCreate16(LPWORD lphnd,HINSTANCE16 *hMmTask, DWORD x2)
4907 {
4908 DWORD showCmd = 0x40002;
4909 LPSTR cmdline;
4910 WORD sel1, sel2;
4911 LOADPARAMS *lp;
4912 HINSTANCE16 ret, handle;
4913
4914 TRACE(mmsys,"(%p,%p,%08lx);\n", lphnd, hMmTask,x2);
4915 cmdline = (LPSTR)HeapAlloc(GetProcessHeap(), 0, 0x0d);
4916 cmdline[0] = 0x0d;
4917 (DWORD)cmdline[1] = (DWORD)lphnd;
4918 (DWORD)cmdline[5] = x2;
4919 (DWORD)cmdline[9] = 0;
4920
4921 sel1 = SELECTOR_AllocBlock(cmdline, 0x0d, SEGMENT_DATA, FALSE, FALSE);
4922 sel2 = SELECTOR_AllocBlock(&showCmd, sizeof(showCmd),
4923 SEGMENT_DATA, FALSE, FALSE);
4924
4925 lp = (LOADPARAMS *)HeapAlloc(GetProcessHeap(), 0, sizeof(LOADPARAMS));
4926 lp->hEnvironment = 0;
4927 lp->cmdLine = PTR_SEG_OFF_TO_SEGPTR(sel1, 0);
4928 lp->showCmd = PTR_SEG_OFF_TO_SEGPTR(sel2, 0);
4929 lp->reserved = 0;
4930
4931 ret = LoadModule16("c:\\windows\\mmtask.tsk", lp);
4932 if (ret < 32) {
4933 if (ret)
4934 ret = 1;
4935 else
4936 ret = 2;
4937 handle = 0;
4938 }
4939 else {
4940 handle = ret;
4941 ret = 0;
4942 }
4943 if (hMmTask)
4944 *(HINSTANCE16 *)PTR_SEG_TO_LIN(hMmTask) = handle;
4945
4946 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel2, 0));
4947 UnMapLS(PTR_SEG_OFF_TO_SEGPTR(sel1, 0));
4948
4949 HeapFree(GetProcessHeap(), 0, lp);
4950 HeapFree(GetProcessHeap(), 0, cmdline);
4951
4952 return ret;
4953 }
4954
4955 /**************************************************************************
4956 * mmTaskSignal [MMSYSTEM.903]
4957 */
4958 LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
4959 {
4960 TRACE(mmsys,"(%04x);\n", ht);
4961 return PostAppMessage32A(ht, WM_USER, 0, 0);
4962 }
Quick hack tree for wine patches julliard doesn't want to commit