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