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