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