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