1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
6 * Copyright 1998 Patrik Stridvall
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.
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.
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
38 #include "wine/debug.h"
39 #include "wine/unicode.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(msacm
);
43 /**********************************************************************/
45 HANDLE MSACM_hHeap
= NULL
;
46 PWINE_ACMDRIVERID MSACM_pFirstACMDriverID
= NULL
;
47 PWINE_ACMDRIVERID MSACM_pLastACMDriverID
= NULL
;
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
;
54 static void MSACM_ReorderDriversByPriority(void);
56 /***********************************************************************
57 * MSACM_RegisterDriverFromRegistry()
59 PWINE_ACMDRIVERID
MSACM_RegisterDriverFromRegistry(LPCWSTR pszRegEntry
)
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'};
70 PWINE_ACMDRIVERID padid
= NULL
;
72 /* The requested registry entry must have the format msacm.XXXXX in order to
73 be recognized in any future sessions of msacm
75 if (0 == strncmpiW(buf
, 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
);
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
);
85 MSACM_RegisterDriver(pszRegEntry
, buf
, 0);
94 /***********************************************************************
97 static void MSACM_DumpCache(PWINE_ACMDRIVERID padid
)
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
);
110 /***********************************************************************
111 * MSACM_FindFormatTagInCache [internal]
113 * Returns TRUE is the format tag fmtTag is present in the cache.
114 * If so, idx is set to its index.
116 BOOL
MSACM_FindFormatTagInCache(WINE_ACMDRIVERID
* padid
, DWORD fmtTag
, LPDWORD idx
)
120 for (i
= 0; i
< padid
->cFormatTags
; i
++) {
121 if (padid
->aFormatTag
[i
].dwFormatTag
== fmtTag
) {
129 /***********************************************************************
132 static BOOL
MSACM_FillCache(PWINE_ACMDRIVERID padid
)
136 ACMDRIVERDETAILSW add
;
137 ACMFORMATTAGDETAILSW aftd
;
139 if (acmDriverOpen(&had
, (HACMDRIVERID
)padid
, 0) != 0)
142 padid
->aFormatTag
= NULL
;
143 add
.cbStruct
= sizeof(add
);
144 if (MSACM_Message(had
, ACMDM_DRIVER_DETAILS
, (LPARAM
)&add
, 0))
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
;
153 padid
->cFormatTags
= add
.cFormatTags
;
154 padid
->cFilterTags
= add
.cFilterTags
;
155 padid
->fdwSupport
= add
.fdwSupport
;
157 aftd
.cbStruct
= sizeof(aftd
);
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
));
165 padid
->aFormatTag
[ntag
].dwFormatTag
= aftd
.dwFormatTag
;
166 padid
->aFormatTag
[ntag
].cbwfx
= aftd
.cbFormatSize
;
169 acmDriverClose(had
, 0);
174 if (had
) acmDriverClose(had
, 0);
175 HeapFree(MSACM_hHeap
, 0, padid
->aFormatTag
);
176 padid
->aFormatTag
= NULL
;
180 /***********************************************************************
181 * MSACM_GetRegistryKey
183 static LPWSTR
MSACM_GetRegistryKey(const WINE_ACMDRIVERID
* padid
)
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'};
191 if (!padid
->pszDriverAlias
) {
192 ERR("No alias needed for registry entry\n");
195 len
= strlenW(baseKey
);
196 ret
= HeapAlloc(MSACM_hHeap
, 0, (len
+ strlenW(padid
->pszDriverAlias
) + 1) * sizeof(WCHAR
));
197 if (!ret
) return NULL
;
199 strcpyW(ret
, baseKey
);
200 strcpyW(ret
+ len
, padid
->pszDriverAlias
);
201 CharLowerW(ret
+ len
);
205 /***********************************************************************
208 static BOOL
MSACM_ReadCache(PWINE_ACMDRIVERID padid
)
210 LPWSTR key
= MSACM_GetRegistryKey(padid
);
214 if (!key
) return FALSE
;
216 padid
->aFormatTag
= NULL
;
218 if (RegCreateKeyW(HKEY_LOCAL_MACHINE
, key
, &hKey
))
221 size
= sizeof(padid
->cFormatTags
);
222 if (RegQueryValueExA(hKey
, "cFormatTags", 0, &type
, (void*)&padid
->cFormatTags
, &size
))
224 size
= sizeof(padid
->cFilterTags
);
225 if (RegQueryValueExA(hKey
, "cFilterTags", 0, &type
, (void*)&padid
->cFilterTags
, &size
))
227 size
= sizeof(padid
->fdwSupport
);
228 if (RegQueryValueExA(hKey
, "fdwSupport", 0, &type
, (void*)&padid
->fdwSupport
, &size
))
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
))
238 HeapFree(MSACM_hHeap
, 0, key
);
242 HeapFree(MSACM_hHeap
, 0, key
);
243 HeapFree(MSACM_hHeap
, 0, padid
->aFormatTag
);
244 padid
->aFormatTag
= NULL
;
249 /***********************************************************************
252 static BOOL
MSACM_WriteCache(PWINE_ACMDRIVERID padid
)
254 LPWSTR key
= MSACM_GetRegistryKey(padid
);
257 if (!key
) return FALSE
;
259 if (RegCreateKeyW(HKEY_LOCAL_MACHINE
, key
, &hKey
))
262 if (RegSetValueExA(hKey
, "cFormatTags", 0, REG_DWORD
, (void*)&padid
->cFormatTags
, sizeof(DWORD
)))
264 if (RegSetValueExA(hKey
, "cFilterTags", 0, REG_DWORD
, (void*)&padid
->cFilterTags
, sizeof(DWORD
)))
266 if (RegSetValueExA(hKey
, "fdwSupport", 0, REG_DWORD
, (void*)&padid
->fdwSupport
, sizeof(DWORD
)))
268 if (RegSetValueExA(hKey
, "aFormatTagCache", 0, REG_BINARY
,
269 (void*)padid
->aFormatTag
,
270 padid
->cFormatTags
* sizeof(padid
->aFormatTag
[0])))
272 HeapFree(MSACM_hHeap
, 0, key
);
276 HeapFree(MSACM_hHeap
, 0, key
);
280 /***********************************************************************
281 * MSACM_RegisterDriver()
283 PWINE_ACMDRIVERID
MSACM_RegisterDriver(LPCWSTR pszDriverAlias
, LPCWSTR pszFileName
,
284 PWINE_ACMLOCALDRIVER pLocalDriver
)
286 PWINE_ACMDRIVERID padid
;
288 TRACE("(%s, %s, %p)\n",
289 debugstr_w(pszDriverAlias
), debugstr_w(pszFileName
), pLocalDriver
);
291 padid
= HeapAlloc(MSACM_hHeap
, 0, sizeof(WINE_ACMDRIVERID
));
292 padid
->obj
.dwType
= WINE_ACMOBJ_DRIVERID
;
293 padid
->obj
.pACMDriverID
= padid
;
294 padid
->pszDriverAlias
= NULL
;
297 padid
->pszDriverAlias
= HeapAlloc( MSACM_hHeap
, 0, (strlenW(pszDriverAlias
)+1) * sizeof(WCHAR
) );
298 strcpyW( padid
->pszDriverAlias
, pszDriverAlias
);
300 padid
->pszFileName
= NULL
;
303 padid
->pszFileName
= HeapAlloc( MSACM_hHeap
, 0, (strlenW(pszFileName
)+1) * sizeof(WCHAR
) );
304 strcpyW( padid
->pszFileName
, pszFileName
);
306 padid
->pLocalDriver
= pLocalDriver
;
308 padid
->pACMDriverList
= NULL
;
311 padid
->pPrevACMDriverID
= NULL
;
312 padid
->pNextACMDriverID
= MSACM_pFirstACMDriverID
;
313 if (MSACM_pFirstACMDriverID
)
314 MSACM_pFirstACMDriverID
->pPrevACMDriverID
= padid
;
315 MSACM_pFirstACMDriverID
= padid
;
316 if (!MSACM_pLastACMDriverID
)
317 MSACM_pLastACMDriverID
= padid
;
319 padid
->pNextACMDriverID
= NULL
;
320 padid
->pPrevACMDriverID
= MSACM_pLastACMDriverID
;
321 if (MSACM_pLastACMDriverID
)
322 MSACM_pLastACMDriverID
->pNextACMDriverID
= padid
;
323 MSACM_pLastACMDriverID
= padid
;
324 if (!MSACM_pFirstACMDriverID
)
325 MSACM_pFirstACMDriverID
= padid
;
327 /* disable the driver if we cannot load the cache */
328 if ((!padid
->pszDriverAlias
|| !MSACM_ReadCache(padid
)) && !MSACM_FillCache(padid
)) {
329 WARN("Couldn't load cache for ACM driver (%s)\n", debugstr_w(pszFileName
));
330 MSACM_UnregisterDriver(padid
);
334 if (pLocalDriver
) padid
->fdwSupport
|= ACMDRIVERDETAILS_SUPPORTF_LOCAL
;
338 /***********************************************************************
339 * MSACM_RegisterAllDrivers()
341 void MSACM_RegisterAllDrivers(void)
343 static const WCHAR msacm32
[] = {'m','s','a','c','m','3','2','.','d','l','l','\0'};
344 static const WCHAR msacmW
[] = {'M','S','A','C','M','.'};
345 static const WCHAR drv32
[] = {'d','r','i','v','e','r','s','3','2','\0'};
346 static const WCHAR sys
[] = {'s','y','s','t','e','m','.','i','n','i','\0'};
347 static const WCHAR drvkey
[] = {'S','o','f','t','w','a','r','e','\\',
348 'M','i','c','r','o','s','o','f','t','\\',
349 'W','i','n','d','o','w','s',' ','N','T','\\',
350 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
351 'D','r','i','v','e','r','s','3','2','\0'};
352 DWORD i
, cnt
= 0, bufLen
, lRet
;
353 WCHAR buf
[2048], *name
, *s
;
357 /* FIXME: What if the user edits system.ini while the program is running?
358 * Does Windows handle that? */
359 if (MSACM_pFirstACMDriverID
) return;
361 lRet
= RegOpenKeyExW(HKEY_LOCAL_MACHINE
, drvkey
, 0, KEY_QUERY_VALUE
, &hKey
);
362 if (lRet
== ERROR_SUCCESS
) {
363 RegQueryInfoKeyW( hKey
, 0, 0, 0, &cnt
, 0, 0, 0, 0, 0, 0, 0);
364 for (i
= 0; i
< cnt
; i
++) {
365 bufLen
= sizeof(buf
) / sizeof(buf
[0]);
366 lRet
= RegEnumKeyExW(hKey
, i
, buf
, &bufLen
, 0, 0, 0, &lastWrite
);
367 if (lRet
!= ERROR_SUCCESS
) continue;
368 if (strncmpiW(buf
, msacmW
, sizeof(msacmW
)/sizeof(msacmW
[0]))) continue;
369 if (!(name
= strchrW(buf
, '='))) continue;
371 MSACM_RegisterDriver(buf
, name
+ 1, 0);
376 if (GetPrivateProfileSectionW(drv32
, buf
, sizeof(buf
)/sizeof(buf
[0]), sys
))
378 for(s
= buf
; *s
; s
+= strlenW(s
) + 1)
380 if (strncmpiW(s
, msacmW
, sizeof(msacmW
)/sizeof(msacmW
[0]))) continue;
381 if (!(name
= strchrW(s
, '='))) continue;
383 MSACM_RegisterDriver(s
, name
+ 1, 0);
387 MSACM_ReorderDriversByPriority();
388 MSACM_RegisterDriver(msacm32
, msacm32
, 0);
391 /***********************************************************************
392 * MSACM_RegisterNotificationWindow()
394 PWINE_ACMNOTIFYWND
MSACM_RegisterNotificationWindow(HWND hNotifyWnd
, DWORD dwNotifyMsg
)
396 PWINE_ACMNOTIFYWND panwnd
;
398 TRACE("(%p,0x%08x)\n", hNotifyWnd
, dwNotifyMsg
);
400 panwnd
= HeapAlloc(MSACM_hHeap
, 0, sizeof(WINE_ACMNOTIFYWND
));
401 panwnd
->obj
.dwType
= WINE_ACMOBJ_NOTIFYWND
;
402 panwnd
->obj
.pACMDriverID
= 0;
403 panwnd
->hNotifyWnd
= hNotifyWnd
;
404 panwnd
->dwNotifyMsg
= dwNotifyMsg
;
405 panwnd
->fdwSupport
= 0;
407 panwnd
->pNextACMNotifyWnd
= NULL
;
408 panwnd
->pPrevACMNotifyWnd
= MSACM_pLastACMNotifyWnd
;
409 if (MSACM_pLastACMNotifyWnd
)
410 MSACM_pLastACMNotifyWnd
->pNextACMNotifyWnd
= panwnd
;
411 MSACM_pLastACMNotifyWnd
= panwnd
;
412 if (!MSACM_pFirstACMNotifyWnd
)
413 MSACM_pFirstACMNotifyWnd
= panwnd
;
418 /***********************************************************************
419 * MSACM_BroadcastNotification()
421 void MSACM_BroadcastNotification(void)
423 if (MSACM_suspendBroadcastCount
<= 0) {
424 PWINE_ACMNOTIFYWND panwnd
;
426 for (panwnd
= MSACM_pFirstACMNotifyWnd
; panwnd
; panwnd
= panwnd
->pNextACMNotifyWnd
)
427 if (!(panwnd
->fdwSupport
& ACMDRIVERDETAILS_SUPPORTF_DISABLED
))
428 SendMessageW(panwnd
->hNotifyWnd
, panwnd
->dwNotifyMsg
, 0, 0);
430 MSACM_pendingBroadcast
= TRUE
;
434 /***********************************************************************
435 * MSACM_DisableNotifications()
437 void MSACM_DisableNotifications(void)
439 MSACM_suspendBroadcastCount
++;
442 /***********************************************************************
443 * MSACM_EnableNotifications()
445 void MSACM_EnableNotifications(void)
447 if (MSACM_suspendBroadcastCount
> 0) {
448 MSACM_suspendBroadcastCount
--;
449 if (MSACM_suspendBroadcastCount
== 0 && MSACM_pendingBroadcast
) {
450 MSACM_pendingBroadcast
= FALSE
;
451 MSACM_BroadcastNotification();
456 /***********************************************************************
457 * MSACM_UnRegisterNotificationWindow()
459 PWINE_ACMNOTIFYWND
MSACM_UnRegisterNotificationWindow(PWINE_ACMNOTIFYWND panwnd
)
461 PWINE_ACMNOTIFYWND p
;
463 for (p
= MSACM_pFirstACMNotifyWnd
; p
; p
= p
->pNextACMNotifyWnd
) {
465 PWINE_ACMNOTIFYWND pNext
= p
->pNextACMNotifyWnd
;
467 if (p
->pPrevACMNotifyWnd
) p
->pPrevACMNotifyWnd
->pNextACMNotifyWnd
= p
->pNextACMNotifyWnd
;
468 if (p
->pNextACMNotifyWnd
) p
->pNextACMNotifyWnd
->pPrevACMNotifyWnd
= p
->pPrevACMNotifyWnd
;
469 if (MSACM_pFirstACMNotifyWnd
== p
) MSACM_pFirstACMNotifyWnd
= p
->pNextACMNotifyWnd
;
470 if (MSACM_pLastACMNotifyWnd
== p
) MSACM_pLastACMNotifyWnd
= p
->pPrevACMNotifyWnd
;
471 HeapFree(MSACM_hHeap
, 0, p
);
479 /***********************************************************************
480 * MSACM_RePositionDriver()
482 void MSACM_RePositionDriver(PWINE_ACMDRIVERID padid
, DWORD dwPriority
)
484 PWINE_ACMDRIVERID pTargetPosition
= NULL
;
486 /* Remove selected driver from linked list */
487 if (MSACM_pFirstACMDriverID
== padid
) {
488 MSACM_pFirstACMDriverID
= padid
->pNextACMDriverID
;
490 if (MSACM_pLastACMDriverID
== padid
) {
491 MSACM_pLastACMDriverID
= padid
->pPrevACMDriverID
;
493 if (padid
->pPrevACMDriverID
!= NULL
) {
494 padid
->pPrevACMDriverID
->pNextACMDriverID
= padid
->pNextACMDriverID
;
496 if (padid
->pNextACMDriverID
!= NULL
) {
497 padid
->pNextACMDriverID
->pPrevACMDriverID
= padid
->pPrevACMDriverID
;
500 /* Look up position where selected driver should be */
501 if (dwPriority
== 1) {
502 pTargetPosition
= padid
->pPrevACMDriverID
;
503 while (pTargetPosition
->pPrevACMDriverID
!= NULL
&&
504 !(pTargetPosition
->pPrevACMDriverID
->fdwSupport
& ACMDRIVERDETAILS_SUPPORTF_LOCAL
)) {
505 pTargetPosition
= pTargetPosition
->pPrevACMDriverID
;
507 } else if (dwPriority
== -1) {
508 pTargetPosition
= padid
->pNextACMDriverID
;
509 while (pTargetPosition
->pNextACMDriverID
!= NULL
) {
510 pTargetPosition
= pTargetPosition
->pNextACMDriverID
;
514 /* Place selected driver in selected position */
515 padid
->pPrevACMDriverID
= pTargetPosition
->pPrevACMDriverID
;
516 padid
->pNextACMDriverID
= pTargetPosition
;
517 if (padid
->pPrevACMDriverID
!= NULL
) {
518 padid
->pPrevACMDriverID
->pNextACMDriverID
= padid
;
520 MSACM_pFirstACMDriverID
= padid
;
522 if (padid
->pNextACMDriverID
!= NULL
) {
523 padid
->pNextACMDriverID
->pPrevACMDriverID
= padid
;
525 MSACM_pLastACMDriverID
= padid
;
529 /***********************************************************************
530 * MSACM_ReorderDriversByPriority()
531 * Reorders all drivers based on the priority list indicated by the registry key:
532 * HKCU\\Software\\Microsoft\\Multimedia\\Audio Compression Manager\\Priority v4.00
534 static void MSACM_ReorderDriversByPriority(void)
536 PWINE_ACMDRIVERID padid
;
537 unsigned int iNumDrivers
;
538 PWINE_ACMDRIVERID
* driverList
= NULL
;
539 HKEY hPriorityKey
= NULL
;
543 /* Count drivers && alloc corresponding memory for list */
545 for (padid
= MSACM_pFirstACMDriverID
; padid
; padid
= padid
->pNextACMDriverID
) iNumDrivers
++;
549 static const WCHAR basePriorityKey
[] = {
550 'S','o','f','t','w','a','r','e','\\',
551 'M','i','c','r','o','s','o','f','t','\\',
552 'M','u','l','t','i','m','e','d','i','a','\\',
553 'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
554 'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
560 driverList
= HeapAlloc(MSACM_hHeap
, 0, iNumDrivers
* sizeof(PWINE_ACMDRIVERID
));
563 ERR("out of memory\n");
567 lError
= RegOpenKeyW(HKEY_CURRENT_USER
, basePriorityKey
, &hPriorityKey
);
568 if (lError
!= ERROR_SUCCESS
) {
569 TRACE("RegOpenKeyW failed, possibly key does not exist yet\n");
574 /* Copy drivers into list to simplify linked list modification */
575 for (i
= 0, padid
= MSACM_pFirstACMDriverID
; padid
; padid
= padid
->pNextACMDriverID
, i
++)
577 driverList
[i
] = padid
;
580 /* Query each of the priorities in turn. Alias key is in lowercase.
581 The general form of the priority record is the following:
582 "PriorityN" --> "1, msacm.driveralias"
583 where N is an integer, and the value is a string of the driver
584 alias, prefixed by "1, " for an enabled driver, or "0, " for a
587 for (i
= 0; i
< iNumDrivers
; i
++)
589 static const WCHAR priorityTmpl
[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
591 unsigned int iTargetPosition
;
592 unsigned int iCurrentPosition
;
594 static const WCHAR sPrefix
[] = {'m','s','a','c','m','.','\0'};
596 /* Build expected entry name */
597 snprintfW(szSubKey
, 17, priorityTmpl
, i
+ 1);
598 lBufferLength
= sizeof(szBuffer
);
599 lError
= RegQueryValueExW(hPriorityKey
, szSubKey
, NULL
, NULL
, (LPBYTE
)szBuffer
, (LPDWORD
)&lBufferLength
);
600 if (lError
!= ERROR_SUCCESS
) continue;
602 /* Recovered driver alias should be at this position */
605 /* Locate driver alias in driver list */
606 pAlias
= strstrW(szBuffer
, sPrefix
);
607 if (pAlias
== NULL
) continue;
609 for (iCurrentPosition
= 0; iCurrentPosition
< iNumDrivers
; iCurrentPosition
++) {
610 if (strcmpiW(driverList
[iCurrentPosition
]->pszDriverAlias
, pAlias
) == 0)
613 if (iCurrentPosition
< iNumDrivers
&& iTargetPosition
!= iCurrentPosition
) {
614 padid
= driverList
[iTargetPosition
];
615 driverList
[iTargetPosition
] = driverList
[iCurrentPosition
];
616 driverList
[iCurrentPosition
] = padid
;
618 /* Locate enabled status */
619 if (szBuffer
[0] == '1') {
620 driverList
[iTargetPosition
]->fdwSupport
&= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED
;
621 } else if (szBuffer
[0] == '0') {
622 driverList
[iTargetPosition
]->fdwSupport
|= ACMDRIVERDETAILS_SUPPORTF_DISABLED
;
627 /* Re-assign pointers so that linked list traverses the ordered array */
628 for (i
= 0; i
< iNumDrivers
; i
++) {
629 driverList
[i
]->pPrevACMDriverID
= (i
> 0) ? driverList
[i
- 1] : NULL
;
630 driverList
[i
]->pNextACMDriverID
= (i
< iNumDrivers
- 1) ? driverList
[i
+ 1] : NULL
;
632 MSACM_pFirstACMDriverID
= driverList
[0];
633 MSACM_pLastACMDriverID
= driverList
[iNumDrivers
- 1];
637 if (hPriorityKey
!= NULL
) RegCloseKey(hPriorityKey
);
638 HeapFree(MSACM_hHeap
, 0, driverList
);
641 /***********************************************************************
642 * MSACM_WriteCurrentPriorities()
643 * Writes out current order of driver priorities to registry key:
644 * HKCU\\Software\\Microsoft\\Multimedia\\Audio Compression Manager\\Priority v4.00
646 void MSACM_WriteCurrentPriorities(void)
650 static const WCHAR basePriorityKey
[] = {
651 'S','o','f','t','w','a','r','e','\\',
652 'M','i','c','r','o','s','o','f','t','\\',
653 'M','u','l','t','i','m','e','d','i','a','\\',
654 'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
655 'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
657 PWINE_ACMDRIVERID padid
;
658 DWORD dwPriorityCounter
;
659 static const WCHAR priorityTmpl
[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
660 static const WCHAR valueTmpl
[] = {'%','c',',',' ','%','s','\0'};
661 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'};
665 /* Delete ACM priority key and create it anew */
666 lError
= RegDeleteKeyW(HKEY_CURRENT_USER
, basePriorityKey
);
667 if (lError
!= ERROR_SUCCESS
&& lError
!= ERROR_FILE_NOT_FOUND
) {
668 ERR("unable to remove current key %s (0x%08x) - priority changes won't persist past application end.\n",
669 debugstr_w(basePriorityKey
), lError
);
672 lError
= RegCreateKeyW(HKEY_CURRENT_USER
, basePriorityKey
, &hPriorityKey
);
673 if (lError
!= ERROR_SUCCESS
) {
674 ERR("unable to create key %s (0x%08x) - priority changes won't persist past application end.\n",
675 debugstr_w(basePriorityKey
), lError
);
679 /* Write current list of priorities */
680 for (dwPriorityCounter
= 0, padid
= MSACM_pFirstACMDriverID
; padid
; padid
= padid
->pNextACMDriverID
) {
681 if (padid
->fdwSupport
& ACMDRIVERDETAILS_SUPPORTF_LOCAL
) continue;
682 if (padid
->pszDriverAlias
== NULL
) continue; /* internal PCM converter is last */
684 /* Build required value name */
686 snprintfW(szSubKey
, 17, priorityTmpl
, dwPriorityCounter
);
688 /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
689 snprintfW(szBuffer
, 256, valueTmpl
, (padid
->fdwSupport
& ACMDRIVERDETAILS_SUPPORTF_DISABLED
) ? '0' : '1', padid
->pszDriverAlias
);
692 lError
= RegSetValueExW(hPriorityKey
, szSubKey
, 0, REG_SZ
, (BYTE
*)szBuffer
, (strlenW(szBuffer
) + 1) * sizeof(WCHAR
));
693 if (lError
!= ERROR_SUCCESS
) {
694 ERR("unable to write value for %s under key %s (0x%08x)\n",
695 debugstr_w(padid
->pszDriverAlias
), debugstr_w(basePriorityKey
), lError
);
699 /* Build required value name */
701 snprintfW(szSubKey
, 17, priorityTmpl
, dwPriorityCounter
);
703 /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
704 snprintfW(szBuffer
, 256, valueTmpl
, '1', converterAlias
);
706 lError
= RegSetValueExW(hPriorityKey
, szSubKey
, 0, REG_SZ
, (BYTE
*)szBuffer
, (strlenW(szBuffer
) + 1) * sizeof(WCHAR
));
707 if (lError
!= ERROR_SUCCESS
) {
708 ERR("unable to write value for %s under key %s (0x%08x)\n",
709 debugstr_w(converterAlias
), debugstr_w(basePriorityKey
), lError
);
711 RegCloseKey(hPriorityKey
);
714 /***********************************************************************
715 * MSACM_UnregisterDriver()
717 PWINE_ACMDRIVERID
MSACM_UnregisterDriver(PWINE_ACMDRIVERID p
)
719 PWINE_ACMDRIVERID pNextACMDriverID
;
721 while (p
->pACMDriverList
)
722 acmDriverClose((HACMDRIVER
) p
->pACMDriverList
, 0);
724 HeapFree(MSACM_hHeap
, 0, p
->pszDriverAlias
);
725 HeapFree(MSACM_hHeap
, 0, p
->pszFileName
);
726 HeapFree(MSACM_hHeap
, 0, p
->aFormatTag
);
728 if (p
== MSACM_pFirstACMDriverID
)
729 MSACM_pFirstACMDriverID
= p
->pNextACMDriverID
;
730 if (p
== MSACM_pLastACMDriverID
)
731 MSACM_pLastACMDriverID
= p
->pPrevACMDriverID
;
733 if (p
->pPrevACMDriverID
)
734 p
->pPrevACMDriverID
->pNextACMDriverID
= p
->pNextACMDriverID
;
735 if (p
->pNextACMDriverID
)
736 p
->pNextACMDriverID
->pPrevACMDriverID
= p
->pPrevACMDriverID
;
738 pNextACMDriverID
= p
->pNextACMDriverID
;
740 if (p
->pLocalDriver
) MSACM_UnregisterLocalDriver(p
->pLocalDriver
);
741 HeapFree(MSACM_hHeap
, 0, p
);
743 return pNextACMDriverID
;
746 /***********************************************************************
747 * MSACM_UnregisterAllDrivers()
749 void MSACM_UnregisterAllDrivers(void)
751 PWINE_ACMNOTIFYWND panwnd
= MSACM_pFirstACMNotifyWnd
;
752 PWINE_ACMDRIVERID p
= MSACM_pFirstACMDriverID
;
756 p
= MSACM_UnregisterDriver(p
);
760 panwnd
= MSACM_UnRegisterNotificationWindow(panwnd
);
764 /***********************************************************************
767 PWINE_ACMOBJ
MSACM_GetObj(HACMOBJ hObj
, DWORD type
)
769 PWINE_ACMOBJ pao
= (PWINE_ACMOBJ
)hObj
;
771 if (pao
== NULL
|| IsBadReadPtr(pao
, sizeof(WINE_ACMOBJ
)) ||
772 ((type
!= WINE_ACMOBJ_DONTCARE
) && (type
!= pao
->dwType
)))
777 /***********************************************************************
778 * MSACM_GetDriverID()
780 PWINE_ACMDRIVERID
MSACM_GetDriverID(HACMDRIVERID hDriverID
)
782 return (PWINE_ACMDRIVERID
)MSACM_GetObj((HACMOBJ
)hDriverID
, WINE_ACMOBJ_DRIVERID
);
785 /***********************************************************************
788 PWINE_ACMDRIVER
MSACM_GetDriver(HACMDRIVER hDriver
)
790 return (PWINE_ACMDRIVER
)MSACM_GetObj((HACMOBJ
)hDriver
, WINE_ACMOBJ_DRIVER
);
793 /***********************************************************************
794 * MSACM_GetNotifyWnd()
796 PWINE_ACMNOTIFYWND
MSACM_GetNotifyWnd(HACMDRIVERID hDriver
)
798 return (PWINE_ACMNOTIFYWND
)MSACM_GetObj((HACMOBJ
)hDriver
, WINE_ACMOBJ_NOTIFYWND
);
801 /***********************************************************************
802 * MSACM_GetLocalDriver()
805 PWINE_ACMLOCALDRIVER MSACM_GetLocalDriver(HACMDRIVER hDriver)
807 return (PWINE_ACMLOCALDRIVER)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_LOCALDRIVER);
810 #define MSACM_DRIVER_SendMessage(PDRVRINST, msg, lParam1, lParam2) \
811 (PDRVRINST)->pLocalDriver->lpDrvProc((PDRVRINST)->dwDriverID, (HDRVR)(PDRVRINST), msg, lParam1, lParam2)
813 /***********************************************************************
816 MMRESULT
MSACM_Message(HACMDRIVER had
, UINT uMsg
, LPARAM lParam1
, LPARAM lParam2
)
818 PWINE_ACMDRIVER pad
= MSACM_GetDriver(had
);
820 if (!pad
) return MMSYSERR_INVALHANDLE
;
821 if (pad
->hDrvr
) return SendDriverMessage(pad
->hDrvr
, uMsg
, lParam1
, lParam2
);
822 if (pad
->pLocalDrvrInst
) return MSACM_DRIVER_SendMessage(pad
->pLocalDrvrInst
, uMsg
, lParam1
, lParam2
);
824 return MMSYSERR_INVALHANDLE
;
827 PWINE_ACMLOCALDRIVER MSACM_pFirstACMLocalDriver
= NULL
;
828 PWINE_ACMLOCALDRIVER MSACM_pLastACMLocalDriver
= NULL
;
830 PWINE_ACMLOCALDRIVER
MSACM_RegisterLocalDriver(HMODULE hModule
, DRIVERPROC lpDriverProc
)
832 PWINE_ACMLOCALDRIVER paldrv
;
834 TRACE("(%p, %p)\n", hModule
, lpDriverProc
);
835 if (!hModule
|| !lpDriverProc
) return NULL
;
837 /* look up previous instance of local driver module */
838 for (paldrv
= MSACM_pFirstACMLocalDriver
; paldrv
; paldrv
= paldrv
->pNextACMLocalDrv
)
840 if (paldrv
->hModule
== hModule
&& paldrv
->lpDrvProc
== lpDriverProc
) return paldrv
;
843 paldrv
= HeapAlloc(MSACM_hHeap
, 0, sizeof(WINE_ACMLOCALDRIVER
));
844 paldrv
->obj
.dwType
= WINE_ACMOBJ_LOCALDRIVER
;
845 paldrv
->obj
.pACMDriverID
= 0;
846 paldrv
->hModule
= hModule
;
847 paldrv
->lpDrvProc
= lpDriverProc
;
848 paldrv
->pACMInstList
= NULL
;
850 paldrv
->pNextACMLocalDrv
= NULL
;
851 paldrv
->pPrevACMLocalDrv
= MSACM_pLastACMLocalDriver
;
852 if (MSACM_pLastACMLocalDriver
)
853 MSACM_pLastACMLocalDriver
->pNextACMLocalDrv
= paldrv
;
854 MSACM_pLastACMLocalDriver
= paldrv
;
855 if (!MSACM_pFirstACMLocalDriver
)
856 MSACM_pFirstACMLocalDriver
= paldrv
;
861 /**************************************************************************
862 * MSACM_GetNumberOfModuleRefs [internal]
864 * Returns the number of open drivers which share the same module.
865 * Inspired from implementation in dlls/winmm/driver.c
867 static unsigned MSACM_GetNumberOfModuleRefs(HMODULE hModule
, DRIVERPROC lpDrvProc
, WINE_ACMLOCALDRIVERINST
** found
)
869 PWINE_ACMLOCALDRIVER lpDrv
;
872 if (found
) *found
= NULL
;
873 for (lpDrv
= MSACM_pFirstACMLocalDriver
; lpDrv
; lpDrv
= lpDrv
->pNextACMLocalDrv
)
875 if (lpDrv
->hModule
== hModule
&& lpDrv
->lpDrvProc
== lpDrvProc
)
877 PWINE_ACMLOCALDRIVERINST pInst
= lpDrv
->pACMInstList
;
880 if (found
&& !*found
) *found
= pInst
;
882 pInst
= pInst
->pNextACMInst
;
889 /**************************************************************************
890 * MSACM_RemoveFromList [internal]
892 * Generates all the logic to handle driver closure / deletion
893 * Removes a driver struct to the list of open drivers.
895 static BOOL
MSACM_RemoveFromList(PWINE_ACMLOCALDRIVERINST lpDrv
)
897 PWINE_ACMLOCALDRIVER pDriverBase
= lpDrv
->pLocalDriver
;
898 PWINE_ACMLOCALDRIVERINST pPrevInst
;
900 /* last of this driver in list ? */
901 if (MSACM_GetNumberOfModuleRefs(pDriverBase
->hModule
, pDriverBase
->lpDrvProc
, NULL
) == 1) {
902 MSACM_DRIVER_SendMessage(lpDrv
, DRV_DISABLE
, 0L, 0L);
903 MSACM_DRIVER_SendMessage(lpDrv
, DRV_FREE
, 0L, 0L);
907 if (pDriverBase
->pACMInstList
!= lpDrv
) {
908 pPrevInst
= pDriverBase
->pACMInstList
;
909 while (pPrevInst
&& pPrevInst
->pNextACMInst
!= lpDrv
)
910 pPrevInst
= pPrevInst
->pNextACMInst
;
912 ERR("requested to remove invalid instance %p\n", pPrevInst
);
917 /* first driver instance on list */
918 pDriverBase
->pACMInstList
= lpDrv
->pNextACMInst
;
920 pPrevInst
->pNextACMInst
= lpDrv
->pNextACMInst
;
925 /**************************************************************************
926 * MSACM_AddToList [internal]
928 * Adds a driver struct to the list of open drivers.
929 * Generates all the logic to handle driver creation / open.
931 static BOOL
MSACM_AddToList(PWINE_ACMLOCALDRIVERINST lpNewDrv
, LPARAM lParam2
)
933 PWINE_ACMLOCALDRIVER pDriverBase
= lpNewDrv
->pLocalDriver
;
935 /* first of this driver in list ? */
936 if (MSACM_GetNumberOfModuleRefs(pDriverBase
->hModule
, pDriverBase
->lpDrvProc
, NULL
) == 0) {
937 if (MSACM_DRIVER_SendMessage(lpNewDrv
, DRV_LOAD
, 0L, 0L) != DRV_SUCCESS
) {
938 FIXME("DRV_LOAD failed on driver %p\n", lpNewDrv
);
941 /* returned value is not checked */
942 MSACM_DRIVER_SendMessage(lpNewDrv
, DRV_ENABLE
, 0L, 0L);
945 lpNewDrv
->pNextACMInst
= NULL
;
946 if (pDriverBase
->pACMInstList
== NULL
) {
947 pDriverBase
->pACMInstList
= lpNewDrv
;
949 PWINE_ACMLOCALDRIVERINST lpDrvInst
= pDriverBase
->pACMInstList
;
951 while (lpDrvInst
->pNextACMInst
!= NULL
)
952 lpDrvInst
= lpDrvInst
->pNextACMInst
;
954 lpDrvInst
->pNextACMInst
= lpNewDrv
;
957 /* Now just open a new instance of a driver on this module */
958 lpNewDrv
->dwDriverID
= MSACM_DRIVER_SendMessage(lpNewDrv
, DRV_OPEN
, 0, lParam2
);
960 if (lpNewDrv
->dwDriverID
== 0) {
961 FIXME("DRV_OPEN failed on driver %p\n", lpNewDrv
);
962 MSACM_RemoveFromList(lpNewDrv
);
968 PWINE_ACMLOCALDRIVERINST
MSACM_OpenLocalDriver(PWINE_ACMLOCALDRIVER paldrv
, LPARAM lParam2
)
970 PWINE_ACMLOCALDRIVERINST pDrvInst
;
972 pDrvInst
= HeapAlloc(MSACM_hHeap
, 0, sizeof(WINE_ACMLOCALDRIVERINST
));
973 pDrvInst
->pLocalDriver
= paldrv
;
974 pDrvInst
->dwDriverID
= 0;
975 pDrvInst
->pNextACMInst
= NULL
;
976 pDrvInst
->bSession
= FALSE
;
978 /* Win32 installable drivers must support a two phase opening scheme:
979 * + first open with NULL as lParam2 (session instance),
980 * + then do a second open with the real non null lParam2)
982 if (MSACM_GetNumberOfModuleRefs(paldrv
->hModule
, paldrv
->lpDrvProc
, NULL
) == 0 && lParam2
)
984 PWINE_ACMLOCALDRIVERINST ret
;
986 if (!MSACM_AddToList(pDrvInst
, 0L))
988 ERR("load0 failed\n");
991 ret
= MSACM_OpenLocalDriver(paldrv
, lParam2
);
994 MSACM_CloseLocalDriver(pDrvInst
);
995 ERR("load1 failed\n");
998 pDrvInst
->bSession
= TRUE
;
1002 if (!MSACM_AddToList(pDrvInst
, lParam2
))
1004 ERR("load failed\n");
1008 TRACE("=> %p\n", pDrvInst
);
1011 HeapFree(MSACM_hHeap
, 0, pDrvInst
);
1015 LRESULT
MSACM_CloseLocalDriver(PWINE_ACMLOCALDRIVERINST paldrv
)
1017 if (MSACM_RemoveFromList(paldrv
)) {
1018 PWINE_ACMLOCALDRIVERINST lpDrv0
;
1019 PWINE_ACMLOCALDRIVER pDriverBase
= paldrv
->pLocalDriver
;
1021 MSACM_DRIVER_SendMessage(paldrv
, DRV_CLOSE
, 0, 0);
1022 paldrv
->dwDriverID
= 0;
1024 if (paldrv
->bSession
)
1025 ERR("should not directly close session instance (%p)\n", paldrv
);
1027 /* if driver has an opened session instance, we have to close it too */
1028 if (MSACM_GetNumberOfModuleRefs(pDriverBase
->hModule
, pDriverBase
->lpDrvProc
, &lpDrv0
) == 1 &&
1031 MSACM_DRIVER_SendMessage(lpDrv0
, DRV_CLOSE
, 0L, 0L);
1032 lpDrv0
->dwDriverID
= 0;
1033 MSACM_RemoveFromList(lpDrv0
);
1034 HeapFree(GetProcessHeap(), 0, lpDrv0
);
1037 HeapFree(MSACM_hHeap
, 0, paldrv
);
1040 ERR("unable to close driver instance\n");
1044 PWINE_ACMLOCALDRIVER
MSACM_UnregisterLocalDriver(PWINE_ACMLOCALDRIVER paldrv
)
1046 PWINE_ACMLOCALDRIVER pNextACMLocalDriver
;
1048 if (paldrv
->pACMInstList
) {
1049 ERR("local driver instances still present after closing all drivers - memory leak\n");
1053 if (paldrv
== MSACM_pFirstACMLocalDriver
)
1054 MSACM_pFirstACMLocalDriver
= paldrv
->pNextACMLocalDrv
;
1055 if (paldrv
== MSACM_pLastACMLocalDriver
)
1056 MSACM_pLastACMLocalDriver
= paldrv
->pPrevACMLocalDrv
;
1058 if (paldrv
->pPrevACMLocalDrv
)
1059 paldrv
->pPrevACMLocalDrv
->pNextACMLocalDrv
= paldrv
->pNextACMLocalDrv
;
1060 if (paldrv
->pNextACMLocalDrv
)
1061 paldrv
->pNextACMLocalDrv
->pPrevACMLocalDrv
= paldrv
->pPrevACMLocalDrv
;
1063 pNextACMLocalDriver
= paldrv
->pNextACMLocalDrv
;
1065 HeapFree(MSACM_hHeap
, 0, paldrv
);
1067 return pNextACMLocalDriver
;