driver.c File Reference

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

Include dependency graph for driver.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msacm)
MMRESULT WINAPI	acmDriverAddA (PHACMDRIVERID phadid, HINSTANCE hinstModule, LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
MMRESULT WINAPI	acmDriverAddW (PHACMDRIVERID phadid, HINSTANCE hinstModule, LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
MMRESULT WINAPI	acmDriverClose (HACMDRIVER had, DWORD fdwClose)
MMRESULT WINAPI	acmDriverDetailsA (HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
MMRESULT WINAPI	acmDriverDetailsW (HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
MMRESULT WINAPI	acmDriverEnum (ACMDRIVERENUMCB fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
MMRESULT WINAPI	acmDriverID (HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
LRESULT WINAPI	acmDriverMessage (HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
MMRESULT WINAPI	acmDriverOpen (PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
MMRESULT WINAPI	acmDriverPriority (HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
MMRESULT WINAPI	acmDriverRemove (HACMDRIVERID hadid, DWORD fdwRemove)

Function Documentation

acmDriverAddA()

MMRESULT WINAPI acmDriverAddA	(	PHACMDRIVERID	phadid,
		HINSTANCE	hinstModule,
		LPARAM	lParam,
		DWORD	dwPriority,
		DWORD	fdwAdd
	)

Definition at line 45 of file driver.c.

{
    MMRESULT resultW;
    WCHAR * driverW = NULL;
    LPARAM lParamW = lParam;
 
    TRACE("(%p, %p, %08lx, %08x, %08x)\n",
          phadid, hinstModule, lParam, dwPriority, fdwAdd);
 
    if (!phadid) {
        WARN("invalid parameter\n");
    return MMSYSERR_INVALPARAM;
    }
 
    /* Check if any unknown flags */
    if (fdwAdd &
    ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
      ACM_DRIVERADDF_GLOBAL)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    /* Check if any incompatible flags */
    if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
    (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    /* A->W translation of name */
    if ((fdwAdd & ACM_DRIVERADDF_TYPEMASK) == ACM_DRIVERADDF_NAME) {
        INT len;
 
        if (lParam == 0) return MMSYSERR_INVALPARAM;
        len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, NULL, 0);
        driverW = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
        if (!driverW) return MMSYSERR_NOMEM;
        MultiByteToWideChar(CP_ACP, 0, (LPSTR)lParam, -1, driverW, len);
        lParamW = (LPARAM)driverW;
    }
 
    resultW = acmDriverAddW(phadid, hinstModule, lParamW, dwPriority, fdwAdd);
    HeapFree(MSACM_hHeap, 0, driverW);
    return resultW;
}

Referenced by test_acmDriverAdd().

acmDriverAddW()

MMRESULT WINAPI acmDriverAddW	(	PHACMDRIVERID	phadid,
		HINSTANCE	hinstModule,
		LPARAM	lParam,
		DWORD	dwPriority,
		DWORD	fdwAdd
	)

Definition at line 96 of file driver.c.

{
    PWINE_ACMLOCALDRIVER pLocalDrv = NULL;
 
    TRACE("(%p, %p, %08lx, %08x, %08x)\n",
          phadid, hinstModule, lParam, dwPriority, fdwAdd);
 
    if (!phadid) {
        WARN("invalid parameter\n");
    return MMSYSERR_INVALPARAM;
    }
 
    /* Check if any unknown flags */
    if (fdwAdd &
    ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
      ACM_DRIVERADDF_GLOBAL)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    /* Check if any incompatible flags */
    if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
    (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    switch (fdwAdd & ACM_DRIVERADDF_TYPEMASK) {
    case ACM_DRIVERADDF_NAME:
        /*
                hInstModule     (unused)
                lParam          name of value in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Drivers32
                dwPriority      (unused, set to 0)
         */
        *phadid = (HACMDRIVERID) MSACM_RegisterDriverFromRegistry((LPCWSTR)lParam);        
        if (!*phadid) {
            ERR("Unable to register driver via ACM_DRIVERADDF_NAME\n");
            return MMSYSERR_INVALPARAM;
        }
        break;
    case ACM_DRIVERADDF_FUNCTION:
        /*
                hInstModule     Handle of module which contains driver entry proc
                lParam          Driver function address
                dwPriority      (unused, set to 0)
         */
        fdwAdd &= ~ACM_DRIVERADDF_TYPEMASK;
        /* FIXME: fdwAdd ignored */
        /* Application-supplied acmDriverProc's are placed at the top of the priority unless
           fdwAdd indicates ACM_DRIVERADDF_GLOBAL
         */
        pLocalDrv = MSACM_RegisterLocalDriver(hinstModule, (DRIVERPROC)lParam);
        *phadid = pLocalDrv ? (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pLocalDrv) : NULL;
        if (!*phadid) {
            ERR("Unable to register driver via ACM_DRIVERADDF_FUNCTION\n");
            return MMSYSERR_INVALPARAM;
        }
        break;
    case ACM_DRIVERADDF_NOTIFYHWND:
        /*
                hInstModule     (unused)
                lParam          Handle of notification window
                dwPriority      Window message to send for notification broadcasts
         */
        *phadid = (HACMDRIVERID) MSACM_RegisterNotificationWindow((HWND)lParam, dwPriority);
        if (!*phadid) {
            ERR("Unable to register driver via ACM_DRIVERADDF_NOTIFYHWND\n");
            return MMSYSERR_INVALPARAM;
        }
        break;
    default:
        ERR("invalid flag value 0x%08x for fdwAdd\n", fdwAdd);
        return MMSYSERR_INVALFLAG;
    }
 
    MSACM_BroadcastNotification();
    return MMSYSERR_NOERROR;
}

Referenced by acmDriverAddA().

acmDriverClose()

MMRESULT WINAPI acmDriverClose	(	HACMDRIVER	had,
		DWORD	fdwClose
	)

Definition at line 179 of file driver.c.

{
    PWINE_ACMDRIVER pad;
    PWINE_ACMDRIVERID   padid;
    PWINE_ACMDRIVER*    tpad;
 
    TRACE("(%p, %08x)\n", had, fdwClose);
 
    if (fdwClose) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    pad = MSACM_GetDriver(had);
    if (!pad) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
 
    padid = pad->obj.pACMDriverID;
 
    /* remove driver from list */
    for (tpad = &(padid->pACMDriverList); *tpad; tpad = &((*tpad)->pNextACMDriver)) {
    if (*tpad == pad) {
        *tpad = (*tpad)->pNextACMDriver;
        break;
    }
    }
 
    /* close driver if it has been opened */
    if (pad->hDrvr && !pad->pLocalDrvrInst)
    CloseDriver(pad->hDrvr, 0, 0);
    else if (pad->pLocalDrvrInst)
        MSACM_CloseLocalDriver(pad->pLocalDrvrInst);
 
    pad->obj.dwType = 0;
    HeapFree(MSACM_hHeap, 0, pad);
 
    return MMSYSERR_NOERROR;
}

Referenced by acmDriverDetailsW(), acmDriverMessage(), acmFilterDetailsW(), acmFilterEnumW(), acmFilterTagDetailsW(), acmFilterTagEnumW(), acmFormatDetailsW(), acmFormatEnumW(), acmFormatSuggest(), acmFormatTagDetailsW(), acmFormatTagEnumW(), acmStreamClose(), acmStreamOpen(), DriverEnumProc(), FormatEnumProc(), MSACM_FillCache(), MSACM_FillFormatTagsCB(), and MSACM_UnregisterDriver().

acmDriverDetailsA()

MMRESULT WINAPI acmDriverDetailsA	(	HACMDRIVERID	hadid,
		PACMDRIVERDETAILSA	padd,
		DWORD	fdwDetails
	)

Definition at line 223 of file driver.c.

{
    MMRESULT mmr;
    ACMDRIVERDETAILSW   addw;
 
    TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
 
    if (!padd) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    if (padd->cbStruct < 4) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    addw.cbStruct = sizeof(addw);
    mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
    if (mmr == 0) {
        ACMDRIVERDETAILSA padda;
 
        padda.fccType = addw.fccType;
        padda.fccComp = addw.fccComp;
        padda.wMid = addw.wMid;
        padda.wPid = addw.wPid;
        padda.vdwACM = addw.vdwACM;
        padda.vdwDriver = addw.vdwDriver;
        padda.fdwSupport = addw.fdwSupport;
        padda.cFormatTags = addw.cFormatTags;
        padda.cFilterTags = addw.cFilterTags;
        padda.hicon = addw.hicon;
        WideCharToMultiByte( CP_ACP, 0, addw.szShortName, -1, padda.szShortName,
                             sizeof(padda.szShortName), NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, addw.szLongName, -1, padda.szLongName,
                             sizeof(padda.szLongName), NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, addw.szCopyright, -1, padda.szCopyright,
                             sizeof(padda.szCopyright), NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, addw.szLicensing, -1, padda.szLicensing,
                             sizeof(padda.szLicensing), NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, addw.szFeatures, -1, padda.szFeatures,
                             sizeof(padda.szFeatures), NULL, NULL );
        padda.cbStruct = min(padd->cbStruct, sizeof(*padd));
        memcpy(padd, &padda, padda.cbStruct);
    }
    return mmr;
}

Referenced by DriverEnumProc(), and test_acmDriverAdd().

acmDriverDetailsW()

MMRESULT WINAPI acmDriverDetailsW	(	HACMDRIVERID	hadid,
		PACMDRIVERDETAILSW	padd,
		DWORD	fdwDetails
	)

Definition at line 274 of file driver.c.

{
    HACMDRIVER acmDrvr;
    MMRESULT mmr;
 
    TRACE("(%p, %p, %08x)\n", hadid, padd, fdwDetails);
 
    if (!padd) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    if (padd->cbStruct < 4) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    if (fdwDetails) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    mmr = acmDriverOpen(&acmDrvr, hadid, 0);
    if (mmr == MMSYSERR_NOERROR) {
        ACMDRIVERDETAILSW paddw;
        paddw.cbStruct = sizeof(paddw);
        mmr = MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)&paddw,  0);
 
    acmDriverClose(acmDrvr, 0);
        paddw.cbStruct = min(padd->cbStruct, sizeof(*padd));
        memcpy(padd, &paddw, paddw.cbStruct);
    }
    else if (mmr == MMSYSERR_NODRIVER)
        return MMSYSERR_NOTSUPPORTED;
 
    return mmr;
}

Referenced by acmDriverDetailsA().

acmDriverEnum()

MMRESULT WINAPI acmDriverEnum	(	ACMDRIVERENUMCB	fnCallback,
		DWORD_PTR	dwInstance,
		DWORD	fdwEnum
	)

Definition at line 315 of file driver.c.

{
    PWINE_ACMDRIVERID   padid;
    DWORD       fdwSupport;
 
    TRACE("(%p, %08lx, %08x)\n", fnCallback, dwInstance, fdwEnum);
 
    if (!fnCallback) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    if (fdwEnum & ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
    fdwSupport = padid->fdwSupport;
 
    if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
        if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
        fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
        else
        continue;
    }
    if (!(*fnCallback)((HACMDRIVERID)padid, dwInstance, fdwSupport))
        break;
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by driver_tests().

acmDriverID()

MMRESULT WINAPI acmDriverID	(	HACMOBJ	hao,
		PHACMDRIVERID	phadid,
		DWORD	fdwDriverID
	)

Definition at line 352 of file driver.c.

{
    PWINE_ACMOBJ pao;
 
    TRACE("(%p, %p, %08x)\n", hao, phadid, fdwDriverID);
 
    if (fdwDriverID) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
    if (!pao) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
 
    if (!phadid) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    *phadid = (HACMDRIVERID) pao->pACMDriverID;
 
    return MMSYSERR_NOERROR;
}

Referenced by acmFilterEnumW(), acmFormatEnumW(), acmFormatTagEnumW(), and DriverEnumProc().

acmDriverMessage()

LRESULT WINAPI acmDriverMessage	(	HACMDRIVER	had,
		UINT	uMsg,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 392 of file driver.c.

{
    TRACE("(%p, %04x, %08lx, %08lx\n", had, uMsg, lParam1, lParam2);
 
    if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
    uMsg == ACMDM_DRIVER_ABOUT ||
    uMsg == DRV_QUERYCONFIGURE ||
    uMsg == DRV_CONFIGURE)
    {
        PWINE_ACMDRIVERID padid;
        LRESULT lResult;
        LPDRVCONFIGINFO pConfigInfo = NULL;
        LPWSTR section_name = NULL;
        LPWSTR alias_name = NULL;
 
        /* Check whether handle is an HACMDRIVERID */
        padid  = MSACM_GetDriverID((HACMDRIVERID)had);
        
        /* If the message is DRV_CONFIGURE, and the application provides no
           DRVCONFIGINFO structure, msacm must supply its own.
         */
        if (uMsg == DRV_CONFIGURE && lParam2 == 0) {
            LPWSTR pAlias;
            
            /* Get the alias from the HACMDRIVERID */
            if (padid) {
                pAlias = padid->pszDriverAlias;
                if (pAlias == NULL) {
                    WARN("DRV_CONFIGURE: no alias for this driver, cannot self-supply alias\n");
                }
            } else {
                FIXME("DRV_CONFIGURE: reverse lookup HACMDRIVER -> HACMDRIVERID not implemented\n");
                pAlias = NULL;
            }
        
            if (pAlias != NULL) {
                /* DRVCONFIGINFO is only 12 bytes long, but native msacm
                 * reports a 16-byte structure to codecs, so allocate 16 bytes,
                 * just to be on the safe side.
                 */
                const unsigned int iStructSize = 16;
                pConfigInfo = HeapAlloc(MSACM_hHeap, 0, iStructSize);
                if (!pConfigInfo) {
                    ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
                } else {
                    static const WCHAR drivers32[] = {'D','r','i','v','e','r','s','3','2','\0'};
 
                    pConfigInfo->dwDCISize = iStructSize;
 
                    section_name = HeapAlloc(MSACM_hHeap, 0, (lstrlenW(drivers32) + 1) * sizeof(WCHAR));
                    if (section_name) lstrcpyW(section_name, drivers32);
                    pConfigInfo->lpszDCISectionName = section_name;
                    alias_name = HeapAlloc(MSACM_hHeap, 0, (lstrlenW(pAlias) + 1) * sizeof(WCHAR));
                    if (alias_name) lstrcpyW(alias_name, pAlias);
                    pConfigInfo->lpszDCIAliasName = alias_name;
 
                    if (pConfigInfo->lpszDCISectionName == NULL || pConfigInfo->lpszDCIAliasName == NULL) {
                        HeapFree(MSACM_hHeap, 0, alias_name);
                        HeapFree(MSACM_hHeap, 0, section_name);
                        HeapFree(MSACM_hHeap, 0, pConfigInfo);
                        pConfigInfo = NULL;
                        ERR("OOM while supplying DRVCONFIGINFO for DRV_CONFIGURE, using NULL\n");
                    }
                }
            }
            
            lParam2 = (LPARAM)pConfigInfo;
        }
        
        if (padid) {
            /* Handle is really an HACMDRIVERID, must have an open session to get an HACMDRIVER */
            if (padid->pACMDriverList != NULL) {
                lResult = MSACM_Message((HACMDRIVER)padid->pACMDriverList, uMsg, lParam1, lParam2);
            } else {
                MMRESULT mmr = acmDriverOpen(&had, (HACMDRIVERID)padid, 0);
                if (mmr != MMSYSERR_NOERROR) {
                    lResult = MMSYSERR_INVALPARAM;
                } else {
                    lResult = acmDriverMessage(had, uMsg, lParam1, lParam2);
                    acmDriverClose(had, 0);
                }
            }
        } else {
            lResult = MSACM_Message(had, uMsg, lParam1, lParam2);
        }
        if (pConfigInfo) {
            HeapFree(MSACM_hHeap, 0, alias_name);
            HeapFree(MSACM_hHeap, 0, section_name);
            HeapFree(MSACM_hHeap, 0, pConfigInfo);
        }
        return lResult;
    }
    WARN("invalid parameter\n");
    return MMSYSERR_INVALPARAM;
}

Referenced by acmDriverMessage().

acmDriverOpen()

MMRESULT WINAPI acmDriverOpen	(	PHACMDRIVER	phad,
		HACMDRIVERID	hadid,
		DWORD	fdwOpen
	)

Definition at line 491 of file driver.c.

{
    PWINE_ACMDRIVERID   padid;
    PWINE_ACMDRIVER pad = NULL;
    MMRESULT        ret;
 
    TRACE("(%p, %p, %08u)\n", phad, hadid, fdwOpen);
 
    if (!phad) {
        WARN("invalid parameter\n");
    return MMSYSERR_INVALPARAM;
    }
 
    if (fdwOpen) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    padid = MSACM_GetDriverID(hadid);
    if (!padid) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
 
    pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
    if (!pad) {
        WARN("no memory\n");
        return MMSYSERR_NOMEM;
    }
 
    pad->obj.dwType = WINE_ACMOBJ_DRIVER;
    pad->obj.pACMDriverID = padid;
    pad->hDrvr = 0;
    pad->pLocalDrvrInst = NULL;
 
    if (padid->pLocalDriver == NULL)
    {
        ACMDRVOPENDESCW adod;
        int     len;
        LPWSTR      section_name;
 
    /* this is not an externally added driver... need to actually load it */
    if (!padid->pszDriverAlias)
        {
            ret = MMSYSERR_ERROR;
            goto gotError;
        }
 
        adod.cbStruct = sizeof(adod);
        adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
        adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
        adod.dwVersion = acmGetVersion();
        adod.dwFlags = fdwOpen;
        adod.dwError = 0;
        len = strlen("Drivers32") + 1;
        section_name = HeapAlloc(MSACM_hHeap, 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, "Drivers32", -1, section_name, len);
        adod.pszSectionName = section_name;
        adod.pszAliasName = padid->pszDriverAlias;
        adod.dnDevNode = 0;
 
        pad->hDrvr = OpenDriver(padid->pszDriverAlias, NULL, (DWORD_PTR)&adod);
 
        HeapFree(MSACM_hHeap, 0, section_name);
        if (!pad->hDrvr)
        {
            ret = adod.dwError;
            if (ret == MMSYSERR_NOERROR)
                ret = MMSYSERR_NODRIVER;
            goto gotError;
        }
    }
    else
    {
        ACMDRVOPENDESCW adod;
 
        pad->hDrvr = NULL;
 
        adod.cbStruct = sizeof(adod);
        adod.fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
        adod.fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
        adod.dwVersion = acmGetVersion();
        adod.dwFlags = fdwOpen;
        adod.dwError = 0;
        adod.pszSectionName = NULL;
        adod.pszAliasName = NULL;
        adod.dnDevNode = 0;
 
        pad->pLocalDrvrInst = MSACM_OpenLocalDriver(padid->pLocalDriver, (DWORD_PTR)&adod);
        if (!pad->pLocalDrvrInst)
        {
            ret = adod.dwError;
            if (ret == MMSYSERR_NOERROR)
                ret = MMSYSERR_NODRIVER;
            goto gotError;
        }
    }
 
    /* insert new pad at beg of list */
    pad->pNextACMDriver = padid->pACMDriverList;
    padid->pACMDriverList = pad;
 
    /* FIXME: Create a WINE_ACMDRIVER32 */
    *phad = (HACMDRIVER)pad;
    TRACE("%s => %p\n", debugstr_w(padid->pszDriverAlias), pad);
 
    return MMSYSERR_NOERROR;
 gotError:
    WARN("failed: ret = %08x\n", ret);
    HeapFree(MSACM_hHeap, 0, pad);
    return ret;
}

Referenced by acmDriverDetailsW(), acmDriverMessage(), acmFilterDetailsW(), acmFilterEnumW(), acmFilterTagDetailsW(), acmFilterTagEnumW(), acmFormatDetailsW(), acmFormatEnumW(), acmFormatSuggest(), acmFormatTagDetailsW(), acmFormatTagEnumW(), acmStreamOpen(), DriverEnumProc(), FormatEnumProc(), FormatTagEnumProc(), MSACM_FillCache(), and MSACM_FillFormatTagsCB().

acmDriverPriority()

MMRESULT WINAPI acmDriverPriority	(	HACMDRIVERID	hadid,
		DWORD	dwPriority,
		DWORD	fdwPriority
	)

Definition at line 607 of file driver.c.

{
 
    TRACE("(%p, %08x, %08x)\n", hadid, dwPriority, fdwPriority);
 
    /* Check for unknown flags */
    if (fdwPriority &
    ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
      ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    /* Check for incompatible flags */
    if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
    (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    /* Check for incompatible flags */
    if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
    (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
    
    /* According to MSDN, ACM_DRIVERPRIORITYF_BEGIN and ACM_DRIVERPRIORITYF_END 
       may only appear by themselves, and in addition, hadid and dwPriority must
       both be zero */
    if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) ||
    (fdwPriority & ACM_DRIVERPRIORITYF_END)) {
    if (fdwPriority & ~(ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END)) {
        WARN("ACM_DRIVERPRIORITYF_[BEGIN|END] cannot be used with any other flags\n");
        return MMSYSERR_INVALPARAM;
    }
    if (dwPriority) {
        WARN("priority invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
        return MMSYSERR_INVALPARAM;
    }
    if (hadid) {
        WARN("non-null hadid invalid with ACM_DRIVERPRIORITYF_[BEGIN|END]\n");
        return MMSYSERR_INVALPARAM;
    }
    /* FIXME: MSDN wording suggests that deferred notification should be 
       implemented as a system-wide lock held by a calling task, and that 
       re-enabling notifications should broadcast them across all processes.
       This implementation uses a simple DWORD counter. One consequence of the
       current implementation is that applications will never see 
       MMSYSERR_ALLOCATED as a return error.
     */
    if (fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) {
        MSACM_DisableNotifications();
    } else if (fdwPriority & ACM_DRIVERPRIORITYF_END) {
        MSACM_EnableNotifications();
    }
    return MMSYSERR_NOERROR;
    } else {
        PWINE_ACMDRIVERID padid;
        PWINE_ACMNOTIFYWND panwnd;
        BOOL bPerformBroadcast = FALSE;
 
        /* Fetch driver ID */
        padid = MSACM_GetDriverID(hadid);
        panwnd = MSACM_GetNotifyWnd(hadid);
        if (!padid && !panwnd) {
            WARN("invalid handle\n");
        return MMSYSERR_INVALHANDLE;
        }
        
        if (padid) {
            /* Check whether driver ID is appropriate for requested op */
            if (dwPriority) {
                if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL) {
                    return MMSYSERR_NOTSUPPORTED;
                }
                if (dwPriority != 1 && dwPriority != (DWORD)-1) {
                    FIXME("unexpected priority %d, using sign only\n", dwPriority);
                    if ((signed)dwPriority < 0) dwPriority = (DWORD)-1;
                    if (dwPriority > 0) dwPriority = 1;
                }
                
                if (dwPriority == 1 && (padid->pPrevACMDriverID == NULL || 
                    (padid->pPrevACMDriverID->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_LOCAL))) {
                    /* do nothing - driver is first of list, or first after last
                       local driver */
                } else if (dwPriority == (DWORD)-1 && padid->pNextACMDriverID == NULL) {
                    /* do nothing - driver is last of list */
                } else {
                    MSACM_RePositionDriver(padid, dwPriority);
                    bPerformBroadcast = TRUE;
                }
            }
 
            /* Check whether driver ID should be enabled or disabled */
            if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
                if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
                    padid->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
                    bPerformBroadcast = TRUE;
                }
            } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
                if (padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
                    padid->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
                    bPerformBroadcast = TRUE;
                }
            }
        }
        
        if (panwnd) {
            if (dwPriority) {
                return MMSYSERR_NOTSUPPORTED;
            }
        
            /* Check whether notify window should be enabled or disabled */
            if (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE) {
                if (!(panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED)) {
                    panwnd->fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
                    bPerformBroadcast = TRUE;
                }
            } else if (fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) {
                if (panwnd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) {
                    panwnd->fdwSupport &= ~ACMDRIVERDETAILS_SUPPORTF_DISABLED;
                    bPerformBroadcast = TRUE;
                }
            }
        }
        
        /* Perform broadcast of changes */
        if (bPerformBroadcast) {
            MSACM_WriteCurrentPriorities();
            MSACM_BroadcastNotification();
        }
        return MMSYSERR_NOERROR;
    }
}

acmDriverRemove()

MMRESULT WINAPI acmDriverRemove	(	HACMDRIVERID	hadid,
		DWORD	fdwRemove
	)

Definition at line 746 of file driver.c.

{
    PWINE_ACMDRIVERID padid;
    PWINE_ACMNOTIFYWND panwnd;
 
    TRACE("(%p, %08x)\n", hadid, fdwRemove);
 
    padid = MSACM_GetDriverID(hadid);
    panwnd = MSACM_GetNotifyWnd(hadid);
    if (!padid && !panwnd) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
 
    if (fdwRemove) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    if (padid) MSACM_UnregisterDriver(padid);
    if (panwnd) MSACM_UnRegisterNotificationWindow(panwnd);
    MSACM_BroadcastNotification();
 
    return MMSYSERR_NOERROR;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msacm

)