winhttp: Use schannel for HTTPS connection by defaul and get rid of OpenSSL dependency.
[wine] / 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 }