internal.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "winreg.h"
#include "mmsystem.h"
#include "mmreg.h"
#include "msacm.h"
#include "msacmdrv.h"
#include "wineacm.h"
#include "wine/debug.h"

Include dependency graph for internal.c:

Go to the source code of this file.

Macros
#define	MSACM_DRIVER_SendMessage(PDRVRINST, msg, lParam1, lParam2)    (PDRVRINST)->pLocalDriver->lpDrvProc((PDRVRINST)->dwDriverID, (HDRVR)(PDRVRINST), msg, lParam1, lParam2)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msacm)
static void	MSACM_ReorderDriversByPriority (void)
PWINE_ACMDRIVERID	MSACM_RegisterDriverFromRegistry (LPCWSTR pszRegEntry)
BOOL	MSACM_FindFormatTagInCache (const WINE_ACMDRIVERID *padid, DWORD fmtTag, LPDWORD idx)
static BOOL	MSACM_FillCache (PWINE_ACMDRIVERID padid)
static LPWSTR	MSACM_GetRegistryKey (const WINE_ACMDRIVERID *padid)
static BOOL	MSACM_ReadCache (PWINE_ACMDRIVERID padid)
static BOOL	MSACM_WriteCache (const WINE_ACMDRIVERID *padid)
PWINE_ACMDRIVERID	MSACM_RegisterDriver (LPCWSTR pszDriverAlias, LPCWSTR pszFileName, PWINE_ACMLOCALDRIVER pLocalDriver)
void	MSACM_RegisterAllDrivers (void)
PWINE_ACMNOTIFYWND	MSACM_RegisterNotificationWindow (HWND hNotifyWnd, DWORD dwNotifyMsg)
void	MSACM_BroadcastNotification (void)
void	MSACM_DisableNotifications (void)
void	MSACM_EnableNotifications (void)
PWINE_ACMNOTIFYWND	MSACM_UnRegisterNotificationWindow (const WINE_ACMNOTIFYWND *panwnd)
void	MSACM_RePositionDriver (PWINE_ACMDRIVERID padid, DWORD dwPriority)
void	MSACM_WriteCurrentPriorities (void)
static PWINE_ACMLOCALDRIVER	MSACM_UnregisterLocalDriver (PWINE_ACMLOCALDRIVER paldrv)
PWINE_ACMDRIVERID	MSACM_UnregisterDriver (PWINE_ACMDRIVERID p)
void	MSACM_UnregisterAllDrivers (void)
PWINE_ACMOBJ	MSACM_GetObj (HACMOBJ hObj, DWORD type)
PWINE_ACMDRIVERID	MSACM_GetDriverID (HACMDRIVERID hDriverID)
PWINE_ACMDRIVER	MSACM_GetDriver (HACMDRIVER hDriver)
PWINE_ACMNOTIFYWND	MSACM_GetNotifyWnd (HACMDRIVERID hDriver)
MMRESULT	MSACM_Message (HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
PWINE_ACMLOCALDRIVER	MSACM_RegisterLocalDriver (HMODULE hModule, DRIVERPROC lpDriverProc)
static unsigned	MSACM_GetNumberOfModuleRefs (HMODULE hModule, DRIVERPROC lpDrvProc, WINE_ACMLOCALDRIVERINST **found)
static BOOL	MSACM_RemoveFromList (PWINE_ACMLOCALDRIVERINST lpDrv)
static BOOL	MSACM_AddToList (PWINE_ACMLOCALDRIVERINST lpNewDrv, LPARAM lParam2)
PWINE_ACMLOCALDRIVERINST	MSACM_OpenLocalDriver (PWINE_ACMLOCALDRIVER paldrv, LPARAM lParam2)
LRESULT	MSACM_CloseLocalDriver (PWINE_ACMLOCALDRIVERINST paldrv)

Variables
HANDLE	MSACM_hHeap = NULL
PWINE_ACMDRIVERID	MSACM_pFirstACMDriverID = NULL
static PWINE_ACMDRIVERID	MSACM_pLastACMDriverID
static DWORD	MSACM_suspendBroadcastCount = 0
static BOOL	MSACM_pendingBroadcast = FALSE
static PWINE_ACMNOTIFYWND	MSACM_pFirstACMNotifyWnd = NULL
static PWINE_ACMNOTIFYWND	MSACM_pLastACMNotifyWnd = NULL
static PWINE_ACMLOCALDRIVER	MSACM_pFirstACMLocalDriver
static PWINE_ACMLOCALDRIVER	MSACM_pLastACMLocalDriver

Macro Definition Documentation

MSACM_DRIVER_SendMessage

#define MSACM_DRIVER_SendMessage	(		PDRVRINST,
			msg,
			lParam1,
			lParam2
	)		(PDRVRINST)->pLocalDriver->lpDrvProc((PDRVRINST)->dwDriverID, (HDRVR)(PDRVRINST), msg, lParam1, lParam2)

Definition at line 866 of file internal.c.

Function Documentation

MSACM_AddToList()

static BOOL MSACM_AddToList ( PWINE_ACMLOCALDRIVERINST  lpNewDrv, LPARAM  lParam2  )

static

Definition at line 989 of file internal.c.

{
    PWINE_ACMLOCALDRIVER pDriverBase = lpNewDrv->pLocalDriver;
 
    /* first of this driver in list ? */
    if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, NULL) == 0) {
        if (MSACM_DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
            FIXME("DRV_LOAD failed on driver %p\n", lpNewDrv);
            return FALSE;
        }
        /* returned value is not checked */
        MSACM_DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
    }
 
    lpNewDrv->pNextACMInst = NULL;
    if (pDriverBase->pACMInstList == NULL) {
    pDriverBase->pACMInstList = lpNewDrv;
    } else {
        PWINE_ACMLOCALDRIVERINST lpDrvInst = pDriverBase->pACMInstList;
    
        while (lpDrvInst->pNextACMInst != NULL)
            lpDrvInst = lpDrvInst->pNextACMInst;
 
    lpDrvInst->pNextACMInst = lpNewDrv;
    }
 
    /* Now just open a new instance of a driver on this module */
    lpNewDrv->dwDriverID = MSACM_DRIVER_SendMessage(lpNewDrv, DRV_OPEN, 0, lParam2);
 
    if (lpNewDrv->dwDriverID == 0) {
        FIXME("DRV_OPEN failed on driver %p\n", lpNewDrv);
        MSACM_RemoveFromList(lpNewDrv);
        return FALSE;
    }
    return TRUE;
}

Referenced by MSACM_OpenLocalDriver().

MSACM_BroadcastNotification()

void MSACM_BroadcastNotification

(

void

)

Definition at line 443 of file internal.c.

{
    if (MSACM_suspendBroadcastCount <= 0) {
        PWINE_ACMNOTIFYWND panwnd;
 
        for (panwnd = MSACM_pFirstACMNotifyWnd; panwnd; panwnd = panwnd->pNextACMNotifyWnd) 
        if (!(panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED))
            SendMessageW(panwnd->hNotifyWnd, panwnd->dwNotifyMsg, 0, 0);
    } else {
        MSACM_pendingBroadcast = TRUE;
    }
}

Referenced by acmDriverAddW(), acmDriverPriority(), acmDriverRemove(), and MSACM_EnableNotifications().

MSACM_CloseLocalDriver()

LRESULT MSACM_CloseLocalDriver

(

PWINE_ACMLOCALDRIVERINST

paldrv

)

Definition at line 1081 of file internal.c.

{
    if (MSACM_RemoveFromList(paldrv)) {
        PWINE_ACMLOCALDRIVERINST lpDrv0;
        PWINE_ACMLOCALDRIVER pDriverBase = paldrv->pLocalDriver;
    
        MSACM_DRIVER_SendMessage(paldrv, DRV_CLOSE, 0, 0);
        paldrv->dwDriverID = 0;
    
        if (paldrv->bSession)
            ERR("should not directly close session instance (%p)\n", paldrv);
 
        /* if driver has an opened session instance, we have to close it too */
        if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, &lpDrv0) == 1 &&
                lpDrv0->bSession)
        {
            MSACM_DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L);
            lpDrv0->dwDriverID = 0;
            MSACM_RemoveFromList(lpDrv0);
            HeapFree(MSACM_hHeap, 0, lpDrv0);
        }
 
        HeapFree(MSACM_hHeap, 0, paldrv);
        return TRUE;
    }
    ERR("unable to close driver instance\n");
    return FALSE;
}

Referenced by acmDriverClose(), and MSACM_OpenLocalDriver().

MSACM_DisableNotifications()

void MSACM_DisableNotifications

(

void

)

Definition at line 459 of file internal.c.

{
    MSACM_suspendBroadcastCount++;
}

Referenced by acmDriverPriority().

MSACM_EnableNotifications()

void MSACM_EnableNotifications

(

void

)

Definition at line 467 of file internal.c.

{
    if (MSACM_suspendBroadcastCount > 0) {
        MSACM_suspendBroadcastCount--;
        if (MSACM_suspendBroadcastCount == 0 && MSACM_pendingBroadcast) {
            MSACM_pendingBroadcast = FALSE;
            MSACM_BroadcastNotification();
        }
    }
}

Referenced by acmDriverPriority().

MSACM_FillCache()

static BOOL MSACM_FillCache ( PWINE_ACMDRIVERID  padid )

static

Definition at line 134 of file internal.c.

{
    HACMDRIVER              had = 0;
    unsigned int                ntag;
    ACMDRIVERDETAILSW           add;
    ACMFORMATTAGDETAILSW        aftd;
 
    if (acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != 0)
    return FALSE;
 
    padid->aFormatTag = NULL;
    add.cbStruct = sizeof(add);
    if (MSACM_Message(had, ACMDM_DRIVER_DETAILS, (LPARAM)&add,  0))
    goto errCleanUp;
 
    if (add.cFormatTags > 0) {
    padid->aFormatTag = HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY,
                      add.cFormatTags * sizeof(padid->aFormatTag[0]));
    if (!padid->aFormatTag) goto errCleanUp;
    }
 
    padid->cFormatTags = add.cFormatTags;
    padid->cFilterTags = add.cFilterTags;
    padid->fdwSupport  = add.fdwSupport;
 
    aftd.cbStruct = sizeof(aftd);
 
    for (ntag = 0; ntag < add.cFormatTags; ntag++) {
    aftd.dwFormatTagIndex = ntag;
    if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)&aftd, ACM_FORMATTAGDETAILSF_INDEX)) {
        TRACE("IIOs (%s)\n", debugstr_w(padid->pszDriverAlias));
        goto errCleanUp;
    }
    padid->aFormatTag[ntag].dwFormatTag = aftd.dwFormatTag;
    padid->aFormatTag[ntag].cbwfx = aftd.cbFormatSize;
    }
 
    acmDriverClose(had, 0);
 
    return TRUE;
 
errCleanUp:
    if (had) acmDriverClose(had, 0);
    HeapFree(MSACM_hHeap, 0, padid->aFormatTag);
    padid->aFormatTag = NULL;
    return FALSE;
}

Referenced by MSACM_RegisterDriver().

MSACM_FindFormatTagInCache()

BOOL MSACM_FindFormatTagInCache	(	const WINE_ACMDRIVERID *	padid,
		DWORD	fmtTag,
		LPDWORD	idx
	)

Definition at line 118 of file internal.c.

{
    unsigned    i;
 
    for (i = 0; i < padid->cFormatTags; i++) {
    if (padid->aFormatTag[i].dwFormatTag == fmtTag) {
        if (idx) *idx = i;
        return TRUE;
    }
    }
    return FALSE;
}

Referenced by acmFormatTagDetailsW(), and acmStreamOpen().

MSACM_GetDriver()

PWINE_ACMDRIVER MSACM_GetDriver

(

HACMDRIVER

hDriver

)

Definition at line 844 of file internal.c.

{
    return (PWINE_ACMDRIVER)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_DRIVER);
}

Referenced by acmDriverClose(), acmFormatTagDetailsW(), acmStreamOpen(), and MSACM_Message().

MSACM_GetDriverID()

PWINE_ACMDRIVERID MSACM_GetDriverID

(

HACMDRIVERID

hDriverID

)

Definition at line 836 of file internal.c.

{
    return (PWINE_ACMDRIVERID)MSACM_GetObj((HACMOBJ)hDriverID, WINE_ACMOBJ_DRIVERID);
}

Referenced by acmDriverMessage(), acmDriverOpen(), acmDriverPriority(), acmDriverRemove(), acmFilterEnumW(), and acmFormatEnumW().

MSACM_GetNotifyWnd()

PWINE_ACMNOTIFYWND MSACM_GetNotifyWnd

(

HACMDRIVERID

hDriver

)

Definition at line 852 of file internal.c.

{
    return (PWINE_ACMNOTIFYWND)MSACM_GetObj((HACMOBJ)hDriver, WINE_ACMOBJ_NOTIFYWND);
}

Referenced by acmDriverPriority(), and acmDriverRemove().

MSACM_GetNumberOfModuleRefs()

static unsigned MSACM_GetNumberOfModuleRefs ( HMODULE  hModule, DRIVERPROC  lpDrvProc, WINE_ACMLOCALDRIVERINST **  found  )

static

Definition at line 925 of file internal.c.

{
    PWINE_ACMLOCALDRIVER lpDrv;
    unsigned        count = 0;
 
    if (found) *found = NULL;
    for (lpDrv = MSACM_pFirstACMLocalDriver; lpDrv; lpDrv = lpDrv->pNextACMLocalDrv)
    {
    if (lpDrv->hModule == hModule && lpDrv->lpDrvProc == lpDrvProc)
        {
            PWINE_ACMLOCALDRIVERINST pInst = lpDrv->pACMInstList;
        
        while (pInst) {
                if (found && !*found) *found = pInst;
            count++;
            pInst = pInst->pNextACMInst;
        }
    }
    }
    return count;
}

Referenced by MSACM_AddToList(), MSACM_CloseLocalDriver(), MSACM_OpenLocalDriver(), and MSACM_RemoveFromList().

MSACM_GetObj()

PWINE_ACMOBJ MSACM_GetObj	(	HACMOBJ	hObj,
		DWORD	type
	)

Definition at line 823 of file internal.c.

{
    PWINE_ACMOBJ    pao = (PWINE_ACMOBJ)hObj;
 
    if (pao == NULL || IsBadReadPtr(pao, sizeof(WINE_ACMOBJ)) ||
    ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
    return NULL;
    return pao;
}

Referenced by acmDriverID(), acmMetrics(), MSACM_GetDriver(), MSACM_GetDriverID(), and MSACM_GetNotifyWnd().

MSACM_GetRegistryKey()

static LPWSTR MSACM_GetRegistryKey ( const WINE_ACMDRIVERID *  padid )

static

Definition at line 185 of file internal.c.

{
    static const WCHAR  baseKey[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
                                     'A','u','d','i','o','C','o','m','p','r','e','s','s','i','o','n','M','a','n','a','g','e','r','\\',
                                     'D','r','i','v','e','r','C','a','c','h','e','\\','\0'};
    LPWSTR  ret;
    int     len;
 
    if (!padid->pszDriverAlias) {
    ERR("No alias needed for registry entry\n");
    return NULL;
    }
    len = lstrlenW(baseKey);
    ret = HeapAlloc(MSACM_hHeap, 0, (len + lstrlenW(padid->pszDriverAlias) + 1) * sizeof(WCHAR));
    if (!ret) return NULL;
 
    lstrcpyW(ret, baseKey);
    lstrcpyW(ret + len, padid->pszDriverAlias);
    CharLowerW(ret + len);
    return ret;
}

Referenced by MSACM_ReadCache(), and MSACM_WriteCache().

MSACM_Message()

MMRESULT MSACM_Message	(	HACMDRIVER	had,
		UINT	uMsg,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 872 of file internal.c.

{
    PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
 
    if (!pad) return MMSYSERR_INVALHANDLE;
    if (pad->hDrvr) return SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2);
    if (pad->pLocalDrvrInst) return MSACM_DRIVER_SendMessage(pad->pLocalDrvrInst, uMsg, lParam1, lParam2);
 
    return MMSYSERR_INVALHANDLE;
}

Referenced by acmDriverDetailsW(), acmDriverMessage(), acmFilterDetailsW(), acmFilterTagDetailsW(), acmFormatDetailsW(), acmFormatSuggest(), acmFormatTagDetailsW(), acmFormatTagEnumW(), acmStreamClose(), acmStreamConvert(), acmStreamOpen(), acmStreamPrepareHeader(), acmStreamReset(), acmStreamSize(), acmStreamUnprepareHeader(), and MSACM_FillCache().

MSACM_OpenLocalDriver()

PWINE_ACMLOCALDRIVERINST MSACM_OpenLocalDriver	(	PWINE_ACMLOCALDRIVER	paldrv,
		LPARAM	lParam2
	)

Definition at line 1026 of file internal.c.

{
    PWINE_ACMLOCALDRIVERINST pDrvInst;
    
    pDrvInst = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVERINST));
    if (!pDrvInst)
        return NULL;
 
    pDrvInst->pLocalDriver = paldrv;
    pDrvInst->dwDriverID = 0;
    pDrvInst->pNextACMInst = NULL;
    pDrvInst->bSession = FALSE;
    
    /* Win32 installable drivers must support a two phase opening scheme:
     * + first open with NULL as lParam2 (session instance),
     * + then do a second open with the real non null lParam2)
     */
    if (MSACM_GetNumberOfModuleRefs(paldrv->hModule, paldrv->lpDrvProc, NULL) == 0 && lParam2)
    {
        PWINE_ACMLOCALDRIVERINST   ret;
 
        if (!MSACM_AddToList(pDrvInst, 0L))
        {
            ERR("load0 failed\n");
            goto exit;
        }
        ret = MSACM_OpenLocalDriver(paldrv, lParam2);
        if (!ret)
        {
            ERR("load1 failed\n");
            /* If MSACM_CloseLocalDriver returns TRUE,
             * then pDrvInst has been freed
             */
            if (!MSACM_CloseLocalDriver(pDrvInst))
                goto exit;
 
            return NULL;
        }
        pDrvInst->bSession = TRUE;
        return ret;
    }
    
    if (!MSACM_AddToList(pDrvInst, lParam2))
    {
        ERR("load failed\n");
        goto exit;
    }
 
    TRACE("=> %p\n", pDrvInst);
    return pDrvInst;
exit:
    HeapFree(MSACM_hHeap, 0, pDrvInst);
    return NULL;
}

Referenced by acmDriverOpen(), and MSACM_OpenLocalDriver().

MSACM_ReadCache()

static BOOL MSACM_ReadCache ( PWINE_ACMDRIVERID  padid )

static

Definition at line 210 of file internal.c.

{
    LPWSTR  key = MSACM_GetRegistryKey(padid);
    HKEY    hKey;
    DWORD   type, size;
 
    if (!key) return FALSE;
 
    padid->aFormatTag = NULL;
 
    if (RegCreateKeyW(HKEY_LOCAL_MACHINE, key, &hKey))
    goto errCleanUp;
 
    size = sizeof(padid->cFormatTags);
    if (RegQueryValueExA(hKey, "cFormatTags", 0, &type, (void*)&padid->cFormatTags, &size))
    goto errCleanUp;
    size = sizeof(padid->cFilterTags);
    if (RegQueryValueExA(hKey, "cFilterTags", 0, &type, (void*)&padid->cFilterTags, &size))
    goto errCleanUp;
    size = sizeof(padid->fdwSupport);
    if (RegQueryValueExA(hKey, "fdwSupport", 0, &type, (void*)&padid->fdwSupport, &size))
    goto errCleanUp;
 
    if (padid->cFormatTags > 0) {
    size = padid->cFormatTags * sizeof(padid->aFormatTag[0]);
    padid->aFormatTag = HeapAlloc(MSACM_hHeap, HEAP_ZERO_MEMORY, size);
    if (!padid->aFormatTag) goto errCleanUp;
    if (RegQueryValueExA(hKey, "aFormatTagCache", 0, &type, (void*)padid->aFormatTag, &size))
        goto errCleanUp;
    }
    HeapFree(MSACM_hHeap, 0, key);
    return TRUE;
 
 errCleanUp:
    HeapFree(MSACM_hHeap, 0, key);
    HeapFree(MSACM_hHeap, 0, padid->aFormatTag);
    padid->aFormatTag = NULL;
    RegCloseKey(hKey);
    return FALSE;
}

Referenced by MSACM_RegisterDriver().

MSACM_RegisterAllDrivers()

void MSACM_RegisterAllDrivers

(

void

)

Definition at line 354 of file internal.c.

{
    static const WCHAR msacm32[] = {'m','s','a','c','m','3','2','.','d','l','l','\0'};
    static const WCHAR msacmW[] = {'M','S','A','C','M','.'};
    static const WCHAR drv32[] = {'d','r','i','v','e','r','s','3','2','\0'};
    static const WCHAR sys[] = {'s','y','s','t','e','m','.','i','n','i','\0'};
    static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\',
                   'M','i','c','r','o','s','o','f','t','\\',
                   'W','i','n','d','o','w','s',' ','N','T','\\',
                   'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
                   'D','r','i','v','e','r','s','3','2','\0'};
    DWORD i, cnt, bufLen, lRet, type;
    WCHAR buf[2048], valname[64], *name, *s;
    FILETIME lastWrite;
    HKEY hKey;
 
    /* FIXME: What if the user edits system.ini while the program is running?
     * Does Windows handle that?  */
    if (MSACM_pFirstACMDriverID) return;
 
    lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, drvkey, 0, KEY_QUERY_VALUE, &hKey);
    if (lRet == ERROR_SUCCESS) {
    RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
    for (i = 0; i < cnt; i++) {
        bufLen = ARRAY_SIZE(buf);
        lRet = RegEnumKeyExW(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite);
        if (lRet != ERROR_SUCCESS) continue;
        if (_wcsnicmp(buf, msacmW, ARRAY_SIZE(msacmW))) continue;
        if (!(name = wcschr(buf, '='))) continue;
        *name = 0;
        MSACM_RegisterDriver(buf, name + 1, 0);
    }
    i = 0;
    cnt = ARRAY_SIZE(valname);
    bufLen = sizeof(buf);
    while(RegEnumValueW(hKey, i, valname, &cnt, 0,
            &type, (BYTE*)buf, &bufLen) == ERROR_SUCCESS){
        if (!_wcsnicmp(valname, msacmW, ARRAY_SIZE(msacmW)))
        MSACM_RegisterDriver(valname, buf, 0);
        ++i;
    }
        RegCloseKey( hKey );
    }
 
    if (GetPrivateProfileSectionW(drv32, buf, ARRAY_SIZE(buf), sys))
    {
    for(s = buf; *s;  s += lstrlenW(s) + 1)
    {
        if (_wcsnicmp(s, msacmW, ARRAY_SIZE(msacmW))) continue;
        if (!(name = wcschr(s, '='))) continue;
        *name = 0;
        MSACM_RegisterDriver(s, name + 1, 0);
        *name = '=';
    }
    }
    MSACM_ReorderDriversByPriority();
    MSACM_RegisterDriver(msacm32, msacm32, 0);
}

Referenced by DllMain().

MSACM_RegisterDriver()

PWINE_ACMDRIVERID MSACM_RegisterDriver	(	LPCWSTR	pszDriverAlias,
		LPCWSTR	pszFileName,
		PWINE_ACMLOCALDRIVER	pLocalDriver
	)

Definition at line 285 of file internal.c.

{
    PWINE_ACMDRIVERID   padid;
 
    TRACE("(%s, %s, %p)\n", 
          debugstr_w(pszDriverAlias), debugstr_w(pszFileName), pLocalDriver);
 
    padid = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID));
    if (!padid)
        return NULL;
    padid->obj.dwType = WINE_ACMOBJ_DRIVERID;
    padid->obj.pACMDriverID = padid;
    padid->pszDriverAlias = NULL;
    if (pszDriverAlias)
    {
        padid->pszDriverAlias = HeapAlloc( MSACM_hHeap, 0, (lstrlenW(pszDriverAlias)+1) * sizeof(WCHAR) );
        if (!padid->pszDriverAlias) {
            HeapFree(MSACM_hHeap, 0, padid);
            return NULL;
        }
        lstrcpyW( padid->pszDriverAlias, pszDriverAlias );
    }
    padid->pszFileName = NULL;
    if (pszFileName)
    {
        padid->pszFileName = HeapAlloc( MSACM_hHeap, 0, (lstrlenW(pszFileName)+1) * sizeof(WCHAR) );
        if (!padid->pszFileName) {
            HeapFree(MSACM_hHeap, 0, padid->pszDriverAlias);
            HeapFree(MSACM_hHeap, 0, padid);
            return NULL;
        }
        lstrcpyW( padid->pszFileName, pszFileName );
    }
    padid->pLocalDriver = pLocalDriver;
 
    padid->pACMDriverList = NULL;
    
    if (pLocalDriver) {
        padid->pPrevACMDriverID = NULL;
        padid->pNextACMDriverID = MSACM_pFirstACMDriverID;
        if (MSACM_pFirstACMDriverID)
            MSACM_pFirstACMDriverID->pPrevACMDriverID = padid;
        MSACM_pFirstACMDriverID = padid;
        if (!MSACM_pLastACMDriverID)
            MSACM_pLastACMDriverID = padid;
    } else {
        padid->pNextACMDriverID = NULL;
        padid->pPrevACMDriverID = MSACM_pLastACMDriverID;
        if (MSACM_pLastACMDriverID)
        MSACM_pLastACMDriverID->pNextACMDriverID = padid;
        MSACM_pLastACMDriverID = padid;
        if (!MSACM_pFirstACMDriverID)
        MSACM_pFirstACMDriverID = padid;
    }
    /* disable the driver if we cannot load the cache */
    if ((!padid->pszDriverAlias || !MSACM_ReadCache(padid)) && !MSACM_FillCache(padid)) {
    WARN("Couldn't load cache for ACM driver (%s)\n", debugstr_w(pszFileName));
    MSACM_UnregisterDriver(padid);
    return NULL;
    }
 
    if (pLocalDriver) padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_LOCAL;
    return padid;
}

Referenced by acmDriverAddW(), MSACM_RegisterAllDrivers(), and MSACM_RegisterDriverFromRegistry().

MSACM_RegisterDriverFromRegistry()

PWINE_ACMDRIVERID MSACM_RegisterDriverFromRegistry

(

LPCWSTR

pszRegEntry

)

Definition at line 61 of file internal.c.

{
    static const WCHAR msacmW[] = {'M','S','A','C','M','.'};
    static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\',
                   'M','i','c','r','o','s','o','f','t','\\',
                   'W','i','n','d','o','w','s',' ','N','T','\\',
                   'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
                   'D','r','i','v','e','r','s','3','2','\0'};
    WCHAR buf[2048];
    DWORD bufLen, lRet;
    HKEY hKey;
    PWINE_ACMDRIVERID padid = NULL;
    
    /* The requested registry entry must have the format msacm.XXXXX in order to
       be recognized in any future sessions of msacm
     */
    if (0 == _wcsnicmp(pszRegEntry, msacmW, ARRAY_SIZE(msacmW))) {
        lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, drvkey, 0, KEY_QUERY_VALUE, &hKey);
        if (lRet != ERROR_SUCCESS) {
            WARN("unable to open registry key - 0x%08x\n", lRet);
        } else {
            bufLen = sizeof(buf);
            lRet = RegQueryValueExW(hKey, pszRegEntry, NULL, NULL, (LPBYTE)buf, &bufLen);
            if (lRet != ERROR_SUCCESS) {
                WARN("unable to query requested subkey %s - 0x%08x\n", debugstr_w(pszRegEntry), lRet);
            } else {
                MSACM_RegisterDriver(pszRegEntry, buf, 0);
            }
            RegCloseKey( hKey );
        }
    }
    return padid;
}

Referenced by acmDriverAddW().

MSACM_RegisterLocalDriver()

PWINE_ACMLOCALDRIVER MSACM_RegisterLocalDriver	(	HMODULE	hModule,
		DRIVERPROC	lpDriverProc
	)

Definition at line 883 of file internal.c.

{
    PWINE_ACMLOCALDRIVER paldrv;
 
    TRACE("(%p, %p)\n", hModule, lpDriverProc);
    if (!hModule || !lpDriverProc) return NULL;
    
    /* look up previous instance of local driver module */
    for (paldrv = MSACM_pFirstACMLocalDriver; paldrv; paldrv = paldrv->pNextACMLocalDrv)
    {
        if (paldrv->hModule == hModule && paldrv->lpDrvProc == lpDriverProc)
        {
            InterlockedIncrement(&paldrv->ref);
            return paldrv;
        }
    }
 
    paldrv = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
    paldrv->obj.dwType = WINE_ACMOBJ_LOCALDRIVER;
    paldrv->obj.pACMDriverID = 0;
    paldrv->hModule = hModule;
    paldrv->lpDrvProc = lpDriverProc;
    paldrv->pACMInstList = NULL;
    paldrv->ref = 1;
 
    paldrv->pNextACMLocalDrv = NULL;
    paldrv->pPrevACMLocalDrv = MSACM_pLastACMLocalDriver;
    if (MSACM_pLastACMLocalDriver)
    MSACM_pLastACMLocalDriver->pNextACMLocalDrv = paldrv;
    MSACM_pLastACMLocalDriver = paldrv;
    if (!MSACM_pFirstACMLocalDriver)
    MSACM_pFirstACMLocalDriver = paldrv;
 
    return paldrv;
}

Referenced by acmDriverAddW().

MSACM_RegisterNotificationWindow()

PWINE_ACMNOTIFYWND MSACM_RegisterNotificationWindow	(	HWND	hNotifyWnd,
		DWORD	dwNotifyMsg
	)

Definition at line 416 of file internal.c.

{
    PWINE_ACMNOTIFYWND  panwnd;
 
    TRACE("(%p,0x%08x)\n", hNotifyWnd, dwNotifyMsg);
 
    panwnd = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMNOTIFYWND));
    panwnd->obj.dwType = WINE_ACMOBJ_NOTIFYWND;
    panwnd->obj.pACMDriverID = 0;
    panwnd->hNotifyWnd = hNotifyWnd;
    panwnd->dwNotifyMsg = dwNotifyMsg;
    panwnd->fdwSupport = 0;
    
    panwnd->pNextACMNotifyWnd = NULL;
    panwnd->pPrevACMNotifyWnd = MSACM_pLastACMNotifyWnd;
    if (MSACM_pLastACMNotifyWnd)
        MSACM_pLastACMNotifyWnd->pNextACMNotifyWnd = panwnd;
    MSACM_pLastACMNotifyWnd = panwnd;
    if (!MSACM_pFirstACMNotifyWnd)
        MSACM_pFirstACMNotifyWnd = panwnd;
 
    return panwnd;
}

Referenced by acmDriverAddW().

MSACM_RemoveFromList()

static BOOL MSACM_RemoveFromList ( PWINE_ACMLOCALDRIVERINST  lpDrv )

static

Definition at line 953 of file internal.c.

{
    PWINE_ACMLOCALDRIVER pDriverBase = lpDrv->pLocalDriver;
    PWINE_ACMLOCALDRIVERINST pPrevInst;
 
    /* last of this driver in list ? */
    if (MSACM_GetNumberOfModuleRefs(pDriverBase->hModule, pDriverBase->lpDrvProc, NULL) == 1) {
        MSACM_DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
        MSACM_DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
    }
    
    pPrevInst = NULL;
    if (pDriverBase->pACMInstList != lpDrv) {
        pPrevInst = pDriverBase->pACMInstList;
        while (pPrevInst && pPrevInst->pNextACMInst != lpDrv)
            pPrevInst = pPrevInst->pNextACMInst;
        if (!pPrevInst) {
            ERR("requested to remove invalid instance %p\n", pPrevInst);
            return FALSE;
        }
    }
    if (!pPrevInst) {
        /* first driver instance on list */
        pDriverBase->pACMInstList = lpDrv->pNextACMInst;
    } else {
        pPrevInst->pNextACMInst = lpDrv->pNextACMInst;
    }
    return TRUE;
}

Referenced by MSACM_AddToList(), and MSACM_CloseLocalDriver().

MSACM_ReorderDriversByPriority()

static void MSACM_ReorderDriversByPriority ( void  )

static

Definition at line 556 of file internal.c.

{
    PWINE_ACMDRIVERID   padid;
    unsigned int iNumDrivers;
    PWINE_ACMDRIVERID * driverList = NULL;
    HKEY hPriorityKey = NULL;
    
    TRACE("\n");
    
    /* Count drivers && alloc corresponding memory for list */
    iNumDrivers = 0;
    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) iNumDrivers++;
    if (iNumDrivers > 1)
    {
        LONG lError;
        static const WCHAR basePriorityKey[] = {
            'S','o','f','t','w','a','r','e','\\',
            'M','i','c','r','o','s','o','f','t','\\',
            'M','u','l','t','i','m','e','d','i','a','\\',
            'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
            'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
        };
        unsigned int i;
        LONG lBufferLength;
        WCHAR szBuffer[256];
        
        driverList = HeapAlloc(MSACM_hHeap, 0, iNumDrivers * sizeof(PWINE_ACMDRIVERID));
        if (!driverList)
        {
            ERR("out of memory\n");
            goto errCleanUp;
        }
 
        lError = RegOpenKeyW(HKEY_CURRENT_USER, basePriorityKey, &hPriorityKey);
        if (lError != ERROR_SUCCESS) {
            TRACE("RegOpenKeyW failed, possibly key does not exist yet\n");
            hPriorityKey = NULL;
            goto errCleanUp;
        } 
            
        /* Copy drivers into list to simplify linked list modification */
        for (i = 0, padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID, i++)
        {
            driverList[i] = padid;
        }
 
        /* Query each of the priorities in turn. Alias key is in lowercase. 
            The general form of the priority record is the following:
            "PriorityN" --> "1, msacm.driveralias"
            where N is an integer, and the value is a string of the driver
            alias, prefixed by "1, " for an enabled driver, or "0, " for a
            disabled driver.
            */
        for (i = 0; i < iNumDrivers; i++)
        {
            static const WCHAR priorityTmpl[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
            WCHAR szSubKey[17];
            unsigned int iTargetPosition;
            unsigned int iCurrentPosition;
            WCHAR * pAlias;
            static const WCHAR sPrefix[] = {'m','s','a','c','m','.','\0'};
            
            /* Build expected entry name */
            swprintf(szSubKey, priorityTmpl, i + 1);
            lBufferLength = sizeof(szBuffer);
            lError = RegQueryValueExW(hPriorityKey, szSubKey, NULL, NULL, (LPBYTE)szBuffer, (LPDWORD)&lBufferLength);
            if (lError != ERROR_SUCCESS) continue;
 
            /* Recovered driver alias should be at this position */
            iTargetPosition = i;
            
            /* Locate driver alias in driver list */
            pAlias = wcsstr(szBuffer, sPrefix);
            if (pAlias == NULL) continue;
            
            for (iCurrentPosition = 0; iCurrentPosition < iNumDrivers; iCurrentPosition++) {
                if (wcsicmp(driverList[iCurrentPosition]->pszDriverAlias, pAlias) == 0)
                    break;
            }
            if (iCurrentPosition < iNumDrivers && iTargetPosition != iCurrentPosition) {
                padid = driverList[iTargetPosition];
                driverList[iTargetPosition] = driverList[iCurrentPosition];
                driverList[iCurrentPosition] = padid;
 
                /* Locate enabled status */
                if (szBuffer[0] == '1') {
                    driverList[iTargetPosition]->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
                } else if (szBuffer[0] == '0') {
                    driverList[iTargetPosition]->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
                }
            }
        }
        
        /* Re-assign pointers so that linked list traverses the ordered array */
        for (i = 0; i < iNumDrivers; i++) {
            driverList[i]->pPrevACMDriverID = (i > 0) ? driverList[i - 1] : NULL;
            driverList[i]->pNextACMDriverID = (i < iNumDrivers - 1) ? driverList[i + 1] : NULL;
        }
        MSACM_pFirstACMDriverID = driverList[0];
        MSACM_pLastACMDriverID = driverList[iNumDrivers - 1];
    }
    
errCleanUp:
    if (hPriorityKey != NULL) RegCloseKey(hPriorityKey);
    HeapFree(MSACM_hHeap, 0, driverList);
}

Referenced by MSACM_RegisterAllDrivers().

MSACM_RePositionDriver()

void MSACM_RePositionDriver	(	PWINE_ACMDRIVERID	padid,
		DWORD	dwPriority
	)

Definition at line 504 of file internal.c.

{
    PWINE_ACMDRIVERID pTargetPosition = NULL;
                
    /* Remove selected driver from linked list */
    if (MSACM_pFirstACMDriverID == padid) {
        MSACM_pFirstACMDriverID = padid->pNextACMDriverID;
    }
    if (MSACM_pLastACMDriverID == padid) {
        MSACM_pLastACMDriverID = padid->pPrevACMDriverID;
    }
    if (padid->pPrevACMDriverID != NULL) {
        padid->pPrevACMDriverID->pNextACMDriverID = padid->pNextACMDriverID;
    }
    if (padid->pNextACMDriverID != NULL) {
        padid->pNextACMDriverID->pPrevACMDriverID = padid->pPrevACMDriverID;
    }
    
    /* Look up position where selected driver should be */
    if (dwPriority == 1) {
        pTargetPosition = padid->pPrevACMDriverID;
        while (pTargetPosition->pPrevACMDriverID != NULL &&
            !(pTargetPosition->pPrevACMDriverID->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL)) {
            pTargetPosition = pTargetPosition->pPrevACMDriverID;
        }
    } else if (dwPriority == -1) {
        pTargetPosition = padid->pNextACMDriverID;
        while (pTargetPosition->pNextACMDriverID != NULL) {
            pTargetPosition = pTargetPosition->pNextACMDriverID;
        }
    }
    
    /* Place selected driver in selected position */
    padid->pPrevACMDriverID = pTargetPosition->pPrevACMDriverID;
    padid->pNextACMDriverID = pTargetPosition;
    if (padid->pPrevACMDriverID != NULL) {
        padid->pPrevACMDriverID->pNextACMDriverID = padid;
    } else {
        MSACM_pFirstACMDriverID = padid;
    }
    if (padid->pNextACMDriverID != NULL) {
        padid->pNextACMDriverID->pPrevACMDriverID = padid;
    } else {
        MSACM_pLastACMDriverID = padid;
    }
}

Referenced by acmDriverPriority().

MSACM_UnregisterAllDrivers()

void MSACM_UnregisterAllDrivers

(

void

)

Definition at line 805 of file internal.c.

{
    PWINE_ACMNOTIFYWND panwnd = MSACM_pFirstACMNotifyWnd;
    PWINE_ACMDRIVERID p = MSACM_pFirstACMDriverID;
 
    while (p) {
    MSACM_WriteCache(p);
    p = MSACM_UnregisterDriver(p);
    }
    
    while (panwnd) {
    panwnd = MSACM_UnRegisterNotificationWindow(panwnd);
    }
}

Referenced by DllMain().

MSACM_UnregisterDriver()

PWINE_ACMDRIVERID MSACM_UnregisterDriver

(

PWINE_ACMDRIVERID

p

)

Definition at line 773 of file internal.c.

{
    PWINE_ACMDRIVERID pNextACMDriverID;
 
    while (p->pACMDriverList)
    acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
 
    HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
    HeapFree(MSACM_hHeap, 0, p->pszFileName);
    HeapFree(MSACM_hHeap, 0, p->aFormatTag);
 
    if (p == MSACM_pFirstACMDriverID)
    MSACM_pFirstACMDriverID = p->pNextACMDriverID;
    if (p == MSACM_pLastACMDriverID)
    MSACM_pLastACMDriverID = p->pPrevACMDriverID;
 
    if (p->pPrevACMDriverID)
    p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
    if (p->pNextACMDriverID)
    p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
 
    pNextACMDriverID = p->pNextACMDriverID;
 
    if (p->pLocalDriver) MSACM_UnregisterLocalDriver(p->pLocalDriver);
    HeapFree(MSACM_hHeap, 0, p);
 
    return pNextACMDriverID;
}

Referenced by acmDriverRemove(), MSACM_RegisterDriver(), and MSACM_UnregisterAllDrivers().

MSACM_UnregisterLocalDriver()

static PWINE_ACMLOCALDRIVER MSACM_UnregisterLocalDriver ( PWINE_ACMLOCALDRIVER  paldrv )

static

Definition at line 739 of file internal.c.

{
    PWINE_ACMLOCALDRIVER pNextACMLocalDriver;
    LONG ref;
 
    if (paldrv->pACMInstList) {
        ERR("local driver instances still present after closing all drivers - memory leak\n");
        return NULL;
    }
 
    ref = InterlockedDecrement(&paldrv->ref);
    if (ref)
        return paldrv;
 
    if (paldrv == MSACM_pFirstACMLocalDriver)
        MSACM_pFirstACMLocalDriver = paldrv->pNextACMLocalDrv;
    if (paldrv == MSACM_pLastACMLocalDriver)
        MSACM_pLastACMLocalDriver = paldrv->pPrevACMLocalDrv;
 
    if (paldrv->pPrevACMLocalDrv)
        paldrv->pPrevACMLocalDrv->pNextACMLocalDrv = paldrv->pNextACMLocalDrv;
    if (paldrv->pNextACMLocalDrv)
        paldrv->pNextACMLocalDrv->pPrevACMLocalDrv = paldrv->pPrevACMLocalDrv;
 
    pNextACMLocalDriver = paldrv->pNextACMLocalDrv;
 
    HeapFree(MSACM_hHeap, 0, paldrv);
 
    return pNextACMLocalDriver;
}

Referenced by MSACM_UnregisterDriver().

MSACM_UnRegisterNotificationWindow()

PWINE_ACMNOTIFYWND MSACM_UnRegisterNotificationWindow

(

const WINE_ACMNOTIFYWND *

panwnd

)

Definition at line 481 of file internal.c.

{
    PWINE_ACMNOTIFYWND p;
 
    for (p = MSACM_pFirstACMNotifyWnd; p; p = p->pNextACMNotifyWnd) {
        if (p == panwnd) {
            PWINE_ACMNOTIFYWND pNext = p->pNextACMNotifyWnd;
 
            if (p->pPrevACMNotifyWnd) p->pPrevACMNotifyWnd->pNextACMNotifyWnd = p->pNextACMNotifyWnd;
            if (p->pNextACMNotifyWnd) p->pNextACMNotifyWnd->pPrevACMNotifyWnd = p->pPrevACMNotifyWnd;
            if (MSACM_pFirstACMNotifyWnd == p) MSACM_pFirstACMNotifyWnd = p->pNextACMNotifyWnd;
            if (MSACM_pLastACMNotifyWnd == p) MSACM_pLastACMNotifyWnd = p->pPrevACMNotifyWnd;
            HeapFree(MSACM_hHeap, 0, p);
            
            return pNext;
        }
    }
    return NULL;
}

Referenced by acmDriverRemove(), and MSACM_UnregisterAllDrivers().

MSACM_WriteCache()

static BOOL MSACM_WriteCache ( const WINE_ACMDRIVERID *  padid )

static

Definition at line 254 of file internal.c.

{
    LPWSTR  key = MSACM_GetRegistryKey(padid);
    HKEY    hKey;
 
    if (!key) return FALSE;
 
    if (RegCreateKeyW(HKEY_LOCAL_MACHINE, key, &hKey))
    goto errCleanUp;
 
    if (RegSetValueExA(hKey, "cFormatTags", 0, REG_DWORD, (const void*)&padid->cFormatTags, sizeof(DWORD)))
    goto errCleanUp;
    if (RegSetValueExA(hKey, "cFilterTags", 0, REG_DWORD, (const void*)&padid->cFilterTags, sizeof(DWORD)))
    goto errCleanUp;
    if (RegSetValueExA(hKey, "fdwSupport", 0, REG_DWORD, (const void*)&padid->fdwSupport, sizeof(DWORD)))
    goto errCleanUp;
    if (RegSetValueExA(hKey, "aFormatTagCache", 0, REG_BINARY,
               (void*)padid->aFormatTag,
               padid->cFormatTags * sizeof(padid->aFormatTag[0])))
    goto errCleanUp;
    HeapFree(MSACM_hHeap, 0, key);
    return TRUE;
 
 errCleanUp:
    HeapFree(MSACM_hHeap, 0, key);
    return FALSE;
}

Referenced by MSACM_UnregisterAllDrivers().

MSACM_WriteCurrentPriorities()

void MSACM_WriteCurrentPriorities

(

void

)

Definition at line 668 of file internal.c.

{
    LONG lError;
    HKEY hPriorityKey;
    static const WCHAR basePriorityKey[] = {
        'S','o','f','t','w','a','r','e','\\',
        'M','i','c','r','o','s','o','f','t','\\',
        'M','u','l','t','i','m','e','d','i','a','\\',
        'A','u','d','i','o',' ','C','o','m','p','r','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
        'P','r','i','o','r','i','t','y',' ','v','4','.','0','0','\0'
    };
    PWINE_ACMDRIVERID padid;
    DWORD dwPriorityCounter;
    static const WCHAR priorityTmpl[] = {'P','r','i','o','r','i','t','y','%','l','d','\0'};
    static const WCHAR valueTmpl[] = {'%','c',',',' ','%','s','\0'};
    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'};
    WCHAR szSubKey[17];
    WCHAR szBuffer[256];
 
    /* Delete ACM priority key and create it anew */
    lError = RegDeleteKeyW(HKEY_CURRENT_USER, basePriorityKey);
    if (lError != ERROR_SUCCESS && lError != ERROR_FILE_NOT_FOUND) {
        ERR("unable to remove current key %s (0x%08x) - priority changes won't persist past application end.\n",
            debugstr_w(basePriorityKey), lError);
        return;
    }
    lError = RegCreateKeyW(HKEY_CURRENT_USER, basePriorityKey, &hPriorityKey);
    if (lError != ERROR_SUCCESS) {
        ERR("unable to create key %s (0x%08x) - priority changes won't persist past application end.\n",
            debugstr_w(basePriorityKey), lError);
        return;
    }
    
    /* Write current list of priorities */
    for (dwPriorityCounter = 0, padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {        
        if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) continue;
        if (padid->pszDriverAlias == NULL) continue;    /* internal PCM converter is last */
 
        /* Build required value name */
        dwPriorityCounter++;
        swprintf(szSubKey, priorityTmpl, dwPriorityCounter);
        
        /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
        swprintf(szBuffer, valueTmpl, (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ? '0' : '1', padid->pszDriverAlias);
        _wcslwr(szBuffer);
        
        lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (lstrlenW(szBuffer) + 1) * sizeof(WCHAR));
        if (lError != ERROR_SUCCESS) {
            ERR("unable to write value for %s under key %s (0x%08x)\n",
                debugstr_w(padid->pszDriverAlias), debugstr_w(basePriorityKey), lError);
        }
    }
    
    /* Build required value name */
    dwPriorityCounter++;
    swprintf(szSubKey, priorityTmpl, dwPriorityCounter);
        
    /* Value has a 1 in front for enabled drivers and 0 for disabled drivers */
    swprintf(szBuffer, valueTmpl, '1', converterAlias);
        
    lError = RegSetValueExW(hPriorityKey, szSubKey, 0, REG_SZ, (BYTE *)szBuffer, (lstrlenW(szBuffer) + 1) * sizeof(WCHAR));
    if (lError != ERROR_SUCCESS) {
        ERR("unable to write value for %s under key %s (0x%08x)\n",
            debugstr_w(converterAlias), debugstr_w(basePriorityKey), lError);
    }
    RegCloseKey(hPriorityKey);
}

Referenced by acmDriverPriority().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msacm

)

Variable Documentation

MSACM_hHeap

HANDLE MSACM_hHeap = NULL

Definition at line 47 of file internal.c.

Referenced by acmDriverAddA(), acmDriverClose(), acmDriverMessage(), acmDriverOpen(), acmStreamClose(), acmStreamOpen(), DllMain(), MSACM_CloseLocalDriver(), MSACM_FillCache(), MSACM_FillFormatTagsCB(), MSACM_GetRegistryKey(), MSACM_OpenLocalDriver(), MSACM_ReadCache(), MSACM_RegisterDriver(), MSACM_RegisterLocalDriver(), MSACM_RegisterNotificationWindow(), MSACM_ReorderDriversByPriority(), MSACM_UnregisterDriver(), MSACM_UnregisterLocalDriver(), MSACM_UnRegisterNotificationWindow(), and MSACM_WriteCache().

MSACM_pendingBroadcast

BOOL MSACM_pendingBroadcast = FALSE

static

Definition at line 52 of file internal.c.

Referenced by MSACM_BroadcastNotification(), and MSACM_EnableNotifications().

MSACM_pFirstACMDriverID

PWINE_ACMDRIVERID MSACM_pFirstACMDriverID = NULL

Definition at line 48 of file internal.c.

Referenced by acmDriverEnum(), acmFilterDetailsW(), acmFilterEnumW(), acmFilterTagDetailsW(), acmFilterTagEnumW(), acmFormatDetailsW(), acmFormatEnumW(), acmFormatSuggest(), acmFormatTagDetailsW(), acmFormatTagEnumW(), acmMetrics(), acmStreamOpen(), MSACM_RegisterAllDrivers(), MSACM_RegisterDriver(), MSACM_ReorderDriversByPriority(), MSACM_RePositionDriver(), MSACM_UnregisterAllDrivers(), MSACM_UnregisterDriver(), and MSACM_WriteCurrentPriorities().

MSACM_pFirstACMLocalDriver

PWINE_ACMLOCALDRIVER MSACM_pFirstACMLocalDriver

static

Definition at line 736 of file internal.c.

Referenced by MSACM_GetNumberOfModuleRefs(), MSACM_RegisterLocalDriver(), and MSACM_UnregisterLocalDriver().

MSACM_pFirstACMNotifyWnd

PWINE_ACMNOTIFYWND MSACM_pFirstACMNotifyWnd = NULL

static

Definition at line 53 of file internal.c.

Referenced by MSACM_BroadcastNotification(), MSACM_RegisterNotificationWindow(), MSACM_UnregisterAllDrivers(), and MSACM_UnRegisterNotificationWindow().

MSACM_pLastACMDriverID

PWINE_ACMDRIVERID MSACM_pLastACMDriverID

static

Definition at line 49 of file internal.c.

Referenced by MSACM_RegisterDriver(), MSACM_ReorderDriversByPriority(), MSACM_RePositionDriver(), and MSACM_UnregisterDriver().

MSACM_pLastACMLocalDriver

PWINE_ACMLOCALDRIVER MSACM_pLastACMLocalDriver

static

Definition at line 737 of file internal.c.

Referenced by MSACM_RegisterLocalDriver(), and MSACM_UnregisterLocalDriver().

MSACM_pLastACMNotifyWnd

PWINE_ACMNOTIFYWND MSACM_pLastACMNotifyWnd = NULL

static

Definition at line 54 of file internal.c.

Referenced by MSACM_RegisterNotificationWindow(), and MSACM_UnRegisterNotificationWindow().

MSACM_suspendBroadcastCount

DWORD MSACM_suspendBroadcastCount = 0

static

Definition at line 51 of file internal.c.

Referenced by MSACM_BroadcastNotification(), MSACM_DisableNotifications(), and MSACM_EnableNotifications().