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