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(); } }