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