?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32/tests: Use PROCESS_ALL_ACCESS definition compatible with versions of Windows...
[wine.git] / dlls / msacm32 / internal.c
blobb3f6bf3e8555bca5d5afbe0440f0690f00741668
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 }
Windows API implementation