wineacm.h File Reference

#include <windef.h>
#include <winuser.h>
#include "msacmdlg.h"

Include dependency graph for wineacm.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_WINE_ACMOBJ
struct	_WINE_ACMLOCALDRIVER
struct	_WINE_ACMLOCALDRIVERINST
struct	_WINE_ACMDRIVER
struct	_WINE_ACMSTREAM
struct	_WINE_ACMDRIVERID
struct	_WINE_ACMNOTIFYWND

Macros
#define	WINE_ACMOBJ_DONTCARE   0x5EED0000
#define	WINE_ACMOBJ_DRIVERID   0x5EED0001
#define	WINE_ACMOBJ_DRIVER   0x5EED0002
#define	WINE_ACMOBJ_STREAM   0x5EED0003
#define	WINE_ACMOBJ_NOTIFYWND   0x5EED0004
#define	WINE_ACMOBJ_LOCALDRIVER   0x5EED0005

Typedefs
typedef struct _WINE_ACMDRIVERID *	PWINE_ACMDRIVERID
typedef struct _WINE_ACMDRIVER *	PWINE_ACMDRIVER
typedef struct _WINE_ACMOBJ	WINE_ACMOBJ
typedef struct _WINE_ACMOBJ *	PWINE_ACMOBJ
typedef struct _WINE_ACMLOCALDRIVER *	PWINE_ACMLOCALDRIVER
typedef struct _WINE_ACMLOCALDRIVERINST *	PWINE_ACMLOCALDRIVERINST
typedef struct _WINE_ACMLOCALDRIVER	WINE_ACMLOCALDRIVER
typedef struct _WINE_ACMLOCALDRIVERINST	WINE_ACMLOCALDRIVERINST
typedef struct _WINE_ACMDRIVER	WINE_ACMDRIVER
typedef struct _WINE_ACMSTREAM	WINE_ACMSTREAM
typedef struct _WINE_ACMSTREAM *	PWINE_ACMSTREAM
typedef struct _WINE_ACMDRIVERID	WINE_ACMDRIVERID
typedef struct _WINE_ACMNOTIFYWND *	PWINE_ACMNOTIFYWND
typedef struct _WINE_ACMNOTIFYWND	WINE_ACMNOTIFYWND

Functions
PWINE_ACMDRIVERID	MSACM_RegisterDriver (LPCWSTR pszDriverAlias, LPCWSTR pszFileName, PWINE_ACMLOCALDRIVER pLocalDriver) DECLSPEC_HIDDEN
void	MSACM_RegisterAllDrivers (void) DECLSPEC_HIDDEN
PWINE_ACMDRIVERID	MSACM_UnregisterDriver (PWINE_ACMDRIVERID p) DECLSPEC_HIDDEN
void	MSACM_UnregisterAllDrivers (void) DECLSPEC_HIDDEN
PWINE_ACMDRIVERID	MSACM_GetDriverID (HACMDRIVERID hDriverID) DECLSPEC_HIDDEN
PWINE_ACMDRIVER	MSACM_GetDriver (HACMDRIVER hDriver) DECLSPEC_HIDDEN
PWINE_ACMNOTIFYWND	MSACM_GetNotifyWnd (HACMDRIVERID hDriver) DECLSPEC_HIDDEN
PWINE_ACMOBJ	MSACM_GetObj (HACMOBJ hObj, DWORD type) DECLSPEC_HIDDEN
MMRESULT	MSACM_Message (HACMDRIVER, UINT, LPARAM, LPARAM) DECLSPEC_HIDDEN
BOOL	MSACM_FindFormatTagInCache (const WINE_ACMDRIVERID *, DWORD, LPDWORD) DECLSPEC_HIDDEN
void	MSACM_RePositionDriver (PWINE_ACMDRIVERID, DWORD) DECLSPEC_HIDDEN
void	MSACM_WriteCurrentPriorities (void) DECLSPEC_HIDDEN
void	MSACM_BroadcastNotification (void) DECLSPEC_HIDDEN
void	MSACM_DisableNotifications (void) DECLSPEC_HIDDEN
void	MSACM_EnableNotifications (void) DECLSPEC_HIDDEN
PWINE_ACMNOTIFYWND	MSACM_RegisterNotificationWindow (HWND hNotifyWnd, DWORD dwNotifyMsg) DECLSPEC_HIDDEN
PWINE_ACMNOTIFYWND	MSACM_UnRegisterNotificationWindow (const WINE_ACMNOTIFYWND *) DECLSPEC_HIDDEN
PWINE_ACMDRIVERID	MSACM_RegisterDriverFromRegistry (LPCWSTR pszRegEntry) DECLSPEC_HIDDEN
PWINE_ACMLOCALDRIVER	MSACM_RegisterLocalDriver (HMODULE hModule, DRIVERPROC lpDriverProc) DECLSPEC_HIDDEN
PWINE_ACMLOCALDRIVERINST	MSACM_OpenLocalDriver (PWINE_ACMLOCALDRIVER, LPARAM) DECLSPEC_HIDDEN
LRESULT	MSACM_CloseLocalDriver (PWINE_ACMLOCALDRIVERINST) DECLSPEC_HIDDEN
LRESULT CALLBACK	PCM_DriverProc (DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, LPARAM dwParam1, LPARAM dwParam2) DECLSPEC_HIDDEN

Variables
HANDLE MSACM_hHeap	DECLSPEC_HIDDEN

Macro Definition Documentation

WINE_ACMOBJ_DONTCARE

#define WINE_ACMOBJ_DONTCARE   0x5EED0000

Definition at line 35 of file wineacm.h.

WINE_ACMOBJ_DRIVER

#define WINE_ACMOBJ_DRIVER   0x5EED0002

Definition at line 37 of file wineacm.h.

WINE_ACMOBJ_DRIVERID

#define WINE_ACMOBJ_DRIVERID   0x5EED0001

Definition at line 36 of file wineacm.h.

WINE_ACMOBJ_LOCALDRIVER

#define WINE_ACMOBJ_LOCALDRIVER   0x5EED0005

Definition at line 40 of file wineacm.h.

WINE_ACMOBJ_NOTIFYWND

#define WINE_ACMOBJ_NOTIFYWND   0x5EED0004

Definition at line 39 of file wineacm.h.

WINE_ACMOBJ_STREAM

#define WINE_ACMOBJ_STREAM   0x5EED0003

Definition at line 38 of file wineacm.h.

Typedef Documentation

PWINE_ACMDRIVER

typedef struct _WINE_ACMDRIVER* PWINE_ACMDRIVER

Definition at line 33 of file wineacm.h.

PWINE_ACMDRIVERID

typedef struct _WINE_ACMDRIVERID* PWINE_ACMDRIVERID

Definition at line 32 of file wineacm.h.

PWINE_ACMLOCALDRIVER

typedef struct _WINE_ACMLOCALDRIVER* PWINE_ACMLOCALDRIVER

Definition at line 48 of file wineacm.h.

PWINE_ACMLOCALDRIVERINST

typedef struct _WINE_ACMLOCALDRIVERINST* PWINE_ACMLOCALDRIVERINST

Definition at line 49 of file wineacm.h.

PWINE_ACMNOTIFYWND

typedef struct _WINE_ACMNOTIFYWND* PWINE_ACMNOTIFYWND

Definition at line 105 of file wineacm.h.

PWINE_ACMOBJ

typedef struct _WINE_ACMOBJ * PWINE_ACMOBJ

PWINE_ACMSTREAM

typedef struct _WINE_ACMSTREAM * PWINE_ACMSTREAM

WINE_ACMDRIVER

typedef struct _WINE_ACMDRIVER WINE_ACMDRIVER

WINE_ACMDRIVERID

typedef struct _WINE_ACMDRIVERID WINE_ACMDRIVERID

WINE_ACMLOCALDRIVER

typedef struct _WINE_ACMLOCALDRIVER WINE_ACMLOCALDRIVER

WINE_ACMLOCALDRIVERINST

typedef struct _WINE_ACMLOCALDRIVERINST WINE_ACMLOCALDRIVERINST

WINE_ACMNOTIFYWND

typedef struct _WINE_ACMNOTIFYWND WINE_ACMNOTIFYWND

WINE_ACMOBJ

typedef struct _WINE_ACMOBJ WINE_ACMOBJ

WINE_ACMSTREAM

typedef struct _WINE_ACMSTREAM WINE_ACMSTREAM

Function Documentation

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_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_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_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_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_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_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_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().

PCM_DriverProc()

LRESULT CALLBACK PCM_DriverProc	(	DWORD_PTR	dwDevID,
		HDRVR	hDriv,
		UINT	wMsg,
		LPARAM	dwParam1,
		LPARAM	dwParam2
	)

Definition at line 1325 of file pcmconverter.c.

{
    TRACE("(%08lx %p %u %08lx %08lx);\n",
          dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 
    switch (wMsg) {
    case DRV_LOAD:      return 1;
    case DRV_FREE:      return 1;
    case DRV_OPEN:      return PCM_drvOpen((LPSTR)dwParam1, (PACMDRVOPENDESCW)dwParam2);
    case DRV_CLOSE:     return PCM_drvClose(dwDevID);
    case DRV_ENABLE:        return 1;
    case DRV_DISABLE:       return 1;
    case DRV_QUERYCONFIGURE:    return 1;
    case DRV_CONFIGURE:     MessageBoxA(0, "MSACM PCM filter !", "Wine Driver", MB_OK); return 1;
    case DRV_INSTALL:       return DRVCNF_RESTART;
    case DRV_REMOVE:        return DRVCNF_RESTART;
 
    case ACMDM_DRIVER_NOTIFY:
    /* no caching from other ACM drivers is done so far */
    return MMSYSERR_NOERROR;
 
    case ACMDM_DRIVER_DETAILS:
    return PCM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
 
    case ACMDM_FORMATTAG_DETAILS:
    return PCM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
 
    case ACMDM_FORMAT_DETAILS:
    return PCM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
 
    case ACMDM_FORMAT_SUGGEST:
    return PCM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
 
    case ACMDM_STREAM_OPEN:
    return PCM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
 
    case ACMDM_STREAM_CLOSE:
    return PCM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
 
    case ACMDM_STREAM_SIZE:
    return PCM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
 
    case ACMDM_STREAM_CONVERT:
    return PCM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
 
    case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
    case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
    /* this converter is not a hardware driver */
    case ACMDM_FILTERTAG_DETAILS:
    case ACMDM_FILTER_DETAILS:
    /* this converter is not a filter */
    case ACMDM_STREAM_RESET:
    /* only needed for asynchronous driver... we aren't, so just say it */
    case ACMDM_STREAM_PREPARE:
    case ACMDM_STREAM_UNPREPARE:
    /* nothing special to do here... so don't do anything */
    return MMSYSERR_NOTSUPPORTED;
 
    default:
    return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
    }
}

Variable Documentation

DECLSPEC_HIDDEN

HINSTANCE MSACM_hInstance32 DECLSPEC_HIDDEN

extern

Definition at line 118 of file wineacm.h.