?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added support for getting the wave device name.
[wine/wine-kai.git] / dlls / winmm / lolvldrv.c
blobcb472b0b34bde831234934f4cb1cfc44806b94ec
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MMSYTEM low level drivers handling functions
5 *
6 * Copyright 1999 Eric Pouech
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include <string.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <assert.h>
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winreg.h"
30 #include "winver.h"
31 #include "winemm.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
35
36 LRESULT (*pFnCallMMDrvFunc16)(FARPROC16,WORD,WORD,LONG,LONG,LONG) /* = NULL */;
37 unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER) /* = NULL */;
38
39 /* each known type of driver has an instance of this structure */
40 typedef struct tagWINE_LLTYPE {
41 /* those attributes depend on the specification of the type */
42 LPCSTR typestr; /* name (for debugging) */
43 BOOL bSupportMapper; /* if type is allowed to support mapper */
44 MMDRV_MAPFUNC Map16To32A; /* those are function pointers to handle */
45 MMDRV_UNMAPFUNC UnMap16To32A; /* the parameter conversion (16 vs 32 bit) */
46 MMDRV_MAPFUNC Map32ATo16; /* when hi-func (in mmsystem or winmm) and */
47 MMDRV_UNMAPFUNC UnMap32ATo16; /* low-func (in .drv) do not match */
48 LPDRVCALLBACK Callback; /* handles callback for a specified type */
49 /* those attributes reflect the loaded/current situation for the type */
50 UINT wMaxId; /* number of loaded devices (sum across all loaded drivers */
51 LPWINE_MLD lpMlds; /* "static" mlds to access the part though device IDs */
52 int nMapper; /* index to mapper */
53 } WINE_LLTYPE;
54
55 static int MMDrvsHi /* = 0 */;
56 static WINE_MM_DRIVER MMDrvs[3];
57 static LPWINE_MLD MM_MLDrvs[40];
58 #define MAX_MM_MLDRVS (sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]))
59
60 #define A(_x,_y) {#_y, _x, NULL, NULL, NULL, NULL, NULL, 0, NULL, -1}
61 /* Note: the indices of this array must match the definitions
62 * of the MMDRV_???? manifest constants
63 */
64 static WINE_LLTYPE llTypes[MMDRV_MAX] = {
65 A(TRUE, Aux),
66 A(FALSE, Mixer),
67 A(TRUE, MidiIn),
68 A(TRUE, MidiOut),
69 A(TRUE, WaveIn),
70 A(TRUE, WaveOut),
71 };
72 #undef A
73
74 /******************************************************************
75 * MMDRV_InstallMap
76 *
77 *
78 */
79 void MMDRV_InstallMap(unsigned int drv,
80 MMDRV_MAPFUNC mp1632, MMDRV_UNMAPFUNC um1632,
81 MMDRV_MAPFUNC mp3216, MMDRV_UNMAPFUNC um3216,
82 LPDRVCALLBACK cb)
83 {
84 assert(drv < MMDRV_MAX);
85 llTypes[drv].Map16To32A = mp1632;
86 llTypes[drv].UnMap16To32A = um1632;
87 llTypes[drv].Map32ATo16 = mp3216;
88 llTypes[drv].UnMap32ATo16 = um1632;
89 llTypes[drv].Callback = cb;
90 }
91
92 /******************************************************************
93 * MMDRV_Is32
94 *
95 */
96 BOOL MMDRV_Is32(unsigned int idx)
97 {
98 return MMDrvs[idx].bIs32;
99 }
100
101 /**************************************************************************
102 * MMDRV_GetDescription32 [internal]
103 */
104 static BOOL MMDRV_GetDescription32(const char* fname, char* buf, int buflen)
105 {
106 OFSTRUCT ofs;
107 DWORD h;
108 LPVOID ptr = 0;
109 LPVOID val;
110 DWORD dw;
111 BOOL ret = FALSE;
112 UINT u;
113 FARPROC pGetFileVersionInfoSizeA;
114 FARPROC pGetFileVersionInfoA;
115 FARPROC pVerQueryValueA;
116 HMODULE hmodule = 0;
117
118 #define E(_x) do {TRACE _x;goto theEnd;} while(0)
119
120 if (OpenFile(fname, &ofs, OF_EXIST)==HFILE_ERROR) E(("Can't find file %s\n", fname));
121
122 if (!(hmodule = LoadLibraryA( "version.dll" ))) goto theEnd;
123 if (!(pGetFileVersionInfoSizeA = GetProcAddress( hmodule, "GetFileVersionInfoSizeA" )))
124 goto theEnd;
125 if (!(pGetFileVersionInfoA = GetProcAddress( hmodule, "GetFileVersionInfoA" )))
126 goto theEnd;
127 if (!(pVerQueryValueA = GetProcAddress( hmodule, "VerQueryValueA" )))
128 goto theEnd;
129
130 if (!(dw = pGetFileVersionInfoSizeA(ofs.szPathName, &h))) E(("Can't get FVIS\n"));
131 if (!(ptr = HeapAlloc(GetProcessHeap(), 0, dw))) E(("OOM\n"));
132 if (!pGetFileVersionInfoA(ofs.szPathName, h, dw, ptr)) E(("Can't get FVI\n"));
133
134 #define A(_x) if (pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\" #_x, &val, &u)) \
135 TRACE(#_x " => %s\n", (LPSTR)val); else TRACE(#_x " @\n")
136
137 A(CompanyName);
138 A(FileDescription);
139 A(FileVersion);
140 A(InternalName);
141 A(LegalCopyright);
142 A(OriginalFilename);
143 A(ProductName);
144 A(ProductVersion);
145 A(Comments);
146 A(LegalTrademarks);
147 A(PrivateBuild);
148 A(SpecialBuild);
149 #undef A
150
151 if (!pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\ProductName", &val, &u)) E(("Can't get product name\n"));
152 lstrcpynA(buf, val, buflen);
153
154 #undef E
155 ret = TRUE;
156 theEnd:
157 HeapFree(GetProcessHeap(), 0, ptr);
158 if (hmodule) FreeLibrary( hmodule );
159 return ret;
160 }
161
162 /**************************************************************************
163 * MMDRV_GetNum [internal]
164 */
165 UINT MMDRV_GetNum(UINT type)
166 {
167 assert(type < MMDRV_MAX);
168 return llTypes[type].wMaxId;
169 }
170
171 /**************************************************************************
172 * MMDRV_Message [internal]
173 */
174 DWORD MMDRV_Message(LPWINE_MLD mld, WORD wMsg, DWORD dwParam1,
175 DWORD dwParam2, BOOL bFrom32)
176 {
177 LPWINE_MM_DRIVER lpDrv;
178 DWORD ret;
179 WINE_MM_DRIVER_PART* part;
180 WINE_LLTYPE* llType = &llTypes[mld->type];
181 WINMM_MapType map;
182 int devID;
183
184 TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx %c)\n",
185 llTypes[mld->type].typestr, mld->uDeviceID, wMsg,
186 mld->dwDriverInstance, dwParam1, dwParam2, bFrom32?'Y':'N');
187
188 if (mld->uDeviceID == (UINT16)-1) {
189 if (!llType->bSupportMapper) {
190 WARN("uDev=-1 requested on non-mappable ll type %s\n",
191 llTypes[mld->type].typestr);
192 return MMSYSERR_BADDEVICEID;
193 }
194 devID = -1;
195 } else {
196 if (mld->uDeviceID >= llType->wMaxId) {
197 WARN("uDev(%u) requested >= max (%d)\n", mld->uDeviceID, llType->wMaxId);
198 return MMSYSERR_BADDEVICEID;
199 }
200 devID = mld->uDeviceID;
201 }
202
203 lpDrv = &MMDrvs[mld->mmdIndex];
204 part = &lpDrv->parts[mld->type];
205
206 #if 0
207 /* some sanity checks */
208 if (!(part->nIDMin <= devID))
209 ERR("!(part->nIDMin(%d) <= devID(%d))\n", part->nIDMin, devID);
210 if (!(devID < part->nIDMax))
211 ERR("!(devID(%d) < part->nIDMax(%d))\n", devID, part->nIDMax);
212 #endif
213
214 if (lpDrv->bIs32) {
215 assert(part->u.fnMessage32);
216
217 if (bFrom32) {
218 TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
219 mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
220 ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
221 TRACE("=> %lu\n", ret);
222 } else {
223 map = llType->Map16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
224 switch (map) {
225 case WINMM_MAP_NOMEM:
226 ret = MMSYSERR_NOMEM;
227 break;
228 case WINMM_MAP_MSGERROR:
229 FIXME("NIY: no conversion yet 16->32 (%u)\n", wMsg);
230 ret = MMSYSERR_ERROR;
231 break;
232 case WINMM_MAP_OK:
233 case WINMM_MAP_OKMEM:
234 TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
235 mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
236 ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance,
237 dwParam1, dwParam2);
238 TRACE("=> %lu\n", ret);
239 if (map == WINMM_MAP_OKMEM)
240 llType->UnMap16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2, ret);
241 break;
242 default:
243 FIXME("NIY\n");
244 ret = MMSYSERR_NOTSUPPORTED;
245 break;
246 }
247 }
248 } else {
249 assert(part->u.fnMessage16 && pFnCallMMDrvFunc16);
250
251 if (bFrom32) {
252 map = llType->Map32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
253 switch (map) {
254 case WINMM_MAP_NOMEM:
255 ret = MMSYSERR_NOMEM;
256 break;
257 case WINMM_MAP_MSGERROR:
258 FIXME("NIY: no conversion yet 32->16 (%u)\n", wMsg);
259 ret = MMSYSERR_ERROR;
260 break;
261 case WINMM_MAP_OK:
262 case WINMM_MAP_OKMEM:
263 TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
264 mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
265 ret = pFnCallMMDrvFunc16((FARPROC16)part->u.fnMessage16,
266 mld->uDeviceID, wMsg, mld->dwDriverInstance,
267 dwParam1, dwParam2);
268 TRACE("=> %lu\n", ret);
269 if (map == WINMM_MAP_OKMEM)
270 llType->UnMap32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2, ret);
271 break;
272 default:
273 FIXME("NIY\n");
274 ret = MMSYSERR_NOTSUPPORTED;
275 break;
276 }
277 } else {
278 TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
279 mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
280 ret = pFnCallMMDrvFunc16((FARPROC16)part->u.fnMessage16,
281 mld->uDeviceID, wMsg, mld->dwDriverInstance,
282 dwParam1, dwParam2);
283 TRACE("=> %lu\n", ret);
284 }
285 }
286 return ret;
287 }
288
289 /**************************************************************************
290 * MMDRV_Alloc [internal]
291 */
292 LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
293 DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32)
294 {
295 LPWINE_MLD mld;
296 UINT i;
297
298 mld = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
299 if (!mld) return NULL;
300
301 /* find an empty slot in MM_MLDrvs table */
302 for (i = 0; i < MAX_MM_MLDRVS; i++) if (!MM_MLDrvs[i]) break;
303
304 if (i == MAX_MM_MLDRVS) {
305 /* the MM_MLDrvs table could be made growable in the future if needed */
306 ERR("Too many open drivers\n");
307 return NULL;
308 }
309 MM_MLDrvs[i] = mld;
310 *hndl = (HANDLE)(i | 0x8000);
311
312 mld->type = type;
313 if ((UINT)*hndl < MMDRV_GetNum(type) || HIWORD(*hndl) != 0) {
314 /* FIXME: those conditions must be fulfilled so that:
315 * - we can distinguish between device IDs and handles
316 * - we can use handles as 16 or 32 bit entities
317 */
318 ERR("Shouldn't happen. Bad allocation scheme\n");
319 }
320
321 mld->bFrom32 = bFrom32;
322 mld->dwFlags = HIWORD(*dwFlags);
323 mld->dwCallback = *dwCallback;
324 mld->dwClientInstance = *dwInstance;
325
326 if (llTypes[type].Callback)
327 {
328 *dwFlags = LOWORD(*dwFlags) | CALLBACK_FUNCTION;
329 *dwCallback = (DWORD)llTypes[type].Callback;
330 *dwInstance = (DWORD)mld; /* FIXME: wouldn't some 16 bit drivers only use the loword ? */
331 }
332
333 return mld;
334 }
335
336 /**************************************************************************
337 * MMDRV_Free [internal]
338 */
339 void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld)
340 {
341 if ((UINT)hndl & 0x8000) {
342 unsigned idx = (UINT)hndl & ~0x8000;
343 if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
344 MM_MLDrvs[idx] = NULL;
345 HeapFree(GetProcessHeap(), 0, mld);
346 return;
347 }
348 }
349 ERR("Bad Handle %p at %p (not freed)\n", hndl, mld);
350 }
351
352 /**************************************************************************
353 * MMDRV_Open [internal]
354 */
355 DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags)
356 {
357 DWORD dwRet = MMSYSERR_BADDEVICEID;
358 DWORD dwInstance;
359 WINE_LLTYPE* llType = &llTypes[mld->type];
360
361 mld->dwDriverInstance = (DWORD)&dwInstance;
362
363 if (mld->uDeviceID == (UINT)-1 || mld->uDeviceID == (UINT16)-1) {
364 TRACE("MAPPER mode requested !\n");
365 /* check if mapper is supported by type */
366 if (llType->bSupportMapper) {
367 if (llType->nMapper == -1) {
368 /* no driver for mapper has been loaded, try a dumb implementation */
369 TRACE("No mapper loaded, doing it by hand\n");
370 for (mld->uDeviceID = 0; mld->uDeviceID < llType->wMaxId; mld->uDeviceID++) {
371 if ((dwRet = MMDRV_Open(mld, wMsg, dwParam1, dwFlags)) == MMSYSERR_NOERROR) {
372 /* to share this function epilog */
373 dwInstance = mld->dwDriverInstance;
374 break;
375 }
376 }
377 } else {
378 mld->uDeviceID = (UINT16)-1;
379 mld->mmdIndex = llType->lpMlds[-1].mmdIndex;
380 TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
381 dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE);
382 }
383 }
384 } else {
385 if (mld->uDeviceID < llType->wMaxId) {
386 mld->mmdIndex = llType->lpMlds[mld->uDeviceID].mmdIndex;
387 TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
388 dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE);
389 }
390 }
391 if (dwRet == MMSYSERR_NOERROR)
392 mld->dwDriverInstance = dwInstance;
393 return dwRet;
394 }
395
396 /**************************************************************************
397 * MMDRV_Close [internal]
398 */
399 DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg)
400 {
401 return MMDRV_Message(mld, wMsg, 0L, 0L, TRUE);
402 }
403
404 /**************************************************************************
405 * MMDRV_GetByID [internal]
406 */
407 LPWINE_MLD MMDRV_GetByID(UINT uDevID, UINT type)
408 {
409 if (uDevID < llTypes[type].wMaxId)
410 return &llTypes[type].lpMlds[uDevID];
411 if ((uDevID == (UINT16)-1 || uDevID == (UINT)-1) && llTypes[type].nMapper != -1)
412 return &llTypes[type].lpMlds[-1];
413 return NULL;
414 }
415
416 /**************************************************************************
417 * MMDRV_Get [internal]
418 */
419 LPWINE_MLD MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID)
420 {
421 LPWINE_MLD mld = NULL;
422 UINT hndl = (UINT)_hndl;
423
424 assert(type < MMDRV_MAX);
425
426 if (hndl >= llTypes[type].wMaxId &&
427 hndl != (UINT16)-1 && hndl != (UINT)-1) {
428 if (hndl & 0x8000) {
429 hndl = hndl & ~0x8000;
430 if (hndl < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
431 mld = MM_MLDrvs[hndl];
432 if (!mld || !HeapValidate(GetProcessHeap(), 0, mld) || mld->type != type)
433 mld = NULL;
434 }
435 hndl = hndl | 0x8000;
436 }
437 }
438 if (mld == NULL && bCanBeID) {
439 mld = MMDRV_GetByID(hndl, type);
440 }
441 return mld;
442 }
443
444 /**************************************************************************
445 * MMDRV_GetRelated [internal]
446 */
447 LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType,
448 BOOL bSrcCanBeID, UINT dstType)
449 {
450 LPWINE_MLD mld;
451
452 if ((mld = MMDRV_Get(hndl, srcType, bSrcCanBeID)) != NULL) {
453 WINE_MM_DRIVER_PART* part = &MMDrvs[mld->mmdIndex].parts[dstType];
454 if (part->nIDMin < part->nIDMax)
455 return MMDRV_GetByID(part->nIDMin, dstType);
456 }
457 return NULL;
458 }
459
460 /**************************************************************************
461 * MMDRV_PhysicalFeatures [internal]
462 */
463 UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1,
464 DWORD dwParam2, BOOL bFrom32)
465 {
466 WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex];
467
468 TRACE("(%p, %04x, %08lx, %08lx)\n", mld, uMsg, dwParam1, dwParam2);
469
470 /* all those function calls are undocumented */
471 switch (uMsg) {
472 case DRV_QUERYDRVENTRY:
473 if (bFrom32)
474 lstrcpynA((LPSTR)dwParam1, lpDrv->drvname, LOWORD(dwParam2));
475 else
476 lstrcpynA((LPSTR)MapSL(dwParam1), lpDrv->drvname, LOWORD(dwParam2));
477 break;
478 case DRV_QUERYDEVNODE:
479 if (bFrom32)
480 *(LPDWORD)dwParam1 = 0L; /* should be DevNode */
481 else
482 *(DWORD*)MapSL(dwParam1) = 0L;
483 break;
484 case DRV_QUERYNAME:
485 WARN("NIY QueryName\n");
486 break;
487 case DRV_QUERYDRIVERIDS:
488 WARN("NIY call VxD\n");
489 /* should call VxD MMDEVLDR with (DevNode, dwParam1 and dwParam2) as pmts
490 * dwParam1 is buffer and dwParam2 is sizeof(buffer)
491 * I don't know where the result is stored though
492 */
493 break;
494 case DRV_QUERYMAPPABLE:
495 return (lpDrv->bIsMapper) ? 2 : 0;
496
497 case DRVM_MAPPER_PREFERRED_GET:
498 /* FIXME: get from registry someday */
499 if (bFrom32) {
500 *((LPDWORD)dwParam1) = -1; /* No preferred device */
501 break;
502 }
503 return MMSYSERR_INVALPARAM;
504
505 case DRV_QUERYDEVICEINTERFACE:
506 case DRV_QUERYDEVICEINTERFACESIZE:
507 if (bFrom32)
508 return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE);
509
510 return MMSYSERR_INVALPARAM;
511
512 case DRV_QUERYDSOUNDIFACE: /* Wine-specific: Retrieve DirectSound interface */
513 case DRV_QUERYDSOUNDDESC: /* Wine-specific: Retrieve DirectSound driver description*/
514 case DRV_QUERYDSOUNDGUID: /* Wine-specific: Retrieve DirectSound driver GUID */
515 return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE);
516
517 default:
518 WARN("Unknown call %04x\n", uMsg);
519 return MMSYSERR_INVALPARAM;
520 }
521 return 0L;
522 }
523
524 /**************************************************************************
525 * MMDRV_InitPerType [internal]
526 */
527 static BOOL MMDRV_InitPerType(LPWINE_MM_DRIVER lpDrv, UINT type, UINT wMsg)
528 {
529 WINE_MM_DRIVER_PART* part = &lpDrv->parts[type];
530 DWORD ret;
531 UINT count = 0;
532 int i, k;
533
534 part->nIDMin = part->nIDMax = 0;
535
536 /* for DRVM_INIT and DRVM_ENABLE, dwParam2 should be PnP node */
537 /* the DRVM_ENABLE is only required when the PnP node is non zero */
538
539 if (lpDrv->bIs32 && part->u.fnMessage32) {
540 ret = part->u.fnMessage32(0, DRVM_INIT, 0L, 0L, 0L);
541 TRACE("DRVM_INIT => %08lx\n", ret);
542 #if 0
543 ret = part->u.fnMessage32(0, DRVM_ENABLE, 0L, 0L, 0L);
544 TRACE("DRVM_ENABLE => %08lx\n", ret);
545 #endif
546 count = part->u.fnMessage32(0, wMsg, 0L, 0L, 0L);
547 } else if (!lpDrv->bIs32 && part->u.fnMessage16 && pFnCallMMDrvFunc16) {
548 ret = pFnCallMMDrvFunc16((FARPROC16)part->u.fnMessage16,
549 0, DRVM_INIT, 0L, 0L, 0L);
550 TRACE("DRVM_INIT => %08lx\n", ret);
551 #if 0
552 ret = pFnCallMMDrvFunc16((FARPROC16)part->u.fnMessage16,
553 0, DRVM_ENABLE, 0L, 0L, 0L);
554 TRACE("DRVM_ENABLE => %08lx\n", ret);
555 #endif
556 count = pFnCallMMDrvFunc16((FARPROC16)part->u.fnMessage16,
557 0, wMsg, 0L, 0L, 0L);
558 } else {
559 return FALSE;
560 }
561
562 TRACE("Got %u dev for (%s:%s)\n", count, lpDrv->drvname, llTypes[type].typestr);
563
564 /* got some drivers */
565 if (lpDrv->bIsMapper) {
566 /* it seems native mappers return 0 devices :-( */
567 if (llTypes[type].nMapper != -1)
568 ERR("Two mappers for type %s (%d, %s)\n",
569 llTypes[type].typestr, llTypes[type].nMapper, lpDrv->drvname);
570 if (count > 1)
571 ERR("Strange: mapper with %d > 1 devices\n", count);
572 llTypes[type].nMapper = MMDrvsHi;
573 } else {
574 if (count == 0)
575 return FALSE;
576 part->nIDMin = llTypes[type].wMaxId;
577 llTypes[type].wMaxId += count;
578 part->nIDMax = llTypes[type].wMaxId;
579 }
580 TRACE("Setting min=%d max=%d (ttop=%d) for (%s:%s)\n",
581 part->nIDMin, part->nIDMax, llTypes[type].wMaxId,
582 lpDrv->drvname, llTypes[type].typestr);
583 /* realloc translation table */
584 if (llTypes[type].lpMlds)
585 llTypes[type].lpMlds = (LPWINE_MLD)
586 HeapReAlloc(GetProcessHeap(), 0, llTypes[type].lpMlds - 1,
587 sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
588 else
589 llTypes[type].lpMlds = (LPWINE_MLD)
590 HeapAlloc(GetProcessHeap(), 0,
591 sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
592
593 /* re-build the translation table */
594 if (llTypes[type].nMapper != -1) {
595 TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, -1, MMDrvs[llTypes[type].nMapper].drvname);
596 llTypes[type].lpMlds[-1].uDeviceID = (UINT16)-1;
597 llTypes[type].lpMlds[-1].type = type;
598 llTypes[type].lpMlds[-1].mmdIndex = llTypes[type].nMapper;
599 llTypes[type].lpMlds[-1].dwDriverInstance = 0;
600 }
601 for (i = k = 0; i <= MMDrvsHi; i++) {
602 while (MMDrvs[i].parts[type].nIDMin <= k && k < MMDrvs[i].parts[type].nIDMax) {
603 TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, k, MMDrvs[i].drvname);
604 llTypes[type].lpMlds[k].uDeviceID = k;
605 llTypes[type].lpMlds[k].type = type;
606 llTypes[type].lpMlds[k].mmdIndex = i;
607 llTypes[type].lpMlds[k].dwDriverInstance = 0;
608 k++;
609 }
610 }
611 return TRUE;
612 }
613
614 /**************************************************************************
615 * MMDRV_Install [internal]
616 */
617 static BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
618 {
619 int i, count = 0;
620 LPWINE_MM_DRIVER lpDrv = &MMDrvs[MMDrvsHi];
621 LPWINE_DRIVER d;
622
623 TRACE("('%s', '%s', mapper=%c);\n", drvRegName, drvFileName, bIsMapper ? 'Y' : 'N');
624
625 /* be sure that size of MMDrvs matches the max number of loadable drivers !!
626 * if not just increase size of MMDrvs */
627 assert(MMDrvsHi <= sizeof(MMDrvs)/sizeof(MMDrvs[0]));
628
629 for (i = 0; i < MMDrvsHi; i++) {
630 if (!strcmp(drvRegName, MMDrvs[i].drvname)) return FALSE;
631 }
632
633 memset(lpDrv, 0, sizeof(*lpDrv));
634
635 if (!(lpDrv->hDriver = OpenDriverA(drvFileName, 0, 0))) {
636 WARN("Couldn't open driver '%s'\n", drvFileName);
637 return FALSE;
638 }
639
640 d = DRIVER_FindFromHDrvr(lpDrv->hDriver);
641 lpDrv->bIs32 = (d->dwFlags & WINE_GDF_16BIT) ? FALSE : TRUE;
642
643 /* Then look for xxxMessage functions */
644 #define AA(_h,_w,_x,_y,_z) \
645 func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
646 if (func != NULL) \
647 { lpDrv->parts[_w].u.fnMessage##_y = func; count++; \
648 TRACE("Got %d bit func '%s'\n", _y, #_x); }
649
650 if (lpDrv->bIs32) {
651 WINEMM_msgFunc32 func;
652 char buffer[128];
653
654 if (d->d.d32.hModule) {
655 #define A(_x,_y) AA(d->d.d32.hModule,_x,_y,32,GetProcAddress)
656 A(MMDRV_AUX, auxMessage);
657 A(MMDRV_MIXER, mxdMessage);
658 A(MMDRV_MIDIIN, midMessage);
659 A(MMDRV_MIDIOUT, modMessage);
660 A(MMDRV_WAVEIN, widMessage);
661 A(MMDRV_WAVEOUT, wodMessage);
662 #undef A
663 }
664 if (TRACE_ON(winmm)) {
665 if (MMDRV_GetDescription32(drvFileName, buffer, sizeof(buffer)))
666 TRACE("%s => %s\n", drvFileName, buffer);
667 else
668 TRACE("%s => No description\n", drvFileName);
669 }
670 } else if (WINMM_CheckForMMSystem() && pFnLoadMMDrvFunc16) {
671 count += pFnLoadMMDrvFunc16(drvFileName, d, lpDrv);
672 }
673 #undef AA
674
675 if (!count) {
676 CloseDriver(lpDrv->hDriver, 0, 0);
677 WARN("No message functions found\n");
678 return FALSE;
679 }
680
681 /* FIXME: being a mapper or not should be known by another way */
682 /* it's known for NE drvs (the description is of the form '*mapper: *'
683 * I don't have any clue for PE drvs
684 */
685 lpDrv->bIsMapper = bIsMapper;
686 lpDrv->drvname = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(drvRegName) + 1), drvRegName);
687
688 /* Finish init and get the count of the devices */
689 i = 0;
690 if (MMDRV_InitPerType(lpDrv, MMDRV_AUX, AUXDM_GETNUMDEVS)) i = 1;
691 if (MMDRV_InitPerType(lpDrv, MMDRV_MIXER, MXDM_GETNUMDEVS)) i = 1;
692 if (MMDRV_InitPerType(lpDrv, MMDRV_MIDIIN, MIDM_GETNUMDEVS)) i = 1;
693 if (MMDRV_InitPerType(lpDrv, MMDRV_MIDIOUT, MODM_GETNUMDEVS)) i = 1;
694 if (MMDRV_InitPerType(lpDrv, MMDRV_WAVEIN, WIDM_GETNUMDEVS)) i = 1;
695 if (MMDRV_InitPerType(lpDrv, MMDRV_WAVEOUT, WODM_GETNUMDEVS)) i = 1;
696 /* if all those func calls return FALSE, then the driver must be unloaded */
697 if (!i) {
698 CloseDriver(lpDrv->hDriver, 0, 0);
699 HeapFree(GetProcessHeap(), 0, lpDrv->drvname);
700 WARN("Driver initialization failed\n");
701 return FALSE;
702 }
703
704 MMDrvsHi++;
705
706 return TRUE;
707 }
708
709 /**************************************************************************
710 * MMDRV_InitFromRegistry [internal]
711 */
712 static BOOL MMDRV_InitFromRegistry(void)
713 {
714 HKEY hKey;
715 char buffer[256];
716 char* p1;
717 char* p2;
718 DWORD type, size;
719 BOOL ret = FALSE;
720
721 if (RegCreateKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\WinMM", &hKey)) {
722 TRACE("Cannot open WinMM config key\n");
723 return FALSE;
724 }
725
726 size = sizeof(buffer);
727 if (!RegQueryValueExA(hKey, "Drivers", 0, &type, (LPVOID)buffer, &size)) {
728 p1 = buffer;
729 while (p1) {
730 p2 = strchr(p1, ';');
731 if (p2) *p2++ = '\0';
732 ret |= MMDRV_Install(p1, p1, FALSE);
733 p1 = p2;
734 }
735 }
736
737 /* finish with mappers */
738 size = sizeof(buffer);
739 if (!RegQueryValueExA(hKey, "WaveMapper", 0, &type, (LPVOID)buffer, &size))
740 ret |= MMDRV_Install("wavemapper", buffer, TRUE);
741 size = sizeof(buffer);
742 if (!RegQueryValueExA(hKey, "MidiMapper", 0, &type, (LPVOID)buffer, &size))
743 ret |= MMDRV_Install("midimapper", buffer, TRUE);
744
745 RegCloseKey(hKey);
746
747 return ret;
748 }
749
750 /**************************************************************************
751 * MMDRV_InitHardcoded [internal]
752 */
753 static BOOL MMDRV_InitHardcoded(void)
754 {
755 /* first load hardware drivers */
756 MMDRV_Install("wineoss.drv", "wineoss.drv", FALSE);
757
758 /* finish with mappers */
759 MMDRV_Install("wavemapper", "msacm.drv", TRUE);
760 MMDRV_Install("midimapper", "midimap.drv", TRUE);
761
762 return TRUE;
763 }
764
765 /**************************************************************************
766 * MMDRV_Init [internal]
767 */
768 BOOL MMDRV_Init(void)
769 {
770 /* FIXME: MMDRV_InitFromRegistry shall be MMDRV_Init in a near future */
771 return MMDRV_InitFromRegistry() || MMDRV_InitHardcoded();
772 }
773
774 /******************************************************************
775 * ExitPerType
776 *
777 *
778 */
779 static BOOL MMDRV_ExitPerType(LPWINE_MM_DRIVER lpDrv, UINT type)
780 {
781 WINE_MM_DRIVER_PART* part = &lpDrv->parts[type];
782 DWORD ret;
783
784 if (lpDrv->bIs32 && part->u.fnMessage32) {
785 #if 0
786 ret = part->u.fnMessage32(0, DRVM_DISABLE, 0L, 0L, 0L);
787 TRACE("DRVM_DISABLE => %08lx\n", ret);
788 #endif
789 ret = part->u.fnMessage32(0, DRVM_EXIT, 0L, 0L, 0L);
790 TRACE("DRVM_EXIT => %08lx\n", ret);
791 } else if (!lpDrv->bIs32 && part->u.fnMessage16 && pFnCallMMDrvFunc16) {
792 #if 0
793 ret = pFnCallMMDrvFunc16((FARPROC16)part->u.fnMessage16,
794 0, DRVM_DISABLE, 0L, 0L, 0L);
795 TRACE("DRVM_DISABLE => %08lx\n", ret);
796 #endif
797 ret = pFnCallMMDrvFunc16((FARPROC16)part->u.fnMessage16,
798 0, DRVM_EXIT, 0L, 0L, 0L);
799 TRACE("DRVM_EXIT => %08lx\n", ret);
800 } else {
801 return FALSE;
802 }
803
804 return TRUE;
805 }
806
807 /******************************************************************
808 * Exit
809 *
810 *
811 */
812 void MMDRV_Exit(void)
813 {
814 int i;
815
816 for (i = 0; i < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]); i++)
817 {
818 if (MM_MLDrvs[i] != NULL)
819 {
820 FIXME("Closing while ll-driver open\n");
821 #if 0
822 /* FIXME: should generate a message depending on type */
823 MMDRV_Free((HANDLE)(i | 0x8000), MM_MLDrvs[i]);
824 #endif
825 }
826 }
827
828 /* unload driver, in reverse order of loading */
829 for (i = sizeof(MMDrvs) / sizeof(MMDrvs[0]) - 1; i >= 0; i--)
830 {
831 MMDRV_ExitPerType(&MMDrvs[i], MMDRV_AUX);
832 MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIXER);
833 MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIDIIN);
834 MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIDIOUT);
835 MMDRV_ExitPerType(&MMDrvs[i], MMDRV_WAVEIN);
836 MMDRV_ExitPerType(&MMDrvs[i], MMDRV_WAVEOUT);
837 CloseDriver(MMDrvs[i].hDriver, 0, 0);
838 }
839 }
Work in progress by Kai Blin