ole32: Make the virtual table functions static where possible.
[wine] / dlls / winmm / lolvldrv.c
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 }