CMultimediaBackend Class Reference

#include <mediabtns.h>

Collaboration diagram for CMultimediaBackend:

Public Member Functions
	CMultimediaBackend ()
	~CMultimediaBackend ()
	CMultimediaBackend (CMultimediaBackend &)=delete
	CMultimediaBackend (CMultimediaBackend &&)=delete
CMultimediaBackend &	operator= (CMultimediaBackend &)=delete
CMultimediaBackend &	operator= (CMultimediaBackend &&)=delete
void	Initialize ()
bool	Mute ()
bool	AdjustVolume (_In_ UINT direction, _In_ HANDLE hProcessHeap)

Private Member Functions
void	CalculateSteps (_Inout_ PMIXERCONTROLDETAILS_UNSIGNED pmxcdVolume)
void	LogError (_In_ const char *pszFunctionName, _In_ const char *pszMessage, _In_ MMRESULT mmres)
MMRESULT	GetCurrentVolume (_Inout_ PMIXERCONTROLDETAILS pmxcd)

Private Attributes
pmxControlDetails	mixerSetControlDetails
pmxControlDetails	mixerGetControlDetailsW
pmxGetID	mixerGetID
pmxLine	mixerGetLineInfoW
pmxLineControls	mixerGetLineControlsW
pmxOpen	mixerOpen
pmxClose	mixerClose
pwoGetErrText	waveOutGetErrorTextW
pwoGetNumDevs	waveOutGetNumDevs
pwoMessage	waveOutMessage
HMODULE	m_hWinMM
HMIXER	m_hMixer = NULL
DWORD	m_dwMasterMuteControlID
DWORD	m_dwMasterVolumeID
DWORD	m_dwMasterChannels
struct {
DWORD   dwMinimum
DWORD   dwMaximum
}	m_dwMasterRanges
PDWORD	m_pdwChannelSteps = NULL

Detailed Description

Definition at line 24 of file mediabtns.h.

Constructor & Destructor Documentation

CMultimediaBackend() [1/3]

CMultimediaBackend::CMultimediaBackend

(

)

Definition at line 12 of file mediabtns.cpp.

{
    HMODULE hWinMM = LoadLibraryW(L"winmm.dll");
    bool bFailedGetProcAddress = false;
 
    if (!hWinMM)
        return;
 
    bFailedGetProcAddress |= !WINMM_PROC(mixerOpen, pmxOpen);
    bFailedGetProcAddress |= !WINMM_PROC(mixerClose, pmxClose);
    bFailedGetProcAddress |= !WINMM_PROC(mixerSetControlDetails, pmxControlDetails);
    bFailedGetProcAddress |= !WINMM_PROC(mixerGetControlDetailsW, pmxControlDetails);
    bFailedGetProcAddress |= !WINMM_PROC(mixerGetID, pmxGetID);
    bFailedGetProcAddress |= !WINMM_PROC(mixerGetLineInfoW, pmxLine);
    bFailedGetProcAddress |= !WINMM_PROC(mixerGetLineControlsW, pmxLineControls);
    bFailedGetProcAddress |= !WINMM_PROC(waveOutGetErrorTextW, pwoGetErrText);
    bFailedGetProcAddress |= !WINMM_PROC(waveOutGetNumDevs, pwoGetNumDevs);
    bFailedGetProcAddress |= !WINMM_PROC(waveOutMessage, pwoMessage);
 
    if (bFailedGetProcAddress)
    {
        ERR("CMultimediaBackend::ctor: One or more entry points to WinMM functions not found\n");
        FreeLibrary(hWinMM);
        return;
    }
 
    m_hWinMM = hWinMM;
};

~CMultimediaBackend()

CMultimediaBackend::~CMultimediaBackend

(

)

Definition at line 41 of file mediabtns.cpp.

{
    if (m_hMixer)
        mixerClose(m_hMixer);
 
    HeapFree(hProcessHeap, 0, m_pdwChannelSteps);
 
    FreeLibrary(m_hWinMM);
}

CMultimediaBackend() [2/3]

CMultimediaBackend::CMultimediaBackend ( CMultimediaBackend &  )

delete

CMultimediaBackend() [3/3]

CMultimediaBackend::CMultimediaBackend ( CMultimediaBackend &&  )

delete

Member Function Documentation

AdjustVolume()

bool CMultimediaBackend::AdjustVolume	(	_In_ UINT	direction,
		_In_ HANDLE	hProcessHeap
	)

Definition at line 184 of file mediabtns.cpp.

{
    if (!m_hWinMM)
    {
        WARN("CMultimediaBackend: WinMM functions unavailable; cannot %s volume. Check the prior class constructor calls\n",
             direction == APPCOMMAND_VOLUME_DOWN ? "decrease" : "increase");
        return FALSE;
    }
 
    MMRESULT mmres;
 
    MIXERCONTROLDETAILS mxcd;
    mxcd.cbStruct = sizeof(mxcd);
    mxcd.cMultipleItems = 0;
 
    /* If sound is muted and we want to increase volume, we are unmuting it. */
    if (direction == APPCOMMAND_VOLUME_UP)
    {
        MIXERCONTROLDETAILS_BOOLEAN mxcdMute;
        mxcd.cChannels = 1;
        mxcd.dwControlID = m_dwMasterMuteControlID;
        mxcd.cbDetails = sizeof(mxcdMute);
        mxcd.paDetails = &mxcdMute;
        mxcdMute.fValue = false;
 
        mmres = mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mxcd, MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE);
        if (mmres != MMSYSERR_NOERROR)
            LogError(__func__, "mixerSetControlDetails failed unmuting Master Volume", mmres);
    }
 
    if (GetCurrentVolume(&mxcd) != MMSYSERR_NOERROR)
        return FALSE;
 
    PMIXERCONTROLDETAILS_UNSIGNED mxcdVolume = (PMIXERCONTROLDETAILS_UNSIGNED)mxcd.paDetails;
 
    bool bEitherCeiling = [&]()
    {
        DWORD dwValue = m_dwMasterRanges.dwMinimum;
 
        for (DWORD i = 0; i < m_dwMasterChannels; ++i)
        {
            if (mxcdVolume[i].dwValue > dwValue)
                dwValue = mxcdVolume[i].dwValue;
        }
 
        return direction == APPCOMMAND_VOLUME_DOWN
            ? dwValue == m_dwMasterRanges.dwMinimum
            : dwValue == m_dwMasterRanges.dwMaximum;
    }();
 
    if (bEitherCeiling)
    {
        TRACE("CMultimediaBackend::AdjustVolume: Volume boundary hit, no action\n");
        goto cleanup;
    }
 
    CalculateSteps(mxcdVolume);
 
    for (DWORD i = 0; i < m_dwMasterChannels; ++i)
    {
        if (direction == APPCOMMAND_VOLUME_DOWN)
        {
            /* Protecting from underflow when decreasing volume */
            if (mxcdVolume[i].dwValue < m_pdwChannelSteps[i])
                mxcdVolume[i].dwValue = m_dwMasterRanges.dwMinimum;
            else
                mxcdVolume[i].dwValue -= m_pdwChannelSteps[i];
        }
        else if (direction == APPCOMMAND_VOLUME_UP)
        {
            /* Protecting from overflow when increasing volume */
            if (m_dwMasterRanges.dwMaximum - mxcdVolume[i].dwValue < m_pdwChannelSteps[i])
                mxcdVolume[i].dwValue = m_dwMasterRanges.dwMaximum;
            else
                mxcdVolume[i].dwValue += m_pdwChannelSteps[i];
        }
    }
 
    mmres = mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mxcd, MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE);
    if (mmres == MMSYSERR_NOERROR)
    {
        TRACE("CMultimediaBackend::AdjustVolume: Volume values were updated:\n");
        for (DWORD i = 0; i < m_dwMasterChannels; ++i)
            TRACE("    Channel %lu volume: %lu\n", i, mxcdVolume[i].dwValue);
    }
    else
    {
        LogError(__func__, "mixerSetControlDetails failed updating Master Volume control details", mmres);
    }
 
cleanup:
    HeapFree(hProcessHeap, 0, mxcdVolume);
    return TRUE;
}

Referenced by CTaskSwitchWnd::HandleAppCommand().

CalculateSteps()

void CMultimediaBackend::CalculateSteps ( _Inout_ PMIXERCONTROLDETAILS_UNSIGNED  pmxcdVolume )

private

Definition at line 280 of file mediabtns.cpp.

{
    DWORD dwHighestVolume = m_dwMasterRanges.dwMinimum;
    DWORD dwLoudestChIdx = 0;
 
    /* Find the loudest channel of all available */
    for (DWORD i = 0; i < m_dwMasterChannels; ++i)
    {
        if (pmxcdVolume[i].dwValue < dwHighestVolume)
            continue;
 
        dwLoudestChIdx = i;
        dwHighestVolume = pmxcdVolume[dwLoudestChIdx].dwValue;
    }
 
    /* Calculate steps for uneven channels */
    for (DWORD i = 0; i < m_dwMasterChannels; ++i)
    {
        /* As we rely on MIXERLINEW.cChannels, there may be a case of multiple channels having equal high volume. */
        if (dwHighestVolume == m_dwMasterRanges.dwMinimum)
        {
            TRACE("CMultimediaBackend::CalculateSteps: All channels were at minimum volume, steps will be unchanged\n");
            break;
        }
        else if (i == dwLoudestChIdx || (pmxcdVolume[i].dwValue == dwHighestVolume))
        {
            m_pdwChannelSteps[i] = (m_dwMasterRanges.dwMaximum - m_dwMasterRanges.dwMinimum) / VOLUME_STEPS_COUNT;
            TRACE("CMultimediaBackend::CalculateSteps: Channel %lu is the loudest, volume step will be %lu\n", i, m_pdwChannelSteps[i]);
        }
        else
        {
            if (dwHighestVolume > 0)
            {
                float dwStepRatio = (float)pmxcdVolume[i].dwValue / dwHighestVolume;
                m_pdwChannelSteps[i] = ceil(dwStepRatio * m_pdwChannelSteps[dwLoudestChIdx]);
            }
            else
            {
                m_pdwChannelSteps[i] = 0;
            }
            TRACE("CMultimediaBackend::CalculateSteps: Channel %lu volume step will be %lu\n", i, m_pdwChannelSteps[i]);
        }
    }
}

Referenced by AdjustVolume().

GetCurrentVolume()

MMRESULT CMultimediaBackend::GetCurrentVolume ( _Inout_ PMIXERCONTROLDETAILS  pmxcd )

private

Definition at line 334 of file mediabtns.cpp.

{
    PMIXERCONTROLDETAILS_UNSIGNED mxcdVolume =
        (PMIXERCONTROLDETAILS_UNSIGNED)HeapAlloc(hProcessHeap, 0,
                                                 m_dwMasterChannels * sizeof(*mxcdVolume));
 
    if (mxcdVolume == NULL)
    {
        ERR("CMultimediaBackend::GetCurrentVolume: HeapAlloc failed, requested %lu bytes\n", m_dwMasterChannels * sizeof(*mxcdVolume));
        return MMSYSERR_NOMEM;
    }
 
    pmxcd->cChannels = m_dwMasterChannels;
    pmxcd->dwControlID = m_dwMasterVolumeID;
    pmxcd->cbDetails = sizeof(*mxcdVolume);
    pmxcd->paDetails = mxcdVolume;
 
    return mixerGetControlDetailsW((HMIXEROBJ)m_hMixer, pmxcd, MIXER_OBJECTF_HMIXER | MIXER_GETCONTROLDETAILSF_VALUE);
}

Referenced by AdjustVolume().

Initialize()

void CMultimediaBackend::Initialize

(

)

Definition at line 52 of file mediabtns.cpp.

{
    if (m_hMixer)
        mixerClose(m_hMixer);
    m_hMixer = NULL;
 
    if (m_pdwChannelSteps != NULL)
        HeapFree(hProcessHeap, 0, m_pdwChannelSteps);
    m_pdwChannelSteps = NULL;
 
    if (waveOutGetNumDevs() == 0)
    {
        ERR("CMultimediaBackend::Initialize: No waveform-audio output devices detected\n");
        return;
    }
 
    DWORD dwWaveOutDeviceID;
    DWORD dw2 = 0;
 
    MMRESULT mmres = waveOutMessage((HWAVEOUT)UlongToHandle(WAVE_MAPPER), DRVM_MAPPER_PREFERRED_GET,
                                    (DWORD_PTR)&dwWaveOutDeviceID, (DWORD_PTR)&dw2);
    if (mmres != MMSYSERR_NOERROR)
        LogError(__func__, "waveOutMessage failed", mmres);
 
    if (dwWaveOutDeviceID == (DWORD)-1)
    {
        TRACE("CMultimediaBackend::Initialize: No default output device was assigned, falling back to the first device\n");
        dwWaveOutDeviceID = 0;
    }
 
    UINT mxID;
    mmres = mixerGetID((HMIXEROBJ)UlongToHandle(dwWaveOutDeviceID), &mxID, MIXER_OBJECTF_WAVEOUT);
    if (mmres != MMSYSERR_NOERROR)
    {
        LogError(__func__, "mixerGetID failed", mmres);
 
        if (mmres == MMSYSERR_NODRIVER)
        {
            ERR("    Not providing fallback to the first mixer device.\n");
            return;
        }
 
        mxID = 0;
    }
 
    mmres = mixerOpen(&m_hMixer, mxID, NULL, 0, MIXER_OBJECTF_MIXER);
    if (mmres != MMSYSERR_NOERROR)
    {
        m_hMixer = NULL;
        LogError(__func__, "mixerOpen failed", mmres);
        return;
    }
 
    MIXERLINEW mxln;
    mxln.cbStruct = sizeof(mxln);
    mxln.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
 
    mmres = mixerGetLineInfoW((HMIXEROBJ)m_hMixer, &mxln, MIXER_OBJECTF_HMIXER | MIXER_GETLINEINFOF_COMPONENTTYPE);
    if (mmres != MMSYSERR_NOERROR)
    {
        LogError(__func__, "mixerGetLineInfoW failed", mmres);
        return;
    }
 
    m_dwMasterChannels = mxln.cChannels;
 
    MIXERLINECONTROLS mxlctrl;
    MIXERCONTROLW mxc;
    mxlctrl.cbStruct = sizeof(mxlctrl);
    mxlctrl.dwLineID = mxln.dwLineID;
    mxlctrl.dwControlID = MIXERCONTROL_CONTROLTYPE_MUTE;
    mxlctrl.cControls = 1;
    mxlctrl.cbmxctrl = sizeof(mxc);
    mxlctrl.pamxctrl = &mxc;
 
    mmres = mixerGetLineControlsW((HMIXEROBJ)m_hMixer, &mxlctrl, MIXER_OBJECTF_HMIXER | MIXER_GETLINECONTROLSF_ONEBYTYPE);
    if (mmres != MMSYSERR_NOERROR)
    {
        LogError(__func__, "mixerGetLineControlsW failed retrieving Master Mute control", mmres);
        return;
    }
 
    m_dwMasterMuteControlID = mxc.dwControlID;
 
    mxlctrl.dwControlID = MIXERCONTROL_CONTROLTYPE_VOLUME;
 
    mmres = mixerGetLineControlsW((HMIXEROBJ)m_hMixer, &mxlctrl, MIXER_OBJECTF_HMIXER | MIXER_GETLINECONTROLSF_ONEBYTYPE);
    if (mmres != MMSYSERR_NOERROR)
    {
        LogError(__func__, "mixerGetLineControlsW failed retrieving Master Volume control", mmres);
        return;
    }
 
    m_dwMasterVolumeID = mxc.dwControlID;
    m_dwMasterRanges.dwMinimum = mxc.Bounds.dwMinimum;
    m_dwMasterRanges.dwMaximum = mxc.Bounds.dwMaximum;
 
    m_pdwChannelSteps = (PDWORD)HeapAlloc(hProcessHeap, 0, m_dwMasterChannels * sizeof(*m_pdwChannelSteps));
 
    TRACE("CMultimediaBackend::Initialize: Master controls configured successfully:\n"
          "    Master Mute dwControlID: %lu; Master Volume dwControlID %lu\n"
          "    Master Volume channels: %lu; Master Volume value range: %lu-%lu\n",
          m_dwMasterMuteControlID, m_dwMasterVolumeID,
          m_dwMasterChannels, m_dwMasterRanges.dwMinimum, m_dwMasterRanges.dwMaximum);
}

Referenced by CTaskSwitchWnd::OnCreate(), and CTaskSwitchWnd::OnWinMMDeviceChange().

LogError()

void CMultimediaBackend::LogError ( _In_ const char *  pszFunctionName, _In_ const char *  pszMessage, _In_ MMRESULT  mmres  )

private

Definition at line 326 of file mediabtns.cpp.

{
    static WCHAR pszWinMMErrText[MAXERRORLENGTH] = {0};
    waveOutGetErrorTextW(mmres, pszWinMMErrText, _countof(pszWinMMErrText));
    ERR("CMultimediaBackend::%s: %: %lu (%S)\n", pszFunctionName, pszMessage, mmres, pszWinMMErrText);
}

Mute()

bool CMultimediaBackend::Mute

(

)

Definition at line 159 of file mediabtns.cpp.

{
    if (!m_hWinMM)
    {
        WARN("CMultimediaBackend::Mute: WinMM functions unavailable; cannot (un)mute sound. Check the prior class constructor calls\n");
        return false;
    }
 
    MIXERCONTROLDETAILS mxcd;
    MIXERCONTROLDETAILS_BOOLEAN mxcdMute;
    mxcd.cbStruct = sizeof(mxcd);
    mxcd.dwControlID = m_dwMasterMuteControlID;
    mxcd.cChannels = 1;
    mxcd.cMultipleItems = 0;
    mxcd.cbDetails = sizeof(mxcdMute);
    mxcd.paDetails = &mxcdMute;
 
    mixerGetControlDetailsW((HMIXEROBJ)m_hMixer, &mxcd, MIXER_OBJECTF_HMIXER | MIXER_GETCONTROLDETAILSF_VALUE);
    mxcdMute.fValue = !mxcdMute.fValue;
    mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mxcd, MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE);
 
    return true;
}

Referenced by CTaskSwitchWnd::HandleAppCommand().

operator=() [1/2]

CMultimediaBackend & CMultimediaBackend::operator= ( CMultimediaBackend &&  )

delete

operator=() [2/2]

CMultimediaBackend & CMultimediaBackend::operator= ( CMultimediaBackend &  )

delete

Member Data Documentation

dwMaximum

DWORD CMultimediaBackend::dwMaximum

Definition at line 62 of file mediabtns.h.

dwMinimum

DWORD CMultimediaBackend::dwMinimum

Definition at line 61 of file mediabtns.h.

m_dwMasterChannels

DWORD CMultimediaBackend::m_dwMasterChannels

private

Definition at line 58 of file mediabtns.h.

Referenced by AdjustVolume(), CalculateSteps(), GetCurrentVolume(), and Initialize().

m_dwMasterMuteControlID

DWORD CMultimediaBackend::m_dwMasterMuteControlID

private

Definition at line 56 of file mediabtns.h.

Referenced by AdjustVolume(), Initialize(), and Mute().

struct { ... } CMultimediaBackend::m_dwMasterRanges

Referenced by AdjustVolume(), CalculateSteps(), and Initialize().

m_dwMasterVolumeID

DWORD CMultimediaBackend::m_dwMasterVolumeID

private

Definition at line 57 of file mediabtns.h.

Referenced by GetCurrentVolume(), and Initialize().

m_hMixer

HMIXER CMultimediaBackend::m_hMixer = NULL

private

Definition at line 55 of file mediabtns.h.

Referenced by AdjustVolume(), GetCurrentVolume(), Initialize(), Mute(), and ~CMultimediaBackend().

m_hWinMM

HMODULE CMultimediaBackend::m_hWinMM

private

Definition at line 54 of file mediabtns.h.

Referenced by AdjustVolume(), CMultimediaBackend(), Mute(), and ~CMultimediaBackend().

m_pdwChannelSteps

PDWORD CMultimediaBackend::m_pdwChannelSteps = NULL

private

Definition at line 64 of file mediabtns.h.

Referenced by AdjustVolume(), CalculateSteps(), Initialize(), and ~CMultimediaBackend().

mixerClose

pmxClose CMultimediaBackend::mixerClose

private

Definition at line 49 of file mediabtns.h.

Referenced by CMultimediaBackend(), Initialize(), and ~CMultimediaBackend().

mixerGetControlDetailsW

pmxControlDetails CMultimediaBackend::mixerGetControlDetailsW

private

Definition at line 44 of file mediabtns.h.

Referenced by CMultimediaBackend(), GetCurrentVolume(), and Mute().

mixerGetID

pmxGetID CMultimediaBackend::mixerGetID

private

Definition at line 45 of file mediabtns.h.

Referenced by CMultimediaBackend(), and Initialize().

mixerGetLineControlsW

pmxLineControls CMultimediaBackend::mixerGetLineControlsW

private

Definition at line 47 of file mediabtns.h.

Referenced by CMultimediaBackend(), and Initialize().

mixerGetLineInfoW

pmxLine CMultimediaBackend::mixerGetLineInfoW

private

Definition at line 46 of file mediabtns.h.

Referenced by CMultimediaBackend(), and Initialize().

mixerOpen

pmxOpen CMultimediaBackend::mixerOpen

private

Definition at line 48 of file mediabtns.h.

Referenced by CMultimediaBackend(), and Initialize().

mixerSetControlDetails

pmxControlDetails CMultimediaBackend::mixerSetControlDetails

private

Definition at line 43 of file mediabtns.h.

Referenced by AdjustVolume(), CMultimediaBackend(), and Mute().

waveOutGetErrorTextW

pwoGetErrText CMultimediaBackend::waveOutGetErrorTextW

private

Definition at line 50 of file mediabtns.h.

Referenced by CMultimediaBackend(), and LogError().

waveOutGetNumDevs

pwoGetNumDevs CMultimediaBackend::waveOutGetNumDevs

private

Definition at line 51 of file mediabtns.h.

Referenced by CMultimediaBackend(), and Initialize().

waveOutMessage

pwoMessage CMultimediaBackend::waveOutMessage

private

Definition at line 52 of file mediabtns.h.

Referenced by CMultimediaBackend(), and Initialize().

---

The documentation for this class was generated from the following files:

• base/shell/explorer/mediabtns.h
• base/shell/explorer/mediabtns.cpp