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