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