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