git.oblomov.eu Git - wine/blob - dlls/msacm32/internal.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  *      MSACM32 library
   5  *
   6  *      Copyright 1998  Patrik Stridvall
   7  *                1999  Eric Pouech
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "winerror.h"
  32 #include "winreg.h"
  33 #include "mmsystem.h"
  34 #include "mmreg.h"
  35 #include "msacm.h"
  36 #include "msacmdrv.h"
  37 #include "wineacm.h"
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
  42
  43 /**********************************************************************/
  44
  45 HANDLE MSACM_hHeap = NULL;
  46 PWINE_ACMDRIVERID MSACM_pFirstACMDriverID = NULL;
  47 static PWINE_ACMDRIVERID MSACM_pLastACMDriverID;
  48
  49 static DWORD MSACM_suspendBroadcastCount = 0;
  50 static BOOL MSACM_pendingBroadcast = FALSE;
  51 static PWINE_ACMNOTIFYWND MSACM_pFirstACMNotifyWnd = NULL;
  52 static PWINE_ACMNOTIFYWND MSACM_pLastACMNotifyWnd = NULL;
  53
  54 static void MSACM_ReorderDriversByPriority(void);
  55
  56 /***********************************************************************
  57  *           MSACM_RegisterDriverFromRegistry()
  58  */
  59 PWINE_ACMDRIVERID MSACM_RegisterDriverFromRegistry(LPCWSTR pszRegEntry)
  60 {
  61     static const WCHAR msacmW[] = {'M','S','A','C','M','.'};
  62     static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\',
  63                                    'M','i','c','r','o','s','o','f','t','\\',
  64                                    'W','i','n','d','o','w','s',' ','N','T','\\',
  65                                    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  66                                    'D','r','i','v','e','r','s','3','2','\0'};
  67     WCHAR buf[2048];
  68     DWORD bufLen, lRet;
  69     HKEY hKey;
  70     PWINE_ACMDRIVERID padid = NULL;
  71
  72     /* The requested registry entry must have the format msacm.XXXXX in order to
  73        be recognized in any future sessions of msacm
  74      */
  75     if (0 == strncmpiW(pszRegEntry, msacmW, sizeof(msacmW)/sizeof(WCHAR))) {
  76         lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, drvkey, 0, KEY_QUERY_VALUE, &hKey);
  77         if (lRet != ERROR_SUCCESS) {
  78             WARN("unable to open registry key - 0x%08x\n", lRet);
  79         } else {
  80             bufLen = sizeof(buf);
  81             lRet = RegQueryValueExW(hKey, pszRegEntry, NULL, NULL, (LPBYTE)buf, &bufLen);
  82             if (lRet != ERROR_SUCCESS) {
  83                 WARN("unable to query requested subkey %s - 0x%08x\n", debugstr_w(pszRegEntry), lRet);
  84             } else {
  85                 MSACM_RegisterDriver(pszRegEntry, buf, 0);
  86             }
  87             RegCloseKey( hKey );
  88         }
  89     }
  90     return padid;
  91 }
  92
  93 #if 0
  94 /***********************************************************************
  95  *           MSACM_DumpCache
  96  */
  97 static  void MSACM_DumpCache(PWINE_ACMDRIVERID padid)
  98 {
  99     unsigned    i;
 100
 101     TRACE("cFilterTags=%lu cFormatTags=%lu fdwSupport=%08lx\n",
 102           padid->cFilterTags, padid->cFormatTags, padid->fdwSupport);
 103     for (i = 0; i < padid->cache->cFormatTags; i++) {
 104         TRACE("\tdwFormatTag=%lu cbwfx=%lu\n",
 105               padid->aFormatTag[i].dwFormatTag, padid->aFormatTag[i].cbwfx);
 106     }
 107 }
 108 #endif
 109
 110 /***********************************************************************
 111  *           MSACM_FindFormatTagInCache                 [internal]
 112  *
 113  *      Returns TRUE is the format tag fmtTag is present in the cache.
 114  *      If so, idx is set to its index.
 115  */
 116 BOOL MSACM_FindFormatTagInCache(const WINE_ACMDRIVERID* padid, DWORD fmtTag, LPDWORD idx)
 117 {
 118     unsigned    i;
 119
 120     for (i = 0; i < padid->cFormatTags; i++) {
 121         if (padid->aFormatTag[i].dwFormatTag == fmtTag) {
 122             if (idx) *idx = i;
 123             return TRUE;
 124         }
 125     }
 126     return FALSE;
 127 }
 128
 129 /***********************************************************************
 130  *           MSACM_FillCache
 131  */
 132 static BOOL MSACM_FillCache(PWINE_ACMDRIVERID padid)
 133 {
 134     HACMDRIVER                  had = 0;
 135     unsigned int                        ntag;
 136     ACMDRIVERDETAILSW           add;
 137     ACMFORMATTAGDETAILSW        aftd;
 138
 139     if (acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != 0)
 140         return FALSE;
 141
 142     padid->aFormatTag = NULL;
 143     add.cbStruct = sizeof(add);
 144     if (MSACM_Message(had, ACMDM_DRIVER_DETAILS, (LPARAM)&add,  0))
 145         goto errCleanUp;
 146
 147     if (add.cFormatTags > 0) {
 148         padid->aFormatTag = HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY,
 149                                       add.cFormatTags * sizeof(padid->aFormatTag[0]));
 150         if (!padid->aFormatTag) goto errCleanUp;
 151     }
 152
 153     padid->cFormatTags = add.cFormatTags;
 154     padid->cFilterTags = add.cFilterTags;
 155     padid->fdwSupport  = add.fdwSupport;
 156
 157     aftd.cbStruct = sizeof(aftd);
 158
 159     for (ntag = 0; ntag < add.cFormatTags; ntag++) {
 160         aftd.dwFormatTagIndex = ntag;
 161         if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)&aftd, ACM_FORMATTAGDETAILSF_INDEX)) {
 162             TRACE("IIOs (%s)\n", debugstr_w(padid->pszDriverAlias));
 163             goto errCleanUp;
 164         }
 165         padid->aFormatTag[ntag].dwFormatTag = aftd.dwFormatTag;
 166         padid->aFormatTag[ntag].cbwfx = aftd.cbFormatSize;
 167     }
 168
 169     acmDriverClose(had, 0);
 170
 171     return TRUE;
 172
 173 errCleanUp:
 174     if (had) acmDriverClose(had, 0);
 175     HeapFree(MSACM_hHeap, 0, padid->aFormatTag);
 176     padid->aFormatTag = NULL;
 177     return FALSE;
 178 }
 179
 180 /***********************************************************************
 181  *           MSACM_GetRegistryKey
 182  */
 183 static  LPWSTR  MSACM_GetRegistryKey(const WINE_ACMDRIVERID* padid)
 184 {
 185     static const WCHAR  baseKey[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
 186                                      'A','u','d','i','o','C','o','m','p','r','e','s','s','i','o','n','M','a','n','a','g','e','r','\\',
 187                                      'D','r','i','v','e','r','C','a','c','h','e','\\','\0'};
 188     LPWSTR      ret;
 189     int         len;
 190
 191     if (!padid->pszDriverAlias) {
 192         ERR("No alias needed for registry entry\n");
 193         return NULL;
 194     }
 195     len = strlenW(baseKey);
 196     ret = HeapAlloc(MSACM_hHeap, 0, (len + strlenW(padid->pszDriverAlias) + 1) * sizeof(WCHAR));
 197     if (!ret) return NULL;
 198
 199     strcpyW(ret, baseKey);
 200     strcpyW(ret + len, padid->pszDriverAlias);
 201     CharLowerW(ret + len);
 202     return ret;
 203 }
 204
 205 /***********************************************************************
 206  *           MSACM_ReadCache
 207  */
 208 static BOOL MSACM_ReadCache(PWINE_ACMDRIVERID padid)
 209 {
 210     LPWSTR      key = MSACM_GetRegistryKey(padid);
 211     HKEY        hKey;
 212     DWORD       type, size;
 213
 214     if (!key) return FALSE;
 215
 216     padid->aFormatTag = NULL;
 217
 218     if (RegCreateKeyW(HKEY_LOCAL_MACHINE, key, &hKey))
 219         goto errCleanUp;
 220
 221     size = sizeof(padid->cFormatTags);
 222     if (RegQueryValueExA(hKey, "cFormatTags", 0, &type, (void*)&padid->cFormatTags, &size))
 223         goto errCleanUp;
 224     size = sizeof(padid->cFilterTags);
 225     if (RegQueryValueExA(hKey, "cFilterTags", 0, &type, (void*)&padid->cFilterTags, &size))
 226         goto errCleanUp;
 227     size = sizeof(padid->fdwSupport);
 228     if (RegQueryValueExA(hKey, "fdwSupport", 0, &type, (void*)&padid->fdwSupport, &size))
 229         goto errCleanUp;
 230
 231     if (padid->cFormatTags > 0) {
 232         size = padid->cFormatTags * sizeof(padid->aFormatTag[0]);
 233         padid->aFormatTag = HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY, size);
 234         if (!padid->aFormatTag) goto errCleanUp;
 235         if (RegQueryValueExA(hKey, "aFormatTagCache", 0, &type, (void*)padid->aFormatTag, &size))
 236             goto errCleanUp;
 237     }
 238     HeapFree(MSACM_hHeap, 0, key);
 239     return TRUE;
 240
 241  errCleanUp:
 242     HeapFree(MSACM_hHeap, 0, key);
 243     HeapFree(MSACM_hHeap, 0, padid->aFormatTag);
 244     padid->aFormatTag = NULL;
 245     RegCloseKey(hKey);
 246     return FALSE;
 247 }
 248
 249 /***********************************************************************
 250  *           MSACM_WriteCache
 251  */
 252 static  BOOL MSACM_WriteCache(const WINE_ACMDRIVERID *padid)
 253 {
 254     LPWSTR      key = MSACM_GetRegistryKey(padid);
 255     HKEY        hKey;
 256
 257     if (!key) return FALSE;
 258
 259     if (RegCreateKeyW(HKEY_LOCAL_MACHINE, key, &hKey))
 260         goto errCleanUp;
 261
 262     if (RegSetValueExA(hKey, "cFormatTags", 0, REG_DWORD, (const void*)&padid->cFormatTags, sizeof(DWORD)))
 263         goto errCleanUp;
 264     if (RegSetValueExA(hKey, "cFilterTags", 0, REG_DWORD, (const void*)&padid->cFilterTags, sizeof(DWORD)))
 265         goto errCleanUp;
 266     if (RegSetValueExA(hKey, "fdwSupport", 0, REG_DWORD, (const void*)&padid->fdwSupport, sizeof(DWORD)))
 267         goto errCleanUp;
 268     if (RegSetValueExA(hKey, "aFormatTagCache", 0, REG_BINARY,
 269                        (void*)padid->aFormatTag,
 270                        padid->cFormatTags * sizeof(padid->aFormatTag[0])))
 271         goto errCleanUp;
 272     HeapFree(MSACM_hHeap, 0, key);
 273     return TRUE;
 274
 275  errCleanUp:
 276     HeapFree(MSACM_hHeap, 0, key);
 277     return FALSE;
 278 }
 279
 280 /***********************************************************************
 281  *           MSACM_RegisterDriver()
 282  */
 283 PWINE_ACMDRIVERID MSACM_RegisterDriver(LPCWSTR pszDriverAlias, LPCWSTR pszFileName,
 284                                        PWINE_ACMLOCALDRIVER pLocalDriver)
 285 {
 286     PWINE_ACMDRIVERID   padid;
 287
 288     TRACE("(%s, %s, %p)\n",
 289           debugstr_w(pszDriverAlias), debugstr_w(pszFileName), pLocalDriver);
 290
 291     padid = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID));
 292     if (!padid)
 293         return NULL;
 294     padid->obj.dwType = WINE_ACMOBJ_DRIVERID;
 295     padid->obj.pACMDriverID = padid;
 296     padid->pszDriverAlias = NULL;
 297     if (pszDriverAlias)
 298     {
 299         padid->pszDriverAlias = HeapAlloc( MSACM_hHeap, 0, (strlenW(pszDriverAlias)+1) * sizeof(WCHAR) );
 300         if (!padid->pszDriverAlias) {
 301             HeapFree(MSACM_hHeap, 0, padid);
 302             return NULL;
 303         }
 304         strcpyW( padid->pszDriverAlias, pszDriverAlias );
 305     }
 306     padid->pszFileName = NULL;
 307     if (pszFileName)
 308     {
 309         padid->pszFileName = HeapAlloc( MSACM_hHeap, 0, (strlenW(pszFileName)+1) * sizeof(WCHAR) );
 310         if (!padid->pszFileName) {
 311             HeapFree(MSACM_hHeap, 0, padid->pszDriverAlias);
 312             HeapFree(MSACM_hHeap, 0, padid);
 313             return NULL;
 314         }
 315         strcpyW( padid->pszFileName, pszFileName );
 316     }
 317     padid->pLocalDriver = pLocalDriver;
 318
 319     padid->pACMDriverList = NULL;
 320
 321     if (pLocalDriver) {
 322         padid->pPrevACMDriverID = NULL;
 323         padid->pNextACMDriverID = MSACM_pFirstACMDriverID;
 324         if (MSACM_pFirstACMDriverID)
 325             MSACM_pFirstACMDriverID->pPrevACMDriverID = padid;
 326         MSACM_pFirstACMDriverID = padid;
 327         if (!MSACM_pLastACMDriverID)
 328             MSACM_pLastACMDriverID = padid;
 329     } else {
 330         padid->pNextACMDriverID = NULL;
 331         padid->pPrevACMDriverID = MSACM_pLastACMDriverID;
 332         if (MSACM_pLastACMDriverID)
 333             MSACM_pLastACMDriverID->pNextACMDriverID = padid;
 334         MSACM_pLastACMDriverID = padid;
 335         if (!MSACM_pFirstACMDriverID)
 336             MSACM_pFirstACMDriverID = padid;
 337     }
 338     /* disable the driver if we cannot load the cache */
 339     if ((!padid->pszDriverAlias || !MSACM_ReadCache(padid)) && !MSACM_FillCache(padid)) {
 340         WARN("Couldn't load cache for ACM driver (%s)\n", debugstr_w(pszFileName));
 341         MSACM_UnregisterDriver(padid);
 342         return NULL;
 343     }
 344
 345     if (pLocalDriver) padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_LOCAL;
 346     return padid;
 347 }
 348
 349 /***********************************************************************
 350  *           MSACM_RegisterAllDrivers()
 351  */
 352 void MSACM_RegisterAllDrivers(void)
 353 {
 354     static const WCHAR msacm32[] = {'m','s','a','c','m','3','2','.','d','l','l','\0'};
 355     static const WCHAR msacmW[] = {'M','S','A','C','M','.'};
 356     static const WCHAR drv32[] = {'d','r','i','v','e','r','s','3','2','\0'};
 357     static const WCHAR sys[] = {'s','y','s','t','e','m','.','i','n','i','\0'};
 358     static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\',
 359                                    'M','i','c','r','o','s','o','f','t','\\',
 360                                    'W','i','n','d','o','w','s',' ','N','T','\\',
 361                                    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 362                                    'D','r','i','v','e','r','s','3','2','\0'};
 363     DWORD i, cnt, bufLen, lRet, type;
 364     WCHAR buf[2048], valname[64], *name, *s;
 365     FILETIME lastWrite;
 366     HKEY hKey;
 367
 368     /* FIXME: What if the user edits system.ini while the program is running?
 369      * Does Windows handle that?  */
 370     if (MSACM_pFirstACMDriverID) return;
 371
 372     lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, drvkey, 0, KEY_QUERY_VALUE, &hKey);
 373     if (lRet == ERROR_SUCCESS) {
 374         RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
 375         for (i = 0; i < cnt; i++) {
 376             bufLen = sizeof(buf) / sizeof(buf[0]);
 377             lRet = RegEnumKeyExW(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite);
 378             if (lRet != ERROR_SUCCESS) continue;
 379             if (strncmpiW(buf, msacmW, sizeof(msacmW)/sizeof(msacmW[0]))) continue;
 380             if (!(name = strchrW(buf, '='))) continue;
 381             *name = 0;
 382             MSACM_RegisterDriver(buf, name + 1, 0);
 383         }
 384         i = 0;
 385         cnt = sizeof(valname) / sizeof(*valname);
 386         bufLen = sizeof(buf);
 387         while(RegEnumValueW(hKey, i, valname, &cnt, 0,
 388                     &type, (BYTE*)buf, &bufLen) == ERROR_SUCCESS){
 389             if(!strncmpiW(valname, msacmW, sizeof(msacmW) / sizeof(*msacmW)))
 390                 MSACM_RegisterDriver(valname, buf, 0);
 391             ++i;
 392         }
 393         RegCloseKey( hKey );
 394     }
 395
 396     if (GetPrivateProfileSectionW(drv32, buf, sizeof(buf)/sizeof(buf[0]), sys))
 397     {
 398         for(s = buf; *s;  s += strlenW(s) + 1)
 399         {
 400             if (strncmpiW(s, msacmW, sizeof(msacmW)/sizeof(msacmW[0]))) continue;
 401             if (!(name = strchrW(s, '='))) continue;
 402             *name = 0;
 403             MSACM_RegisterDriver(s, name + 1, 0);
 404             *name = '=';
 405         }
 406     }
 407     MSACM_ReorderDriversByPriority();
 408     MSACM_RegisterDriver(msacm32, msacm32, 0);
 409 }
 410
 411 /***********************************************************************
 412  *           MSACM_RegisterNotificationWindow()
 413  */
 414 PWINE_ACMNOTIFYWND MSACM_RegisterNotificationWindow(HWND hNotifyWnd, DWORD dwNotifyMsg)
 415 {
 416     PWINE_ACMNOTIFYWND  panwnd;
 417
 418     TRACE("(%p,0x%08x)\n", hNotifyWnd, dwNotifyMsg);
 419
 420     panwnd = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMNOTIFYWND));
 421     panwnd->obj.dwType = WINE_ACMOBJ_NOTIFYWND;
 422     panwnd->obj.pACMDriverID = 0;
 423     panwnd->hNotifyWnd = hNotifyWnd;
 424     panwnd->dwNotifyMsg = dwNotifyMsg;
 425     panwnd->fdwSupport = 0;
 426
 427     panwnd->pNextACMNotifyWnd = NULL;
 428     panwnd->pPrevACMNotifyWnd = MSACM_pLastACMNotifyWnd;
 429     if (MSACM_pLastACMNotifyWnd)
 430         MSACM_pLastACMNotifyWnd->pNextACMNotifyWnd = panwnd;
 431     MSACM_pLastACMNotifyWnd = panwnd;
 432     if (!MSACM_pFirstACMNotifyWnd)
 433         MSACM_pFirstACMNotifyWnd = panwnd;
 434
 435     return panwnd;
 436 }
 437
 438 /***********************************************************************
 439  *           MSACM_BroadcastNotification()
 440  */
 441 void MSACM_BroadcastNotification(void)
 442 {
 443     if (MSACM_suspendBroadcastCount <= 0) {
 444         PWINE_ACMNOTIFYWND panwnd;
 445
 446         for (panwnd = MSACM_pFirstACMNotifyWnd; panwnd; panwnd = panwnd->pNextACMNotifyWnd)
 447         if (!(panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED))
 448             SendMessageW(panwnd->hNotifyWnd, panwnd->dwNotifyMsg, 0, 0);
 449     } else {
 450         MSACM_pendingBroadcast = TRUE;
 451     }
 452 }
 453
 454 /***********************************************************************
 455  *           MSACM_DisableNotifications()
 456  */
 457 void MSACM_DisableNotifications(void)
 458 {
 459     MSACM_suspendBroadcastCount++;
 460 }
 461
 462 /***********************************************************************
 463  *           MSACM_EnableNotifications()
 464  */
 465 void MSACM_EnableNotifications(void)
 466 {
 467     if (MSACM_suspendBroadcastCount > 0) {
 468         MSACM_suspendBroadcastCount--;
 469         if (MSACM_suspendBroadcastCount == 0 && MSACM_pendingBroadcast) {
 470             MSACM_pendingBroadcast = FALSE;
 471             MSACM_BroadcastNotification();
 472         }
 473     }
 474 }
 475
 476 /***********************************************************************
 477  *           MSACM_UnRegisterNotificationWindow()
 478  */
 479 PWINE_ACMNOTIFYWND MSACM_UnRegisterNotificationWindow(const WINE_ACMNOTIFYWND *panwnd)
 480 {
 481     PWINE_ACMNOTIFYWND p;
 482
 483     for (p = MSACM_pFirstACMNotifyWnd; p; p = p->pNextACMNotifyWnd) {
 484         if (p == panwnd) {
 485             PWINE_ACMNOTIFYWND pNext = p->pNextACMNotifyWnd;
 486
 487             if (p->pPrevACMNotifyWnd) p->pPrevACMNotifyWnd->pNextACMNotifyWnd = p->pNextACMNotifyWnd;
 488             if (p->pNextACMNotifyWnd) p->pNextACMNotifyWnd->pPrevACMNotifyWnd = p->pPrevACMNotifyWnd;
 489             if (MSACM_pFirstACMNotifyWnd == p) MSACM_pFirstACMNotifyWnd = p->pNextACMNotifyWnd;
 490             if (MSACM_pLastACMNotifyWnd == p) MSACM_pLastACMNotifyWnd = p->pPrevACMNotifyWnd;
 491             HeapFree(MSACM_hHeap, 0, p);
 492
 493             return pNext;
 494         }
 495     }
 496     return NULL;
 497 }
 498
 499 /***********************************************************************
 500  *           MSACM_RePositionDriver()
 501  */
 502 void MSACM_RePositionDriver(PWINE_ACMDRIVERID padid, DWORD dwPriority)
 503 {
 504     PWINE_ACMDRIVERID pTargetPosition = NULL;
 505
 506     /* Remove selected driver from linked list */
 507     if (MSACM_pFirstACMDriverID == padid) {
 508         MSACM_pFirstACMDriverID = padid->pNextACMDriverID;
 509     }
 510     if (MSACM_pLastACMDriverID == padid) {
 511         MSACM_pLastACMDriverID = padid->pPrevACMDriverID;
 512     }
 513     if (padid->pPrevACMDriverID != NULL) {
 514         padid->pPrevACMDriverID->pNextACMDriverID = padid->pNextACMDriverID;
 515     }
 516     if (padid->pNextACMDriverID != NULL) {
 517         padid->pNextACMDriverID->pPrevACMDriverID = padid->pPrevACMDriverID;
 518     }
 519
 520     /* Look up position where selected driver should be */
 521     if (dwPriority == 1) {
 522         pTargetPosition = padid->pPrevACMDriverID;
 523         while (pTargetPosition->pPrevACMDriverID != NULL &&
 524             !(pTargetPosition->pPrevACMDriverID->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL)) {
 525             pTargetPosition = pTargetPosition->pPrevACMDriverID;
 526         }
 527     } else if (dwPriority == -1) {
 528         pTargetPosition = padid->pNextACMDriverID;
 529         while (pTargetPosition->pNextACMDriverID != NULL) {
 530             pTargetPosition = pTargetPosition->pNextACMDriverID;
 531         }
 532     }
 533
 534     /* Place selected driver in selected position */
 535     padid->pPrevACMDriverID = pTargetPosition->pPrevACMDriverID;
 536     padid->pNextACMDriverID = pTargetPosition;
 537     if (padid->pPrevACMDriverID != NULL) {
 538         padid->pPrevACMDriverID->pNextACMDriverID = padid;
 539     } else {
 540         MSACM_pFirstACMDriverID = padid;
 541     }
 542     if (padid->pNextACMDriverID != NULL) {
 543         padid->pNextACMDriverID->pPrevACMDriverID = padid;
 544     } else {
 545         MSACM_pLastACMDriverID = padid;
 546     }
 547 }
 548
 549 /***********************************************************************
 550  *           MSACM_ReorderDriversByPriority()
 551  * Reorders all drivers based on the priority list indicated by the registry key:
 552  * HKCU\\Software\\Microsoft\\Multimedia\\Audio Compression Manager\\Priority v4.00
 553  */
 554 static void MSACM_ReorderDriversByPriority(void)
 555 {
 556     PWINE_ACMDRIVERID   padid;
 557     unsigned int iNumDrivers;
 558     PWINE_ACMDRIVERID * driverList = NULL;
 559     HKEY hPriorityKey = NULL;
 560
 561     TRACE("\n");
 562
 563     /* Count drivers && alloc corresponding memory for list */
 564     iNumDrivers = 0;
 565     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) iNumDrivers++;
 566     if (iNumDrivers > 1)
 567     {
 568         LONG lError;
 569         static const WCHAR basePriorityKey[] = {
 570             'S','o','f','t','w','a','r','e','\\',
 571             'M','i','c','r','o','s','o','f','t','\\',
 572             'M','u','l','t','i','m','e','d','i','a','\\',
 573             'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
 574             'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
 575         };
 576         unsigned int i;
 577         LONG lBufferLength;
 578         WCHAR szBuffer[256];
 579
 580         driverList = HeapAlloc(MSACM_hHeap, 0, iNumDrivers * sizeof(PWINE_ACMDRIVERID));
 581         if (!driverList)
 582         {
 583             ERR("out of memory\n");
 584             goto errCleanUp;
 585         }
 586
 587         lError = RegOpenKeyW(HKEY_CURRENT_USER, basePriorityKey, &hPriorityKey);
 588         if (lError != ERROR_SUCCESS) {
 589             TRACE("RegOpenKeyW failed, possibly key does not exist yet\n");
 590             hPriorityKey = NULL;
 591             goto errCleanUp;
 592         }
 593
 594         /* Copy drivers into list to simplify linked list modification */
 595         for (i = 0, padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID, i++)
 596         {
 597             driverList[i] = padid;
 598         }
 599
 600         /* Query each of the priorities in turn. Alias key is in lowercase.
 601             The general form of the priority record is the following:
 602             "PriorityN" --> "1, msacm.driveralias"
 603             where N is an integer, and the value is a string of the driver
 604             alias, prefixed by "1, " for an enabled driver, or "0, " for a
 605             disabled driver.
 606             */
 607         for (i = 0; i < iNumDrivers; i++)
 608         {
 609             static const WCHAR priorityTmpl[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
 610             WCHAR szSubKey[17];
 611             unsigned int iTargetPosition;
 612             unsigned int iCurrentPosition;
 613             WCHAR * pAlias;
 614             static const WCHAR sPrefix[] = {'m','s','a','c','m','.','\0'};
 615
 616             /* Build expected entry name */
 617             snprintfW(szSubKey, 17, priorityTmpl, i + 1);
 618             lBufferLength = sizeof(szBuffer);
 619             lError = RegQueryValueExW(hPriorityKey, szSubKey, NULL, NULL, (LPBYTE)szBuffer, (LPDWORD)&lBufferLength);
 620             if (lError != ERROR_SUCCESS) continue;
 621
 622             /* Recovered driver alias should be at this position */
 623             iTargetPosition = i;
 624
 625             /* Locate driver alias in driver list */
 626             pAlias = strstrW(szBuffer, sPrefix);
 627             if (pAlias == NULL) continue;
 628
 629             for (iCurrentPosition = 0; iCurrentPosition < iNumDrivers; iCurrentPosition++) {
 630                 if (strcmpiW(driverList[iCurrentPosition]->pszDriverAlias, pAlias) == 0)
 631                     break;
 632             }
 633             if (iCurrentPosition < iNumDrivers && iTargetPosition != iCurrentPosition) {
 634                 padid = driverList[iTargetPosition];
 635                 driverList[iTargetPosition] = driverList[iCurrentPosition];
 636                 driverList[iCurrentPosition] = padid;
 637
 638                 /* Locate enabled status */
 639                 if (szBuffer[0] == '1') {
 640                     driverList[iTargetPosition]->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 641                 } else if (szBuffer[0] == '0') {
 642                     driverList[iTargetPosition]->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
 643                 }
 644             }
 645         }
 646
 647         /* Re-assign pointers so that linked list traverses the ordered array */
 648         for (i = 0; i < iNumDrivers; i++) {
 649             driverList[i]->pPrevACMDriverID = (i > 0) ? driverList[i - 1] : NULL;
 650             driverList[i]->pNextACMDriverID = (i < iNumDrivers - 1) ? driverList[i + 1] : NULL;
 651         }
 652         MSACM_pFirstACMDriverID = driverList[0];
 653         MSACM_pLastACMDriverID = driverList[iNumDrivers - 1];
 654     }
 655
 656 errCleanUp:
 657     if (hPriorityKey != NULL) RegCloseKey(hPriorityKey);
 658     HeapFree(MSACM_hHeap, 0, driverList);
 659 }
 660
 661 /***********************************************************************
 662  *           MSACM_WriteCurrentPriorities()
 663  * Writes out current order of driver priorities to registry key:
 664  * HKCU\\Software\\Microsoft\\Multimedia\\Audio Compression Manager\\Priority v4.00
 665  */
 666 void MSACM_WriteCurrentPriorities(void)
 667 {
 668     LONG lError;
 669     HKEY hPriorityKey;
 670     static const WCHAR basePriorityKey[] = {
 671         'S','o','f','t','w','a','r','e','\\',
 672         'M','i','c','r','o','s','o','f','t','\\',
 673         'M','u','l','t','i','m','e','d','i','a','\\',
 674         'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
 675         'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
 676     };
 677     PWINE_ACMDRIVERID padid;
 678     DWORD dwPriorityCounter;
 679     static const WCHAR priorityTmpl[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
 680     static const WCHAR valueTmpl[] = {'%','c',',',' ','%','s','\0'};
 681     static const WCHAR converterAlias[] = {'I','n','t','e','r','n','a','l',' ','P','C','M',' ','C','o','n','v','e','r','t','e','r','\0'};
 682     WCHAR szSubKey[17];
 683     WCHAR szBuffer[256];
 684
 685     /* Delete ACM priority key and create it anew */
 686     lError = RegDeleteKeyW(HKEY_CURRENT_USER, basePriorityKey);
 687     if (lError != ERROR_SUCCESS && lError != ERROR_FILE_NOT_FOUND) {
 688         ERR("unable to remove current key %s (0x%08x) - priority changes won't persist past application end.\n",
 689             debugstr_w(basePriorityKey), lError);
 690         return;
 691     }
 692     lError = RegCreateKeyW(HKEY_CURRENT_USER, basePriorityKey, &hPriorityKey);
 693     if (lError != ERROR_SUCCESS) {
 694         ERR("unable to create key %s (0x%08x) - priority changes won't persist past application end.\n",
 695             debugstr_w(basePriorityKey), lError);
 696         return;
 697     }
 698
 699     /* Write current list of priorities */
 700     for (dwPriorityCounter = 0, padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 701         if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) continue;
 702         if (padid->pszDriverAlias == NULL) continue;    /* internal PCM converter is last */
 703
 704         /* Build required value name */
 705         dwPriorityCounter++;
 706         snprintfW(szSubKey, 17, priorityTmpl, dwPriorityCounter);
 707
 708         /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
 709         snprintfW(szBuffer, 256, valueTmpl, (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ? '0' : '1', padid->pszDriverAlias);
 710         strlwrW(szBuffer);
 711
 712         lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (strlenW(szBuffer) + 1) * sizeof(WCHAR));
 713         if (lError != ERROR_SUCCESS) {
 714             ERR("unable to write value for %s under key %s (0x%08x)\n",
 715                 debugstr_w(padid->pszDriverAlias), debugstr_w(basePriorityKey), lError);
 716         }
 717     }
 718
 719     /* Build required value name */
 720     dwPriorityCounter++;
 721     snprintfW(szSubKey, 17, priorityTmpl, dwPriorityCounter);
 722
 723     /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
 724     snprintfW(szBuffer, 256, valueTmpl, '1', converterAlias);
 725
 726     lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (strlenW(szBuffer) + 1) * sizeof(WCHAR));
 727     if (lError != ERROR_SUCCESS) {
 728         ERR("unable to write value for %s under key %s (0x%08x)\n",
 729             debugstr_w(converterAlias), debugstr_w(basePriorityKey), lError);
 730     }
 731     RegCloseKey(hPriorityKey);
 732 }
 733
 734 static PWINE_ACMLOCALDRIVER MSACM_pFirstACMLocalDriver;
 735 static PWINE_ACMLOCALDRIVER MSACM_pLastACMLocalDriver;
 736
 737 static PWINE_ACMLOCALDRIVER MSACM_UnregisterLocalDriver(PWINE_ACMLOCALDRIVER paldrv)
 738 {
 739     PWINE_ACMLOCALDRIVER pNextACMLocalDriver;
 740
 741     if (paldrv->pACMInstList) {
 742         ERR("local driver instances still present after closing all drivers - memory leak\n");
 743         return NULL;
 744     }
 745
 746     if (paldrv == MSACM_pFirstACMLocalDriver)
 747         MSACM_pFirstACMLocalDriver = paldrv->pNextACMLocalDrv;
 748     if (paldrv == MSACM_pLastACMLocalDriver)
 749         MSACM_pLastACMLocalDriver = paldrv->pPrevACMLocalDrv;
 750
 751     if (paldrv->pPrevACMLocalDrv)
 752         paldrv->pPrevACMLocalDrv->pNextACMLocalDrv = paldrv->pNextACMLocalDrv;
 753     if (paldrv->pNextACMLocalDrv)
 754         paldrv->pNextACMLocalDrv->pPrevACMLocalDrv = paldrv->pPrevACMLocalDrv;
 755
 756     pNextACMLocalDriver = paldrv->pNextACMLocalDrv;
 757
 758     HeapFree(MSACM_hHeap, 0, paldrv);
 759
 760     return pNextACMLocalDriver;
 761 }
 762
 763 /***********************************************************************
 764  *           MSACM_UnregisterDriver()
 765  */
 766 PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p)
 767 {
 768     PWINE_ACMDRIVERID pNextACMDriverID;
 769
 770     while (p->pACMDriverList)
 771         acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
 772
 773     HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
 774     HeapFree(MSACM_hHeap, 0, p->pszFileName);
 775     HeapFree(MSACM_hHeap, 0, p->aFormatTag);
 776
 777     if (p == MSACM_pFirstACMDriverID)
 778         MSACM_pFirstACMDriverID = p->pNextACMDriverID;
 779     if (p == MSACM_pLastACMDriverID)
 780         MSACM_pLastACMDriverID = p->pPrevACMDriverID;
 781
 782     if (p->pPrevACMDriverID)
 783         p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
 784     if (p->pNextACMDriverID)
 785         p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
 786
 787     pNextACMDriverID = p->pNextACMDriverID;
 788
 789     if (p->pLocalDriver) MSACM_UnregisterLocalDriver(p->pLocalDriver);
 790     HeapFree(MSACM_hHeap, 0, p);
 791
 792     return pNextACMDriverID;
 793 }
 794
 795 /***********************************************************************
 796  *           MSACM_UnregisterAllDrivers()
 797  */
 798 void MSACM_UnregisterAllDrivers(void)
 799 {
 800     PWINE_ACMNOTIFYWND panwnd = MSACM_pFirstACMNotifyWnd;
 801     PWINE_ACMDRIVERID p = MSACM_pFirstACMDriverID;
 802
 803     while (p) {
 804         MSACM_WriteCache(p);
 805         p = MSACM_UnregisterDriver(p);
 806     }
 807
 808     while (panwnd) {
 809         panwnd = MSACM_UnRegisterNotificationWindow(panwnd);
 810     }
 811 }
 812
 813 /***********************************************************************
 814  *           MSACM_GetObj()
 815  */
 816 PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj, DWORD type)
 817 {
 818     PWINE_ACMOBJ        pao = (PWINE_ACMOBJ)hObj;
 819
 820     if (pao == NULL || IsBadReadPtr(pao, sizeof(WINE_ACMOBJ)) ||
 821         ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
 822         return NULL;
 823     return pao;
 824 }
 825
 826 /***********************************************************************
 827  *           MSACM_GetDriverID()
 828  */
 829 PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
 830 {
 831     return (PWINE_ACMDRIVERID)MSACM_GetObj((HACMOBJ)hDriverID, WINE_ACMOBJ_DRIVERID);
 832 }
 833
 834 /***********************************************************************
 835  *           MSACM_GetDriver()
 836  */
 837 PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
 838 {
 839     return (PWINE_ACMDRIVER)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_DRIVER);
 840 }
 841
 842 /***********************************************************************
 843  *           MSACM_GetNotifyWnd()
 844  */
 845 PWINE_ACMNOTIFYWND MSACM_GetNotifyWnd(HACMDRIVERID hDriver)
 846 {
 847     return (PWINE_ACMNOTIFYWND)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_NOTIFYWND);
 848 }
 849
 850 /***********************************************************************
 851  *           MSACM_GetLocalDriver()
 852  */
 853 /*
 854 PWINE_ACMLOCALDRIVER MSACM_GetLocalDriver(HACMDRIVER hDriver)
 855 {
 856     return (PWINE_ACMLOCALDRIVER)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_LOCALDRIVER);
 857 }
 858 */
 859 #define MSACM_DRIVER_SendMessage(PDRVRINST, msg, lParam1, lParam2) \
 860         (PDRVRINST)->pLocalDriver->lpDrvProc((PDRVRINST)->dwDriverID, (HDRVR)(PDRVRINST), msg, lParam1, lParam2)
 861
 862 /***********************************************************************
 863  *           MSACM_Message()
 864  */
 865 MMRESULT MSACM_Message(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 866 {
 867     PWINE_ACMDRIVER     pad = MSACM_GetDriver(had);
 868
 869     if (!pad) return MMSYSERR_INVALHANDLE;
 870     if (pad->hDrvr) return SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2);
 871     if (pad->pLocalDrvrInst) return MSACM_DRIVER_SendMessage(pad->pLocalDrvrInst, uMsg, lParam1, lParam2);
 872
 873     return MMSYSERR_INVALHANDLE;
 874 }
 875
 876 PWINE_ACMLOCALDRIVER MSACM_RegisterLocalDriver(HMODULE hModule, DRIVERPROC lpDriverProc)
 877 {
 878     PWINE_ACMLOCALDRIVER paldrv;
 879
 880     TRACE("(%p, %p)\n", hModule, lpDriverProc);
 881     if (!hModule || !lpDriverProc) return NULL;
 882
 883     /* look up previous instance of local driver module */
 884     for (paldrv = MSACM_pFirstACMLocalDriver; paldrv; paldrv = paldrv->pNextACMLocalDrv)
 885     {
 886         if (paldrv->hModule == hModule && paldrv->lpDrvProc == lpDriverProc) return paldrv;
 887     }
 888
 889     paldrv = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
 890     paldrv->obj.dwType = WINE_ACMOBJ_LOCALDRIVER;
 891     paldrv->obj.pACMDriverID = 0;
 892     paldrv->hModule = hModule;
 893     paldrv->lpDrvProc = lpDriverProc;
 894     paldrv->pACMInstList = NULL;
 895
 896     paldrv->pNextACMLocalDrv = NULL;
 897     paldrv->pPrevACMLocalDrv = MSACM_pLastACMLocalDriver;
 898     if (MSACM_pLastACMLocalDriver)
 899         MSACM_pLastACMLocalDriver->pNextACMLocalDrv = paldrv;
 900     MSACM_pLastACMLocalDriver = paldrv;
 901     if (!MSACM_pFirstACMLocalDriver)
 902         MSACM_pFirstACMLocalDriver = paldrv;
 903
 904     return paldrv;
 905 }
 906
 907 /**************************************************************************
 908  *                      MSACM_GetNumberOfModuleRefs             [internal]
 909  *
 910  * Returns the number of open drivers which share the same module.
 911  * Inspired from implementation in dlls/winmm/driver.c
 912  */
 913 static unsigned MSACM_GetNumberOfModuleRefs(HMODULE hModule, DRIVERPROC lpDrvProc, WINE_ACMLOCALDRIVERINST ** found)
 914 {
 915     PWINE_ACMLOCALDRIVER lpDrv;
 916     unsigned            count = 0;
 917
 918     if (found) *found = NULL;
 919     for (lpDrv = MSACM_pFirstACMLocalDriver; lpDrv; lpDrv = lpDrv->pNextACMLocalDrv)
 920     {
 921         if (lpDrv->hModule == hModule && lpDrv->lpDrvProc == lpDrvProc)
 922         {
 923             PWINE_ACMLOCALDRIVERINST pInst = lpDrv->pACMInstList;
 924
 925             while (pInst) {
 926                 if (found && !*found) *found = pInst;
 927                 count++;
 928                 pInst = pInst->pNextACMInst;
 929             }
 930         }
 931     }
 932     return count;
 933 }
 934
 935 /**************************************************************************
 936  *                              MSACM_RemoveFromList            [internal]
 937  *
 938  * Generates all the logic to handle driver closure / deletion
 939  * Removes a driver struct to the list of open drivers.
 940  */
 941 static  BOOL    MSACM_RemoveFromList(PWINE_ACMLOCALDRIVERINST lpDrv)
 942 {
 943     PWINE_ACMLOCALDRIVER pDriverBase = lpDrv->pLocalDriver;
 944     PWINE_ACMLOCALDRIVERINST pPrevInst;
 945
 946     /* last of this driver in list ? */
 947     if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, NULL) == 1) {
 948         MSACM_DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
 949         MSACM_DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
 950     }
 951
 952     pPrevInst = NULL;
 953     if (pDriverBase->pACMInstList != lpDrv) {
 954         pPrevInst = pDriverBase->pACMInstList;
 955         while (pPrevInst && pPrevInst->pNextACMInst != lpDrv)
 956             pPrevInst = pPrevInst->pNextACMInst;
 957         if (!pPrevInst) {
 958             ERR("requested to remove invalid instance %p\n", pPrevInst);
 959             return FALSE;
 960         }
 961     }
 962     if (!pPrevInst) {
 963         /* first driver instance on list */
 964         pDriverBase->pACMInstList = lpDrv->pNextACMInst;
 965     } else {
 966         pPrevInst->pNextACMInst = lpDrv->pNextACMInst;
 967     }
 968     return TRUE;
 969 }
 970
 971 /**************************************************************************
 972  *                              MSACM_AddToList         [internal]
 973  *
 974  * Adds a driver struct to the list of open drivers.
 975  * Generates all the logic to handle driver creation / open.
 976  */
 977 static  BOOL    MSACM_AddToList(PWINE_ACMLOCALDRIVERINST lpNewDrv, LPARAM lParam2)
 978 {
 979     PWINE_ACMLOCALDRIVER pDriverBase = lpNewDrv->pLocalDriver;
 980
 981     /* first of this driver in list ? */
 982     if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, NULL) == 0) {
 983         if (MSACM_DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
 984             FIXME("DRV_LOAD failed on driver %p\n", lpNewDrv);
 985             return FALSE;
 986         }
 987         /* returned value is not checked */
 988         MSACM_DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
 989     }
 990
 991     lpNewDrv->pNextACMInst = NULL;
 992     if (pDriverBase->pACMInstList == NULL) {
 993         pDriverBase->pACMInstList = lpNewDrv;
 994     } else {
 995         PWINE_ACMLOCALDRIVERINST lpDrvInst = pDriverBase->pACMInstList;
 996
 997         while (lpDrvInst->pNextACMInst != NULL)
 998             lpDrvInst = lpDrvInst->pNextACMInst;
 999
1000         lpDrvInst->pNextACMInst = lpNewDrv;
1001     }
1002
1003     /* Now just open a new instance of a driver on this module */
1004     lpNewDrv->dwDriverID = MSACM_DRIVER_SendMessage(lpNewDrv, DRV_OPEN, 0, lParam2);
1005
1006     if (lpNewDrv->dwDriverID == 0) {
1007         FIXME("DRV_OPEN failed on driver %p\n", lpNewDrv);
1008         MSACM_RemoveFromList(lpNewDrv);
1009         return FALSE;
1010     }
1011     return TRUE;
1012 }
1013
1014 PWINE_ACMLOCALDRIVERINST MSACM_OpenLocalDriver(PWINE_ACMLOCALDRIVER paldrv, LPARAM lParam2)
1015 {
1016     PWINE_ACMLOCALDRIVERINST pDrvInst;
1017
1018     pDrvInst = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVERINST));
1019     if (!pDrvInst)
1020         return NULL;
1021
1022     pDrvInst->pLocalDriver = paldrv;
1023     pDrvInst->dwDriverID = 0;
1024     pDrvInst->pNextACMInst = NULL;
1025     pDrvInst->bSession = FALSE;
1026
1027     /* Win32 installable drivers must support a two phase opening scheme:
1028      * + first open with NULL as lParam2 (session instance),
1029      * + then do a second open with the real non null lParam2)
1030      */
1031     if (MSACM_GetNumberOfModuleRefs(paldrv->hModule, paldrv->lpDrvProc, NULL) == 0 && lParam2)
1032     {
1033         PWINE_ACMLOCALDRIVERINST   ret;
1034
1035         if (!MSACM_AddToList(pDrvInst, 0L))
1036         {
1037             ERR("load0 failed\n");
1038             goto exit;
1039         }
1040         ret = MSACM_OpenLocalDriver(paldrv, lParam2);
1041         if (!ret)
1042         {
1043             ERR("load1 failed\n");
1044             /* If MSACM_CloseLocalDriver returns TRUE,
1045              * then pDrvInst has been freed
1046              */
1047             if (!MSACM_CloseLocalDriver(pDrvInst))
1048                 goto exit;
1049
1050             return NULL;
1051         }
1052         pDrvInst->bSession = TRUE;
1053         return ret;
1054     }
1055
1056     if (!MSACM_AddToList(pDrvInst, lParam2))
1057     {
1058         ERR("load failed\n");
1059         goto exit;
1060     }
1061
1062     TRACE("=> %p\n", pDrvInst);
1063     return pDrvInst;
1064 exit:
1065     HeapFree(MSACM_hHeap, 0, pDrvInst);
1066     return NULL;
1067 }
1068
1069 LRESULT MSACM_CloseLocalDriver(PWINE_ACMLOCALDRIVERINST paldrv)
1070 {
1071     if (MSACM_RemoveFromList(paldrv)) {
1072         PWINE_ACMLOCALDRIVERINST lpDrv0;
1073         PWINE_ACMLOCALDRIVER pDriverBase = paldrv->pLocalDriver;
1074
1075         MSACM_DRIVER_SendMessage(paldrv, DRV_CLOSE, 0, 0);
1076         paldrv->dwDriverID = 0;
1077
1078         if (paldrv->bSession)
1079             ERR("should not directly close session instance (%p)\n", paldrv);
1080
1081         /* if driver has an opened session instance, we have to close it too */
1082         if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, &lpDrv0) == 1 &&
1083                 lpDrv0->bSession)
1084         {
1085             MSACM_DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L);
1086             lpDrv0->dwDriverID = 0;
1087             MSACM_RemoveFromList(lpDrv0);
1088             HeapFree(GetProcessHeap(), 0, lpDrv0);
1089         }
1090
1091         HeapFree(MSACM_hHeap, 0, paldrv);
1092         return TRUE;
1093     }
1094     ERR("unable to close driver instance\n");
1095     return FALSE;
1096 }