BOOL MicMute::selectMic(int val)
{
if (m_mixer == NULL)
{
return FALSE;
}
log.WriteString("\n Selecting mic...");
MIXERCONTROLDETAILS_BOOLEAN *pValue =
new MIXERCONTROLDETAILS_BOOLEAN;
pValue->fValue=val;
mxcd.cMultipleItems=0;
mxcd.cbDetails=sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mxcd.paDetails=pValue;
if( mixerSetControlDetails( ( HMIXEROBJ )m_mixer, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER )
!= MMSYSERR_NOERROR )
{
log.WriteString("\nError while setting value");
return FALSE;
}
log.WriteString("Mic selected properly");
return TRUE;
}
void CVolumeOutMaster::SetCurrentVolume( DWORD dwValue )
{
if ( !m_bAvailable || (dwValue<m_dwMinimalVolume) || (dwValue>m_dwMaximalVolume) )
return;
MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
if ( !aDetails )
return;
for ( int i = 0; i < m_nChannelCount; i++ )
{
aDetails[i].dwValue = dwValue;
}
MIXERCONTROLDETAILS ControlDetails;
memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
ControlDetails.dwControlID = m_dwVolumeControlID;
ControlDetails.cChannels = m_nChannelCount;
ControlDetails.cMultipleItems = 0;
ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
ControlDetails.paDetails = &aDetails[0];
MMRESULT mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_SETCONTROLDETAILSF_VALUE );
free( aDetails );
if ( mmResult != MMSYSERR_NOERROR )
{
ssi_wrn (".MasterOutputVolume: FAILURE: Could not set volume(%d) mmResult=%d\n", dwValue, mmResult );
}
}
/*
This doesn't work for custom controls.
*/
HRESULT CMixerControl::_CommitRawBuffer()
{
MIXERCONTROLDETAILS mcd = {0};
MMRESULT mmr;
mcd.cbStruct = sizeof(mcd);
switch(m_DataType)
{
case MIXDT_SIGNED:
mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_SIGNED);
break;
case MIXDT_BOOLEAN:
mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
break;
case MIXDT_UNSIGNED:
mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
break;
}
mcd.dwControlID = m_mc.dwControlID;
mcd.cChannels = (m_mc.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM) ? 1 : m_ml.cChannels;
mcd.cMultipleItems = (m_mc.fdwControl & MIXERCONTROL_CONTROLF_MULTIPLE) ? m_mc.cMultipleItems : 0;
mcd.paDetails = m_pRaw;
mmr = mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mcd, MIXER_GETCONTROLDETAILSF_VALUE);
Refresh();
return MapMMRToHRESULT(mmr);
}
BOOL ChangeLevel(WPARAM wParam, LPARAM lParam)
{
if (mixer.pmxcdu == NULL)
return FALSE;
switch (LOWORD(wParam))
{
// Adjustments
case TB_PAGEDOWN:
case TB_PAGEUP:
break;
case TB_THUMBPOSITION:
case TB_THUMBTRACK:
break;
default:
return FALSE;
}
int value = SendMessage(level.hwnd, TBM_GETPOS, 0, 0);
mixer.pmxcdu->dwValue = ((mixer.pmxc->Bounds.dwMaximum -
mixer.pmxc->Bounds.dwMinimum) *
(MAX_VOL - value)) / (MAX_VOL - MIN_VOL);
mixerSetControlDetails((HMIXEROBJ)mixer.hmx, mixer.pmxcd,
MIXER_SETCONTROLDETAILSF_VALUE);
return TRUE;
}
void CMicVolume::SetDeviceCtrl(MCS *pData, float vol)
{
int nCnt = 1;
MIXERCONTROLDETAILS_UNSIGNED mixer_control_details_unsigned[10];
MIXERCONTROLDETAILS mixer_control_details;
mixer_control_details.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixer_control_details.dwControlID = pData->m_ctlMixerSpeaker.dwControlID;
mixer_control_details.cChannels = 1;
mixer_control_details.cMultipleItems = pData->m_ctlMixerSpeaker.cMultipleItems;
mixer_control_details.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mixer_control_details.paDetails = mixer_control_details_unsigned;
if(MIXERCONTROL_CONTROLF_MULTIPLE & pData->m_ctlMixerSpeaker.fdwControl) nCnt = pData->m_ctlMixerSpeaker.cMultipleItems;
for(int i = 0; i < nCnt; i++){
mixer_control_details_unsigned[i].dwValue = (int)((vol * 65535 + pData->nMax/2) / pData->nMax);
}
if(mixerSetControlDetails((HMIXEROBJ)h_mix, &mixer_control_details, 0))
{
#ifdef _DEBUG
MessageBox(NULL,"내부 함수 오류(mixerSetControlDetails)", "내부 함수 오류", MB_ICONSTOP);
#endif
}
return;
}
BOOL mixer_manipulate_volume(int channel, BOOL get, LPDWORD left, LPDWORD right)
{
MIXERCONTROLDETAILS_UNSIGNED details[2];
MIXERCONTROLDETAILS mcd;
details[0].dwValue = *left;
details[1].dwValue = *right;
if (s_lines.count == 0)
return (FALSE);
if (channel < 0 || channel >= s_lines.count)
return (FALSE);
mcd.cbStruct = sizeof(MIXERCONTROLDETAILS);
mcd.dwControlID = s_lines.mixers[channel].dwControlID;
mcd.cChannels = 2;
mcd.cMultipleItems = 0;
mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mcd.paDetails = &details;
if (get)
{
CHECK_MMRETURN(mixerGetControlDetails((HMIXEROBJ)s_hMixer, &mcd, MIXER_GETCONTROLDETAILSF_VALUE));
}
else
{
CHECK_MMRETURN(mixerSetControlDetails((HMIXEROBJ)s_hMixer, &mcd, MIXER_SETCONTROLDETAILSF_VALUE));
}
*left = details[0].dwValue;
*right = details[1].dwValue;
return (TRUE);
}
BOOL mixer_manipulate_mute(int channel, BOOL get, LPBOOL mute)
{
MIXERCONTROLDETAILS_BOOLEAN details;
MIXERCONTROLDETAILS mcd;
details.fValue = *mute;
if (s_mutes.count == 0)
return (FALSE);
if (channel < 0 || channel >= s_mutes.count)
return (FALSE);
mcd.cbStruct = sizeof(MIXERCONTROLDETAILS);
mcd.dwControlID = s_mutes.mixers[channel].dwControlID;
mcd.cChannels = 1;
mcd.cMultipleItems = 0;
mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mcd.paDetails = &details;
if (get)
{
CHECK_MMRETURN(mixerGetControlDetails((HMIXEROBJ)s_hMixer, &mcd, MIXER_GETCONTROLDETAILSF_VALUE));
}
else
{
CHECK_MMRETURN(mixerSetControlDetails((HMIXEROBJ)s_hMixer, &mcd, MIXER_SETCONTROLDETAILSF_VALUE));
}
*mute = details.fValue;
return (TRUE);
}
/* ------------------------------------------------------------------------------------ */
BOOL CMixer::SetControlValue(DWORD dw)
{
if(!m_bSuccess)
return m_bSuccess;
m_bSuccess = FALSE;
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_UNSIGNED mxcd_u;
mxcd.cbStruct = sizeof(mxcd);
mxcd.dwControlID = m_iMixerControlID;
mxcd.cChannels = m_dwChannels;
mxcd.cMultipleItems = 0;
mxcd.cbDetails = sizeof(mxcd_u);
mxcd.paDetails = &mxcd_u;
mmr = mixerGetControlDetails(reinterpret_cast<HMIXEROBJ>(m_HMixer), &mxcd, 0L);
if(MMSYSERR_NOERROR != mmr) return m_bSuccess;
mxcd_u.dwValue = dw;
mmr = mixerSetControlDetails(reinterpret_cast<HMIXEROBJ>(m_HMixer), &mxcd, 0L);
if(MMSYSERR_NOERROR != mmr)
return m_bSuccess;
m_bSuccess = TRUE;
return m_bSuccess;
}
//--------------------------------------------------------------------------------------
// Class: YARPSoundDeviceDriver
// Method: set_volume
// Description: This function set the volume in both channels
//--------------------------------------------------------------------------------------
int
YARPSoundDeviceDriver::set_volume(void *cmd)
{
MIXERCONTROLDETAILS_UNSIGNED value[2];
MIXERCONTROLDETAILS mixerControlDetails;
MMRESULT err;
SoundResources& d = RES(system_resources);
unsigned int * m_volume = (unsigned int *) cmd;
/*
* Select the control type in the current line
*/
d._select_control(MIXERCONTROL_CONTROLTYPE_VOLUME);
mixerControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixerControlDetails.dwControlID = d.m_mixerControlArray.dwControlID;
mixerControlDetails.cChannels = 2;
mixerControlDetails.cMultipleItems = 0;
mixerControlDetails.paDetails = &value[0];
mixerControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
value[0].dwValue = value[1].dwValue = (*m_volume);
err = mixerSetControlDetails((HMIXEROBJ)d.m_MixerHandle,
&mixerControlDetails,
MIXER_SETCONTROLDETAILSF_VALUE);
if( err != MMSYSERR_NOERROR) printf("yarpsounddriver: Error #%d setting mute for %s!\n", err, d.m_mixerLine.szName);
return YARP_OK;
}
static void
gst_directsound_src_set_mute (GstDirectSoundSrc * dsoundsrc, gboolean mute)
{
MMRESULT mmres;
MIXERCONTROLDETAILS details;
MIXERCONTROLDETAILS_BOOLEAN details_boolean;
if (dsoundsrc->mixer == NULL || dsoundsrc->control_id_mute < 0) {
GST_WARNING ("mixer not initialized");
return;
}
details.cbStruct = sizeof (details);
details.dwControlID = dsoundsrc->control_id_mute;
details.cChannels = dsoundsrc->mixerline_cchannels;
details.cMultipleItems = 0;
details_boolean.fValue = mute;
details.cbDetails = sizeof (MIXERCONTROLDETAILS_BOOLEAN);
details.paDetails = &details_boolean;
mmres = mixerSetControlDetails ((HMIXEROBJ) dsoundsrc->mixer,
&details, MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE);
if (mmres != MMSYSERR_NOERROR)
GST_WARNING ("Failed to set mute");
else
dsoundsrc->mute = mute;
}
void VolumeFunction(HMIXEROBJ hMixer, DWORD controlID, PxVolume *volume)
{
MIXERCONTROLDETAILS details;
MMRESULT result;
unsigned short value = 0;
details.cbStruct = sizeof(MIXERCONTROLDETAILS);
details.dwControlID = controlID;
details.cChannels = 1; /* all channels */
details.cMultipleItems = 0;
details.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
details.paDetails = &value;
result = mixerGetControlDetails(hMixer, &details,
MIXER_GETCONTROLDETAILSF_VALUE);
if (*volume < 0.0) {
*volume = (PxVolume)(value / 65535.0);
}
else {
if (result != MMSYSERR_NOERROR)
return;
value = (unsigned short)(*volume * 65535.0);
mixerSetControlDetails(hMixer, &details,
MIXER_GETCONTROLDETAILSF_VALUE);
}
}
bool Win32RedBookDevice::setVolume(F32 volume)
{
if(!mAcquired)
{
setLastError("Device has not been acquired");
return(false);
}
if(!mVolumeInitialized)
{
setLastError("Volume failed to initialize");
return(false);
}
// move into a U32 - left/right U16 volumes
U32 vol = U32(volume * 65536.f);
if(vol > 0xffff)
vol = 0xffff;
if(mUsingMixer)
{
mMixerVolumeValue.dwValue = vol;
mixerSetControlDetails(mVolumeDeviceId, &mMixerVolumeDetails, MIXER_SETCONTROLDETAILSF_VALUE);
}
else
{
vol |= vol << 16;
auxSetVolume(mAuxVolumeDeviceId, vol);
}
setLastError("");
return(true);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//agenttype_mixer_notify
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void agenttype_mixer_notify_xp (agent *a, int notifytype, void *messagedata)
{
//Get the agent details
AgentType_Mixer_XP * details = static_cast<AgentType_Mixer_XP *>(a->agentdetails);
//Variables
double *value_double = NULL;
bool *value_bool = NULL;
MIXERCONTROLDETAILS_UNSIGNED mixer_setcontrol_value_double;
MIXERCONTROLDETAILS_BOOLEAN mixer_setcontrol_value_bool;
switch (notifytype)
{
case NOTIFY_CHANGE:
{
//Set up the values
if (a->agenttypeptr->format & CONTROL_FORMAT_SCALE)
{
value_double = (double *) messagedata;
details->m_mixer_controldetails.paDetails = &mixer_setcontrol_value_double;
}
else if (a->agenttypeptr->format & CONTROL_FORMAT_BOOL)
{
value_bool = (bool *) messagedata;
details->m_mixer_controldetails.paDetails = &mixer_setcontrol_value_bool;
}
//Retrieve the details
if (MMSYSERR_NOERROR != mixerGetControlDetails((HMIXEROBJ) details->m_mixer_handle, &details->m_mixer_controldetails, MIXER_GETCONTROLDETAILSF_VALUE)) return;
//Set the value
if (a->agenttypeptr->format & CONTROL_FORMAT_SCALE)
{
mixer_setcontrol_value_double.dwValue = (ULONG) (*value_double * 65535);
}
else if (a->agenttypeptr->format & CONTROL_FORMAT_BOOL)
{
mixer_setcontrol_value_bool.fValue = *value_bool;
}
//Reload the details
MMRESULT const res = mixerSetControlDetails((HMIXEROBJ) details->m_mixer_handle, &details->m_mixer_controldetails, MIXER_SETCONTROLDETAILSF_VALUE);
if (MMSYSERR_NOERROR != res) return;
break;
}
case NOTIFY_SAVE_AGENT:
//Write existance
char temp[30];
sprintf(temp, "%d %d %d", (int)details->m_device, (int)details->m_line, (int)details->m_control);
config_write(config_get_control_setagent_c(a->controlptr, a->agentaction, a->agenttypeptr->agenttypename, temp));
break;
}
}
BOOL CMyVolumeCtrl::vSetVolumeValue(HMIXER hmixer ,MIXERCONTROL *mxc, long volume)
{
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_UNSIGNED vol;vol.dwValue = volume;
mxcd.hwndOwner = 0;
mxcd.dwControlID = mxc-> dwControlID;
mxcd.cbStruct = sizeof(mxcd);
mxcd.cbDetails = sizeof(vol);
mxcd.paDetails = &vol;
mxcd.cChannels = 1;
if(mixerSetControlDetails((HMIXEROBJ)hmixer, &mxcd, MIXER_OBJECTF_HMIXER|MIXER_SETCONTROLDETAILSF_VALUE))
return FALSE;
return TRUE;
}
void play()
{
int targetval = 65535;
if (volume != 100)
{
targetval = (int)((volume / 100.0) * 65535);
}
//credits to http://www.codeproject.com/Articles/4754/mixerSetControlDetails
printf("creating mixer,volume = %d, targetval = %d\n",volume,targetval);
/* obtain handle to mixer device */
MMRESULT result;
HMIXER hMixer;
result = mixerOpen(&hMixer, MIXER_OBJECTF_MIXER, 0, 0, 0);
/* get speaker line of the mixer device */
MIXERLINE ml = { 0 };
ml.cbStruct = sizeof(MIXERLINE);
ml.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
result = mixerGetLineInfo((HMIXEROBJ)hMixer,&ml, MIXER_GETLINEINFOF_COMPONENTTYPE);
/* get colume control of the speaker line */
MIXERLINECONTROLS mlc = { 0 };
MIXERCONTROL mc = { 0 };
mlc.cbStruct = sizeof(MIXERLINECONTROLS);
mlc.dwLineID = ml.dwLineID;
mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
mlc.cControls = 1;
mlc.pamxctrl = &mc;
mlc.cbmxctrl = sizeof(MIXERCONTROL);
result = mixerGetLineControls((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE);
/* set the volume level */
MIXERCONTROLDETAILS mcd = { 0 };
MIXERCONTROLDETAILS_UNSIGNED mcdu = { 0 };
mcdu.dwValue = targetval; // the volume is a number between 0 and 65535
mcd.cbStruct = sizeof(MIXERCONTROLDETAILS);
mcd.hwndOwner = 0;
mcd.dwControlID = mc.dwControlID;
mcd.paDetails = &mcdu;
mcd.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mcd.cChannels = 1;
result = mixerSetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_SETCONTROLDETAILSF_VALUE);
PlaySound(filename, NULL, SND_FILENAME);
}
//---------------------------------------------------------------------------
BOOL CMyVolumeCtrl::vSetMuteValue(HMIXER hmixer ,MIXERCONTROL *mxc, BOOL mute)
{
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_BOOLEAN mxcdMute;mxcdMute.fValue=mute;
mxcd.hwndOwner = 0;
mxcd.dwControlID = mxc-> dwControlID;
mxcd.cbStruct = sizeof(mxcd);
mxcd.cbDetails = sizeof(mxcdMute);
mxcd.paDetails = &mxcdMute;
mxcd.cChannels = 1;
mxcd.cMultipleItems = 0;
if (mixerSetControlDetails((HMIXEROBJ)hmixer, &mxcd, MIXER_OBJECTF_HMIXER|MIXER_SETCONTROLDETAILSF_VALUE))
return FALSE;
return TRUE;
}
void Win32RedBookDevice::closeVolume()
{
setLastError("");
if(!mVolumeInitialized)
return;
if(mUsingMixer)
{
mMixerVolumeValue.dwValue = mOriginalVolume;
mixerSetControlDetails(mVolumeDeviceId, &mMixerVolumeDetails, MIXER_SETCONTROLDETAILSF_VALUE);
mixerClose((HMIXER)mVolumeDeviceId);
}
else
auxSetVolume(mAuxVolumeDeviceId, mOriginalVolume);
mVolumeInitialized = false;
}
bool PortAudioInput::SetMicrophoneLevel(DWORD dwLevel)
{
MMRESULT mmresult;
MIXERCONTROLDETAILS_UNSIGNED mxcdVolume_Set = {
dwLevel
};
MIXERCONTROLDETAILS mxcd_Set;
mxcd_Set.cbStruct = sizeof(MIXERCONTROLDETAILS);
mxcd_Set.dwControlID = m_dwCntlID;
mxcd_Set.cChannels = 1;
mxcd_Set.cMultipleItems = 0;
mxcd_Set.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mxcd_Set.paDetails = &mxcdVolume_Set;
mmresult = mixerSetControlDetails(reinterpret_cast<HMIXEROBJ>(m_mixerMic),
&mxcd_Set,
MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE);
return ( mmresult == MMSYSERR_NOERROR );
}
//设置静音值
bool SoundControl::SetMuteValue(HMIXER hmixer, MIXERCONTROL *mxc, bool mute)
{
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_BOOLEAN mxcdMute;
mxcdMute.fValue = mute;
mxcd.hwndOwner = 0;
mxcd.dwControlID = mxc ->dwControlID;
mxcd.cbStruct = sizeof (mxcd);
mxcd.cbDetails = sizeof (mxcdMute);
mxcd.paDetails = &mxcdMute;
mxcd.cChannels = 1;
mxcd.cMultipleItems = 0;
if (mixerSetControlDetails((HMIXEROBJ)hmixer, &mxcd, MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE))
{
return 0;
}
return 1;
}
VOID
SwitchMuteState(PGLOBAL_DATA pGlobalData)
{
MIXERCONTROLDETAILS_BOOLEAN mxcdMute;
MIXERCONTROLDETAILS mxcd;
mxcd.cbStruct = sizeof(MIXERCONTROLDETAILS);
mxcd.dwControlID = pGlobalData->muteControlID;
mxcd.cChannels = 1;
mxcd.cMultipleItems = 0;
mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mxcd.paDetails = &mxcdMute;
mxcdMute.fValue = !pGlobalData->muteVal;
if (mixerSetControlDetails((HMIXEROBJ)pGlobalData->hMixer, &mxcd, MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE)
!= MMSYSERR_NOERROR)
return;
pGlobalData->muteVal = mxcdMute.fValue;
}
STDMETHODIMP CMixerControl::CommitCustomBuffer()
{
if(m_Type != MIXC_CUSTOM) return MIX_E_WRONGTYPE;
MMRESULT mmr = 0;
MIXERCONTROLDETAILS mcd = {0};
mcd.cbStruct = sizeof(mcd);
mcd.cbDetails = m_mc.Metrics.cbCustomData;
mcd.dwControlID = m_mc.dwControlID;
mcd.cChannels = 0;
mcd.cMultipleItems = 0;
mcd.paDetails = m_pRaw;
mmr = mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mcd, MIXER_GETCONTROLDETAILSF_VALUE);
Refresh();
return MapMMRToHRESULT(mmr);
}
INT
SndMixerSetVolumeControlDetails(PSND_MIXER Mixer, DWORD dwControlID, DWORD cbDetails, LPVOID paDetails)
{
MIXERCONTROLDETAILS MixerDetails;
if (Mixer->hmx)
{
MixerDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
MixerDetails.dwControlID = dwControlID;
MixerDetails.cChannels = 1; //FIXME
MixerDetails.cMultipleItems = 0;
MixerDetails.cbDetails = cbDetails;
MixerDetails.paDetails = paDetails;
if (mixerSetControlDetails((HMIXEROBJ)Mixer->hmx, &MixerDetails, MIXER_GETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER) == MMSYSERR_NOERROR)
{
return 1;
}
}
return -1;
}
//--------------------------------------------------------------------------------------
// Class: YARPSoundDeviceDriver
// Method: set_mute
// Description: This function set the mute state in the already selected line.
// Use:
// 0 -> mute
// 1 -> No mute
//--------------------------------------------------------------------------------------
int
YARPSoundDeviceDriver::set_mute(void *cmd)
{
MIXERCONTROLDETAILS_UNSIGNED value[2];
MIXERCONTROLDETAILS mixerControlDetails;
MMRESULT err;
SoundResources& d = RES(system_resources);
unsigned int * m_mute_state = (unsigned int *) cmd;
//----------------------------------------------------------------------
// Select the mute control in the selected line
//----------------------------------------------------------------------
//d._select_control(MIXERCONTROL_CONTROLTYPE_MUTE);
d._select_control(MIXERCONTROL_CONTROLTYPE_ONOFF);
mixerControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixerControlDetails.dwControlID = d.m_mixerControlArray.dwControlID;
mixerControlDetails.cChannels = d.m_mixerLine.cChannels;
if (mixerControlDetails.cChannels > 2) mixerControlDetails.cChannels = 2;
if (d.m_mixerControlArray.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM) mixerControlDetails.cChannels = 1;
mixerControlDetails.cMultipleItems = 0;
mixerControlDetails.paDetails = &value[0];
mixerControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
value[0].dwValue = value[1].dwValue = (*m_mute_state);
err = mixerSetControlDetails((HMIXEROBJ)d.m_MixerHandle,
&mixerControlDetails,
MIXER_SETCONTROLDETAILSF_VALUE);
if( err != MMSYSERR_NOERROR) printf("yarpsounddriver: Error #%d setting mute for %s!\n", err, d.m_mixerLine.szName);
return YARP_OK;
}
VOID
SetVolumeValue(PGLOBAL_DATA pGlobalData){
MIXERCONTROLDETAILS_UNSIGNED mxcdVolume;
MIXERCONTROLDETAILS mxcd;
if (pGlobalData->hMixer == NULL)
return;
mxcdVolume.dwValue = pGlobalData->volumeValue;
mxcd.cbStruct = sizeof(MIXERCONTROLDETAILS);
mxcd.dwControlID = pGlobalData->volumeControlID;
mxcd.cChannels = 1;
mxcd.cMultipleItems = 0;
mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mxcd.paDetails = &mxcdVolume;
if (mixerSetControlDetails((HMIXEROBJ)pGlobalData->hMixer, &mxcd, MIXER_OBJECTF_HMIXER | MIXER_SETCONTROLDETAILSF_VALUE)
!= MMSYSERR_NOERROR)
return;
pGlobalData->volumeValue = mxcdVolume.dwValue;
}
HRESULT SetGain(float fGain)
{
if (fGain > 0.0f)
{
return E_INVALIDARG;
}
const float fMinGain = -40;
float fClippedGain = max(fMinGain, fGain);
// set the volume on every CD player (since we can't map to the right one)
// restore the volume settings for all of the CD players
std::list<MixerLineData>::iterator mixerline;
for (mixerline = m_listMixerLines.begin(); mixerline != m_listMixerLines.end(); ++mixerline)
{
MixerLineData& mixerlinedata = *mixerline;
// translate the gain to a linear volume setting.
MIXERCONTROLDETAILS_UNSIGNED volume;
volume.dwValue = (DWORD)(mixerlinedata.mixercontrol.Bounds.dwMinimum
+ (mixerlinedata.mixercontrol.Bounds.dwMaximum - mixerlinedata.mixercontrol.Bounds.dwMinimum)
* (1 - fClippedGain/fMinGain));
// set the volume for this control
MIXERCONTROLDETAILS mixercontroldetails;
mixercontroldetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixercontroldetails.dwControlID = mixerlinedata.mixercontrol.dwControlID;
mixercontroldetails.cChannels = 1;
mixercontroldetails.cMultipleItems = 0;
mixercontroldetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mixercontroldetails.paDetails = &volume;
ZVerify(mixerSetControlDetails(mixerlinedata.hmixer, &mixercontroldetails, MIXER_SETCONTROLDETAILSF_VALUE)
== MMSYSERR_NOERROR);
}
return S_OK;
}
void Px_SetCurrentInputSource( PxMixer *mixer, int i )
{
PxInfo *info = (PxInfo *)mixer;
MIXERCONTROLDETAILS details;
MIXERCONTROLDETAILS_BOOLEAN flags[32];
MMRESULT result;
int j;
details.cbStruct = sizeof(MIXERCONTROLDETAILS);
details.dwControlID = info->muxID;
details.cMultipleItems = info->numInputs;
details.cChannels = 1;
details.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
details.paDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)&flags[0];
for(j=0; j<info->numInputs; j++)
flags[j].fValue = (i == j);
result = mixerSetControlDetails(info->hInputMixer,
(LPMIXERCONTROLDETAILS)&details,
MIXER_SETCONTROLDETAILSF_VALUE);
}
static PxVolume VolumeFunction(HMIXEROBJ hMixer, DWORD controlID, PxVolume volume)
{
MIXERCONTROLDETAILS details;
MMRESULT result;
MIXERCONTROLDETAILS_UNSIGNED value;
if (hMixer == NULL) {
return -1.0;
}
memset(&value, 0, sizeof(MIXERCONTROLDETAILS_UNSIGNED));
details.cbStruct = sizeof(MIXERCONTROLDETAILS);
details.dwControlID = controlID;
details.cChannels = 1; /* all channels */
details.cMultipleItems = 0;
details.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
details.paDetails = &value;
if (volume < 0.0) {
result = mixerGetControlDetails(hMixer,
&details,
MIXER_GETCONTROLDETAILSF_VALUE);
if (result != MMSYSERR_NOERROR)
return -1.0;
return (PxVolume)(value.dwValue / 65535.0);
}
value.dwValue = (unsigned short)(volume * 65535.0);
result = mixerSetControlDetails(hMixer,
&details,
MIXER_GETCONTROLDETAILSF_VALUE);
if (result != MMSYSERR_NOERROR)
return -1.0;
return 0.0;
}
void CMixer::SetPan(long dwVol)
{
if (!m_bOK || m_dwControlPID==0) return;
HMIXER hMixer;
HRESULT hr;
hr = mixerOpen(&hMixer, 0, 0, 0, 0);
if (FAILED(hr)) return;
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_SIGNED mxdu;
mxdu.lValue = dwVol;
mxcd.cMultipleItems = 0;
mxcd.cChannels = 1;
mxcd.cbStruct = sizeof(mxcd);
mxcd.dwControlID = m_dwControlPID;
mxcd.cbDetails = sizeof(mxdu);
mxcd.paDetails = &mxdu;
hr = mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_SETCONTROLDETAILSF_VALUE| MIXER_OBJECTF_HMIXER);
mixerClose(hMixer);
}
void CMixer::SetVolume(DWORD dwVol)
{
if (!m_bOK) return;
HMIXER hMixer;
HRESULT hr;
hr = mixerOpen(&hMixer, 0, 0, 0, 0);
if (FAILED(hr)) return;
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_UNSIGNED mxdu;
mxdu.dwValue = dwVol;
mxcd.cMultipleItems = 0;
mxcd.cChannels = m_dwChannels;
mxcd.cbStruct = sizeof(mxcd);
mxcd.dwControlID = m_dwControlID;
mxcd.cbDetails = sizeof(mxdu);
mxcd.paDetails = &mxdu;
hr = mixerSetControlDetails((HMIXEROBJ)hMixer, &mxcd, MIXER_SETCONTROLDETAILSF_VALUE);
mixerClose(hMixer);
}
~CDVolume()
{
// restore the volume settings for all of the CD players
while (!m_listMixerLines.empty())
{
MixerLineData& mixerlinedata = m_listMixerLines.back();
MIXERCONTROLDETAILS mixercontroldetails;
mixercontroldetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixercontroldetails.dwControlID = mixerlinedata.mixercontrol.dwControlID;
mixercontroldetails.cChannels = mixerlinedata.cChannels;
mixercontroldetails.cMultipleItems = 0;
mixercontroldetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mixercontroldetails.paDetails = &(mixerlinedata.vmixercontrolsOld);
ZVerify(mixerSetControlDetails(mixerlinedata.hmixer, &mixercontroldetails, MIXER_SETCONTROLDETAILSF_VALUE)
== MMSYSERR_NOERROR);
ZVerify(mixerClose((HMIXER)mixerlinedata.hmixer) == MMSYSERR_NOERROR);
m_listMixerLines.pop_back();
}
}
