TnbMixerVolume.h

[詳解]

#pragma once
#include "TnbDef.h"
#include <mmsystem.h>
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CMixerVolume : CCopyImpossible
{
public:
 
    CMixerVolume(void) : m_hMix(NULL), m_result(MMSYSERR_NOERROR)
    {
    }
 
    ~CMixerVolume(void)
    {
        Close();
    }
 
    void Close(void)
    {
        if ( m_hMix != NULL )
        {
            HMIXER h = reinterpret_cast<HMIXER>(m_hMix);
            ::mixerClose(h);
            m_hMix = NULL;
        }
    }
 
    bool Open(UINT mxid = 0, HWND hCallbackWnd = NULL)
    {
        Close();
        HMIXER h = NULL;
        DWORD dwCallback = reinterpret_cast<DWORD>(hCallbackWnd);
        DWORD dwFlag = MIXER_OBJECTF_MIXER;
        if ( dwCallback != 0 )
        {
            dwFlag |= CALLBACK_WINDOW;
        }
        if ( m_res(::mixerOpen(&h, mxid, dwCallback, 0, dwFlag)) )
        {
            m_hMix = reinterpret_cast<HMIXEROBJ>(h);
            Zero(m_mixerLine);
            m_mixerLine.cbStruct = sizeof(MIXERLINE);
            if ( m_res(::mixerGetLineInfo(m_hMix, &m_mixerLine, MIXER_GETLINEINFOF_DESTINATION | MIXER_OBJECTF_HMIXER)) )
            {
                return true;
            }
        }
        Close();
        return false;
    }
 
    LPCTSTR GetDeviceName(void)
    {
        return (m_hMix == NULL) ? NULL : m_mixerLine.Target.szPname;
    }
 
    size_t GetLinesNumber(void) const
    {
        return (m_hMix == NULL) ? 0 : m_mixerLine.cConnections;
    }
 
    struct TParam
    {
        TCHAR   szLineName[MIXER_LONG_NAME_CHARS];      
        DWORD   componentType;                          
        TCHAR   szVolumeName[MIXER_LONG_NAME_CHARS];    
        DWORD   left;                                   
        DWORD   right;                                  
        DWORD   minimum;                                
        DWORD   maximum;                                
        TCHAR   szMuteName[MIXER_LONG_NAME_CHARS];      
        bool    isMute;                                 
    };
 
    bool GetMasterVolume(TParam& _prm) const
    {
        return GetComponentTypeVolume(_prm, MIXERLINE_COMPONENTTYPE_DST_SPEAKERS);
    }
 
    bool GetLineVolume(TParam& _prm, size_t line) const
    {
        if ( line == INVALID_INDEX ) { return GetMasterVolume(_prm); }
        Zero(_prm);
        return m_LineParam(_prm, line, 0, true);
    }
 
    bool GetComponentTypeVolume(TParam& _prm, DWORD componentType) const
    {
        Zero(_prm);
        return m_LineParam(_prm, 0, componentType, true);
    }
 
    bool SetMasterVolume(DWORD left, DWORD right, bool isMute = false)
    {
        return SetComponentTypeVolume(MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, left, right, isMute);
    }
 
    bool SetLineVolume(size_t line, DWORD left, DWORD right, bool isMute = false)
    {
        if ( line == INVALID_INDEX ) { return SetMasterVolume(left, right, isMute); }
        TParam p = { 0 };
        p.left = left;
        p.right = right;
        p.isMute = isMute;
        return m_LineParam(p, line, 0, false);
    }
 
    bool SetComponentTypeVolume(DWORD componentType, DWORD left, DWORD right, bool isMute = false)
    {
        TParam p = { 0 };
        p.left = left;
        p.right = right;
        p.isMute = isMute;
        return m_LineParam(p, 0, componentType, false);
    }
 
    MMRESULT GetLastError(void) const
    {
        return m_result;
    }
    
    static size_t GetDevicesNumber(void)
    {
        return ::mixerGetNumDevs();
    }
 
private:
 
    bool m_LineParam(TParam& _prm, size_t line, DWORD compType, bool isGet) const
    {
        if ( m_hMix == NULL )
        {
            m_res(MMSYSERR_ERROR);
            return false;
        }
        MIXERLINE ml = { 0 };
        ml.cbStruct = sizeof(MIXERLINE);
        DWORD info = MIXER_OBJECTF_HMIXER;
        if ( compType != 0 )
        {
            ml.dwComponentType = compType;
            info |= MIXER_GETLINEINFOF_COMPONENTTYPE;
        }
        else
        {
            ml.dwSource = line;
            info |= MIXER_GETLINEINFOF_SOURCE;
        }
        if ( ! m_res(::mixerGetLineInfo(m_hMix, &ml, info)) )
        {
            return false;
        }
        MemCopy(_prm.szLineName, ml.szName, MIXER_LONG_NAME_CHARS);
        _prm.componentType = ml.dwComponentType;
        CWorkMemT<MIXERCONTROL> amc(ml.cControls);
        loop ( i, ml.cControls )
        {
            amc[i].cbStruct = sizeof(MIXERCONTROL);
        }
        MIXERLINECONTROLS mlc = { 0 };
        mlc.cbStruct = sizeof(mlc);
        mlc.dwLineID = ml.dwLineID;
        mlc.cControls = ml.cControls;
        mlc.cbmxctrl = sizeof(MIXERCONTROL);
        mlc.pamxctrl = amc;
        if ( ! m_res(::mixerGetLineControls(m_hMix, &mlc, MIXER_GETLINECONTROLSF_ALL | MIXER_OBJECTF_HMIXER)) )
        {
            return false;
        }
        loop ( i, ml.cControls )
        {
            MIXERCONTROL* P = &amc[i];
            MIXERCONTROLDETAILS mcd = { 0 };
            mcd.cMultipleItems = P->cMultipleItems;
            if ( (P->fdwControl & MIXERCONTROL_CONTROLF_MULTIPLE) == 0 )
            {
                mcd.cMultipleItems = 0;
            }
            mcd.cChannels = ml.cChannels;
            if ( (P->fdwControl & MIXERCONTROL_CONTROLF_UNIFORM) != 0 )
            {
                mcd.cChannels = 1;
            }
            MIXERCONTROLDETAILS_BOOLEAN bn = { 0 };
            MIXERCONTROLDETAILS_UNSIGNED us[2] = { 0 };
            if ( P->dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME )
            {
                mcd.paDetails = us;
                mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
                us[0].dwValue = _prm.left;
                us[1].dwValue = _prm.right;
            }
            else if ( P->dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE )
            {
                mcd.paDetails = &bn;
                mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
                mcd.cChannels = 1;
                bn.fValue = _prm.isMute;
            }
            else
            {
                continue;
            }
            mcd.dwControlID = P->dwControlID;
            mcd.cbStruct = sizeof(mcd);
            //
            if ( isGet )
            {
                if ( ! m_res(::mixerGetControlDetails(m_hMix, &mcd, MIXER_GETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER)) )
                {
                    return false;
                }
                if ( P->dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME )
                {
                    MemCopy(_prm.szVolumeName, P->szName, MIXER_LONG_NAME_CHARS);
                    _prm.left = us[0].dwValue;
                    _prm.right = us[1].dwValue;
                    if ( ml.cChannels == 1 )
                    {
                        _prm.right = DWORD_MAX;
                    }
                    _prm.minimum = P->Bounds.dwMinimum;
                    _prm.maximum = P->Bounds.dwMaximum;
                }
                else if ( P->dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE )
                {
                    MemCopy(_prm.szMuteName, P->szName, MIXER_LONG_NAME_CHARS);
                    _prm.isMute = !! bn.fValue;
                }
            }
            else
            {
                if ( ! m_res(::mixerSetControlDetails(m_hMix, &mcd, MIXER_SETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER)) )
                {
                    return false;
                }
            }
        }
        return true;
    }
    bool m_res(MMRESULT r) const
    {
        m_result = r;
        return r == MMSYSERR_NOERROR;
    }
    HMIXEROBJ           m_hMix;         
    mutable MMRESULT    m_result;       
    MIXERLINE           m_mixerLine;    
};
 
 
 
}; // TNB