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