CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAudio/plWinMicLevel.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  plWinMicLevel - Annoying class to deal with the annoying problem of     //
//                  setting the microphone recording volume in Windows.     //
//                  Yeah, you'd THINK there'd be some easier way...         //
//                                                                          //
//// Notes ///////////////////////////////////////////////////////////////////
//                                                                          //
//  5.8.2001 - Created by mcn.                                              //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "plWinMicLevel.h"
#include "hsWindows.h"
#include <mmsystem.h>


//// Our Local Static Data ///////////////////////////////////////////////////

int         sNumMixers = 0;
HMIXER      sMixerHandle = nil;
MIXERCAPS   sMixerCaps;

DWORD       sMinValue = 0, sMaxValue = 0;
DWORD       sVolControlID = 0;


//// Local Static Helpers ////////////////////////////////////////////////////

hsBool  IGetMuxMicVolumeControl( void );
hsBool  IGetBaseMicVolumeControl( void );

hsBool  IGetControlValue( DWORD &value );
hsBool  ISetControlValue( DWORD value );

MIXERLINE       *IGetLineByType( DWORD type );
MIXERLINE       *IGetLineByID( DWORD id );
MIXERCONTROL    *IGetControlByType( MIXERLINE *line, DWORD type );
MIXERLINE       *IGetMixerSubLineByType( MIXERCONTROL *mux, DWORD type );


//// The Publics /////////////////////////////////////////////////////////////

hsScalar    plWinMicLevel::GetLevel( void )
{
    if( !CanSetLevel() )
        return -1;

    DWORD   rawValue;
    if( !IGetControlValue( rawValue ) ) 
        return -1;

    return (hsScalar)( rawValue - sMinValue ) / (hsScalar)( sMaxValue - sMinValue );
}

void    plWinMicLevel::SetLevel( hsScalar level )
{
    if( !CanSetLevel() )
        return;

    DWORD   rawValue = (DWORD)(( level * ( sMaxValue - sMinValue ) ) + sMinValue);

    ISetControlValue( rawValue );
}

hsBool  plWinMicLevel::CanSetLevel( void )
{
    // Just to init
    plWinMicLevel   &instance = IGetInstance();

    return ( sMixerHandle != nil ) ? true : false;
}


//// Protected Init Stuff ////////////////////////////////////////////////////

plWinMicLevel   &plWinMicLevel::IGetInstance( void )
{
    static plWinMicLevel    sInstance;
    return sInstance;
}

plWinMicLevel::plWinMicLevel()
{
    sMixerHandle = nil;
    memset( &sMixerCaps, 0, sizeof( sMixerCaps ) );

    // Get the number of mixers in the system
    sNumMixers = ::mixerGetNumDevs();

    // So long as we have one, open the first one
    if( sNumMixers == 0 )
        return;

    if( ::mixerOpen( &sMixerHandle, 0, 
                                    nil,    // Window handle to receive callback messages
                                    nil, MIXER_OBJECTF_MIXER ) != MMSYSERR_NOERROR )
    {
        sMixerHandle = nil; // Just to be sure
        return;
    }

    if( ::mixerGetDevCaps( (UINT)sMixerHandle, &sMixerCaps, sizeof( sMixerCaps ) ) != MMSYSERR_NOERROR )
    {
        // Oh well, who cares
    }

    // Try to get the Mux/mixer-based mic volume control first, since that seems to work better/more often/at all
    if( !IGetMuxMicVolumeControl() )
    {
        // Failed, so try getting the volume control from the base mic-in line
        if( !IGetBaseMicVolumeControl() )
        {
            IShutdown();
            return;
        }
    }
}

plWinMicLevel::~plWinMicLevel()
{
    IShutdown();
}

void    plWinMicLevel::IShutdown( void )
{
    if( sMixerHandle != nil )
        ::mixerClose( sMixerHandle );

    sMixerHandle = nil;
}

//// IGetMuxMicVolumeControl /////////////////////////////////////////////////
//  Tries to get the volume control of the microphone subline of the MUX or
//  mixer control of the WaveIn destination line of the audio system (whew!)
//  Note: testing indcates that this works but the direct SRC_MICROPHONE
//  doesn't, hence we try this one first.

hsBool  IGetMuxMicVolumeControl( void )
{
    if( sMixerHandle == nil )
        return false;

    // Get the WaveIn destination line
    MIXERLINE *waveInLine = IGetLineByType( MIXERLINE_COMPONENTTYPE_DST_WAVEIN );
    if( waveInLine == nil )
        return false;

    // Get the mixer or MUX controller from the line
    MIXERCONTROL *control = IGetControlByType( waveInLine, MIXERCONTROL_CONTROLTYPE_MIXER );
    if( control == nil )
        control = IGetControlByType( waveInLine, MIXERCONTROL_CONTROLTYPE_MUX );
    if( control == nil )
        return false;

    // Get the microphone sub-component
    // Note: this eventually calls IGetLineByType(), which destroys the waveInLine pointer we had before
    MIXERLINE *micLine = IGetMixerSubLineByType( control, MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE );
    if( micLine == nil )
        return false;

    // Get the volume subcontroller
    MIXERCONTROL *micVolCtrl = IGetControlByType( micLine, MIXERCONTROL_CONTROLTYPE_VOLUME );
    if( micVolCtrl == nil )
        return false;

    // Found it! store our values
    char *dbgLineName = micLine->szName;
    char *dbgControlName = micVolCtrl->szName;
    sMinValue = micVolCtrl->Bounds.dwMinimum;
    sMaxValue = micVolCtrl->Bounds.dwMaximum;
    sVolControlID = micVolCtrl->dwControlID;

    return true;
}

//// IGetBaseMicVolumeControl ////////////////////////////////////////////////
//  Tries to get the volume control of the mic-in line. See 
//  IGetMuxMicVolumeControl for why we don't do this one first.

hsBool  IGetBaseMicVolumeControl( void )
{
    if( sMixerHandle == nil )
        return false;

    // Get the mic source line
    MIXERLINE *micLine = IGetLineByType( MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE );
    if( micLine == nil )
        return false;

    // Get the volume subcontroller
    MIXERCONTROL *micVolCtrl = IGetControlByType( micLine, MIXERCONTROL_CONTROLTYPE_VOLUME );
    if( micVolCtrl == nil )
        return false;

    // Found it! store our values
    char *dbgLineName = micLine->szName;
    char *dbgControlName = micVolCtrl->szName;
    sMinValue = micVolCtrl->Bounds.dwMinimum;
    sMaxValue = micVolCtrl->Bounds.dwMaximum;
    sVolControlID = micVolCtrl->dwControlID;

    return true;
}


//// IGetControlValue ////////////////////////////////////////////////////////
//  Gets the raw value of the current volume control.

hsBool  IGetControlValue( DWORD &value )
{
    if( sMixerHandle == nil )
        return false;

    MIXERCONTROLDETAILS_UNSIGNED mxcdVolume;
    MIXERCONTROLDETAILS mxcd;
    mxcd.cbStruct = sizeof( MIXERCONTROLDETAILS );
    mxcd.dwControlID = sVolControlID;
    mxcd.cChannels = 1;
    mxcd.cMultipleItems = 0;
    mxcd.cbDetails = sizeof( MIXERCONTROLDETAILS_UNSIGNED );
    mxcd.paDetails = &mxcdVolume;
    
    if( ::mixerGetControlDetails( (HMIXEROBJ)sMixerHandle, &mxcd, 
            MIXER_OBJECTF_HMIXER | MIXER_GETCONTROLDETAILSF_VALUE ) != MMSYSERR_NOERROR )
        return false;
    
    value = mxcdVolume.dwValue;
    return true;
}

//// ISetControlValue ////////////////////////////////////////////////////////
//  Sets the raw value of the current volume control.

hsBool  ISetControlValue( DWORD value )
{
    if( sMixerHandle == nil )
        return false;

    MIXERCONTROLDETAILS_UNSIGNED mxcdVolume = { value };
    MIXERCONTROLDETAILS mxcd;
    mxcd.cbStruct = sizeof( MIXERCONTROLDETAILS );
    mxcd.dwControlID = sVolControlID;
    mxcd.cChannels = 1;
    mxcd.cMultipleItems = 0;
    mxcd.cbDetails = sizeof( MIXERCONTROLDETAILS_UNSIGNED );
    mxcd.paDetails = &mxcdVolume;

    if( ::mixerSetControlDetails( (HMIXEROBJ)sMixerHandle, &mxcd, 
            MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE ) != MMSYSERR_NOERROR )
        return false;
    
    return true;
}


//// Helper Functions ////////////////////////////////////////////////////////

MIXERLINE *IGetLineByType( DWORD type )
{
    static MIXERLINE mxl;

    mxl.cbStruct = sizeof( MIXERLINE );
    mxl.dwComponentType = type;
    if( ::mixerGetLineInfo( (HMIXEROBJ)sMixerHandle, &mxl, MIXER_OBJECTF_HMIXER | MIXER_GETLINEINFOF_COMPONENTTYPE ) != MMSYSERR_NOERROR )
        return nil;

    return &mxl;
}

MIXERLINE *IGetLineByID( DWORD id )
{
    static MIXERLINE mxl;

    mxl.cbStruct = sizeof( MIXERLINE );
    mxl.dwLineID = id;
    if( ::mixerGetLineInfo( (HMIXEROBJ)sMixerHandle, &mxl, MIXER_OBJECTF_HMIXER | MIXER_GETLINEINFOF_LINEID ) != MMSYSERR_NOERROR )
        return nil;

    return &mxl;
}

MIXERCONTROL    *IGetControlByType( MIXERLINE *line, DWORD type )
{
    static MIXERCONTROL mxc;

    MIXERLINECONTROLS mxlc;
    mxlc.cbStruct = sizeof( MIXERLINECONTROLS );
    mxlc.dwLineID = line->dwLineID;
    mxlc.dwControlType = type;
    mxlc.cControls = 1;
    mxlc.cbmxctrl = sizeof( MIXERCONTROL );
    mxlc.pamxctrl = &mxc;
    if( ::mixerGetLineControls( (HMIXEROBJ)sMixerHandle, &mxlc, MIXER_OBJECTF_HMIXER | MIXER_GETLINECONTROLSF_ONEBYTYPE ) != MMSYSERR_NOERROR )
        return nil;

    return &mxc;
}

MIXERLINE   *IGetMixerSubLineByType( MIXERCONTROL *mux, DWORD type )
{
    // A mixer or MUX is really a combination of MORE lines. And beautifully, you can't
    // just ask for a single one off of it, you have to ask for them all and search through yourself
    MIXERCONTROLDETAILS_LISTTEXT *lineInfo = TRACKED_NEW MIXERCONTROLDETAILS_LISTTEXT[ mux->cMultipleItems ];
    if( lineInfo == nil )
        return nil;

    MIXERCONTROLDETAILS details;
    details.cbStruct = sizeof( MIXERCONTROLDETAILS );
    details.dwControlID = mux->dwControlID;
    details.cChannels = 1;
    details.cMultipleItems = mux->cMultipleItems;
    details.cbDetails = sizeof( MIXERCONTROLDETAILS_LISTTEXT );
    details.paDetails = lineInfo;
    if( ::mixerGetControlDetails( (HMIXEROBJ)sMixerHandle, &details, MIXER_OBJECTF_HMIXER | MIXER_GETCONTROLDETAILSF_LISTTEXT ) != MMSYSERR_NOERROR )
    {
        delete [] lineInfo;
        return nil;
    }

    // Loop through and find the one with the right component type. But of course it doesn't give us that offhand...
    for( unsigned int i = 0; i < mux->cMultipleItems; i++ )
    {
        MIXERLINE *line = IGetLineByID( lineInfo[ i ].dwParam1 );
        if( line->dwComponentType == type )
        {
            delete [] lineInfo;
            return line;
        }
    }

    delete [] lineInfo;
    return nil;
}