/***************************************************************************** * * Component: sndvol32.exe * File: mixer.c * Purpose: mixer api specific implementations * * Copyright (c) 1985-1999 Microsoft Corporation * *****************************************************************************/ #include #include #include #include #include #include "volumei.h" #include "volids.h" #include "vu.h" extern void Mixer_Multichannel(PMIXUIDIALOG pmxud, DWORD dwVolumeID); extern void Mixer_Advanced(PMIXUIDIALOG pmxud, DWORD dwLineID, LPTSTR szName); extern HRESULT GetDestination(DWORD mxid, int *piDest); extern BOOL DeviceChange_Init(HWND hWnd, DWORD dwMixerID); /***************************************************************************** * * INIT SPECIFIC CODE * *****************************************************************************/ /* * Mixer_GetNumDevs * * */ int Mixer_GetNumDevs() { return mixerGetNumDevs(); } /* * Mixer_GetDeviceName() * * */ BOOL Mixer_GetDeviceName( PMIXUIDIALOG pmxud) { MIXERCAPS mxcaps; MMRESULT mmr; mmr = mixerGetDevCaps( pmxud->mxid, &mxcaps, sizeof(mxcaps)); if (mmr != MMSYSERR_NOERROR) return FALSE; lstrcpy(pmxud->szMixer, mxcaps.szPname); return TRUE; } BOOL Mixer_AreChannelsAtMinimum(MIXERCONTROLDETAILS_UNSIGNED* pmcdVolume, DWORD cChannels) { UINT uiIndx; if (pmcdVolume && cChannels > 0) { for (uiIndx = 0; uiIndx < cChannels; uiIndx++) { if ((pmcdVolume + uiIndx) -> dwValue != 0) { return (FALSE); } } return (TRUE); // Volume of all channels equals zero since we haven't returned yet. } else return (FALSE); } void Mixer_RefreshMixCache (PVOLCTRLDESC pvcd, MIXERCONTROLDETAILS_UNSIGNED* pmcdVolume, DWORD cChannels) { if (pmcdVolume && cChannels > 0) { // Create cache if necessary if (!pvcd->pdblCacheMix) pvcd->pdblCacheMix = (double*) GlobalAllocPtr(GHND, sizeof (double) * cChannels); // Refresh cache if (pvcd->pdblCacheMix) { UINT uiIndx; double* pdblMixPercent; DWORD dwVolume; // Get the maximum volume DWORD dwMaxVol = 0; for (uiIndx = 0; uiIndx < cChannels; uiIndx++) dwMaxVol = max (dwMaxVol, (pmcdVolume + uiIndx) -> dwValue); // Caculate the percentage distance each channel is away from the max // value. Creating this cache allows us to maintain the relative distance // of the channel levels from each other as the user adjusts the master // volume level. for (uiIndx = 0; uiIndx < cChannels; uiIndx++) { dwVolume = (pmcdVolume + uiIndx) -> dwValue; pdblMixPercent = (pvcd->pdblCacheMix + uiIndx); // Caculate the percentage this value is from the max ... if (dwMaxVol == dwVolume) { *pdblMixPercent = 1.0F; } else { // Note: if 0 == dwMaxVol all values would be zero and this part // of the "if" statement will never execute. *pdblMixPercent = ((double) dwVolume / (double) dwMaxVol); } } } } } /* * Mixer_SetLines * * Locate mixer/mux relationships. Fix up uninitialized volume description * information. * * */ static void Mixer_SetLines( HMIXEROBJ hmx, PVOLCTRLDESC pvcd, UINT cPvcd) { LPMIXERCONTROLDETAILS_LISTTEXT pmcd_lt; PMIXERCONTROLDETAILS_BOOLEAN pmcd_b; MIXERCONTROLDETAILS mxd; MMRESULT mmr; UINT i,j; MIXERLINE mxl; DWORD dwDst; // // Another test for drivers. Some drivers (Mediavision) // don't return the proper destination / source index in the // mixerGetLineInfo call. Tag a workaround. // mxl.cbStruct = sizeof(mxl); mxl.dwLineID = pvcd[0].dwLineID; mmr = mixerGetLineInfo(hmx , &mxl , MIXER_GETLINEINFOF_LINEID); if (mmr == MMSYSERR_NOERROR) { dwDst = mxl.dwDestination; for (i = 1; i < cPvcd; i++) { mxl.cbStruct = sizeof(mxl); mxl.dwLineID = pvcd[i].dwLineID; mmr = mixerGetLineInfo(hmx , &mxl , MIXER_GETLINEINFOF_LINEID); if (mmr != MMSYSERR_NOERROR) { pvcd[0].dwSupport |= VCD_SUPPORTF_BADDRIVER; break; } if (mxl.dwDestination != dwDst) { pvcd[0].dwSupport |= VCD_SUPPORTF_BADDRIVER; break; } } } // // for the first pvcd (destination), propogate the mixer/mux control // id's to those controls that are part of the list. 0 out the rest. // The UI can just do a mixerXXXControlDetails on the control ID to // locate the state information // if (pvcd->dwSupport & VCD_SUPPORTF_MIXER_MIXER) { pmcd_lt = GlobalAllocPtr(GHND, sizeof(MIXERCONTROLDETAILS_LISTTEXT) * pvcd->cMixer); pmcd_b = GlobalAllocPtr(GHND, sizeof(MIXERCONTROLDETAILS_BOOLEAN) * pvcd->cMixer); if (!pmcd_lt || !pmcd_b) return; mxd.cbStruct = sizeof(mxd); mxd.dwControlID = pvcd->dwMixerID; mxd.cChannels = 1; mxd.cMultipleItems = pvcd->cMixer; mxd.cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXT); mxd.paDetails = pmcd_lt; mmr = mixerGetControlDetails(hmx , &mxd , MIXER_GETCONTROLDETAILSF_LISTTEXT); if (mmr == MMSYSERR_NOERROR) { // // iterate over all source lines s.t. dwMixerID points to the // correct control id on the destination and iMixer is the // correct index into the value list // pvcd[0].amcd_bMixer = pmcd_b; for (i = 1; i < cPvcd; i++) { for (j = 0; j < pvcd->cMixer; j++) { if (!lstrcmp(pmcd_lt[j].szName,pvcd[i].szName)) { pvcd[i].dwMixerID = pvcd->dwMixerID; pvcd[i].iMixer = j; pvcd[i].cMixer = pvcd->cMixer; pvcd[i].dwSupport |= VCD_SUPPORTF_MIXER_MIXER; pvcd[i].dwVisible |= VCD_VISIBLEF_MIXER_MIXER; pvcd[i].dwVisible &= ~VCD_VISIBLEF_MIXER_MUTE; pvcd[i].amcd_bMixer = pmcd_b; } } } } GlobalFreePtr(pmcd_lt); } if (pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUX) { pmcd_lt = GlobalAllocPtr(GHND, sizeof(MIXERCONTROLDETAILS_LISTTEXT) * pvcd->cMux); pmcd_b = GlobalAllocPtr(GHND, sizeof(MIXERCONTROLDETAILS_BOOLEAN) * pvcd->cMux); if (!pmcd_lt || !pmcd_b) return; mxd.cbStruct = sizeof(mxd); mxd.dwControlID = pvcd->dwMuxID; mxd.cChannels = 1; mxd.cMultipleItems = pvcd->cMux; mxd.cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXT); mxd.paDetails = pmcd_lt; mmr = mixerGetControlDetails(hmx , &mxd , MIXER_GETCONTROLDETAILSF_LISTTEXT); if (mmr == MMSYSERR_NOERROR) { // // iterate over all source lines s.t. dwMuxID points to the // correct control id on the destination and iMux is the // correct index into the value list // pvcd[0].amcd_bMux = pmcd_b; for (i = 1; i < cPvcd; i++) { for (j = 0; j < pvcd->cMux; j++) { if (!lstrcmp(pmcd_lt[j].szName,pvcd[i].szName)) { pvcd[i].dwMuxID = pvcd->dwMuxID; pvcd[i].iMux = j; pvcd[i].cMux = pvcd->cMux; pvcd[i].dwSupport |= VCD_SUPPORTF_MIXER_MUX; pvcd[i].dwVisible |= VCD_VISIBLEF_MIXER_MUX; pvcd[i].dwVisible &= ~VCD_VISIBLEF_MIXER_MUTE; pvcd[i].amcd_bMux = pmcd_b; } } } } GlobalFreePtr(pmcd_lt); } } /* * Mixer_CheckdDriver * * Consistency check for bad mixer drivers. * */ static DWORD Mixer_CheckBadDriver( HMIXEROBJ hmx, PMIXERLINECONTROLS pmxlc, PMIXERCONTROL pmxc, DWORD dwControlID, DWORD dwLineID) { MMRESULT mmr; pmxlc->cbStruct = sizeof(MIXERLINECONTROLS); pmxlc->dwControlID = dwControlID; pmxlc->cControls = 1; pmxlc->cbmxctrl = sizeof(MIXERCONTROL); pmxlc->pamxctrl = pmxc; mmr = mixerGetLineControls(hmx , pmxlc , MIXER_GETLINECONTROLSF_ONEBYID); if (mmr != MMSYSERR_NOERROR) return VCD_SUPPORTF_BADDRIVER; if (pmxlc->dwLineID != dwLineID) return VCD_SUPPORTF_BADDRIVER; return 0L; } /* * IsDestinationMux * * Helper function to determine if a source line has a mux on its associated * destination line * * */ BOOL IsDestinationMux( HMIXEROBJ hmx, DWORD dwLineID ) { MIXERLINE mxl; MIXERLINECONTROLS mxlc; MIXERCONTROL mxc; MMRESULT mmr; DWORD dwDst; mxl.cbStruct = sizeof(mxl); mxl.dwLineID = dwLineID; // Get the destination number for this line mmr = mixerGetLineInfo(hmx , &mxl , MIXER_GETLINEINFOF_LINEID); if (mmr != MMSYSERR_NOERROR) { return FALSE; } // // Get the LineId for this destination number // // mxl.dwDestination will been filled in by the last // call to mixerGetLineInfo // mmr = mixerGetLineInfo(hmx , &mxl , MIXER_GETLINEINFOF_DESTINATION); if (mmr != MMSYSERR_NOERROR) { return FALSE; } mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = mxl.dwLineID; // use the dwLineId obtained from mixerGetLinInfo mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MUX; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls(hmx , &mxlc , MIXER_GETLINECONTROLSF_ONEBYTYPE); if (mmr == MMSYSERR_NOERROR) { return TRUE; } return FALSE; } /* * Mixer_InitLineControls * * Initialize the mixer api specific part of the volume control description * mark hidden lines. * */ static void Mixer_InitLineControls( HMIXEROBJ hmx, PVOLCTRLDESC pvcd, DWORD dwLineID) { MIXERLINECONTROLS mxlc; MIXERCONTROL mxc; MMRESULT mmr; int iType; const DWORD dwAdvTypes[] = { MIXERCONTROL_CONTROLTYPE_BOOLEAN, MIXERCONTROL_CONTROLTYPE_ONOFF, MIXERCONTROL_CONTROLTYPE_MONO, MIXERCONTROL_CONTROLTYPE_LOUDNESS, MIXERCONTROL_CONTROLTYPE_STEREOENH, MIXERCONTROL_CONTROLTYPE_BASS, MIXERCONTROL_CONTROLTYPE_TREBLE }; pvcd->dwLineID = dwLineID; pvcd->dwMeterID = 0; pvcd->dwVolumeID = 0; pvcd->dwMuteID = 0; pvcd->dwMixerID = 0; pvcd->dwMuxID = 0; // // advanced controls // for (iType = 0; iType < SIZEOF(dwAdvTypes); iType++) { mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = dwLineID; mxlc.dwControlType = dwAdvTypes[iType]; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls(hmx , &mxlc , MIXER_GETLINECONTROLSF_ONEBYTYPE); if (mmr == MMSYSERR_NOERROR) { pvcd->dwSupport |= VCD_SUPPORTF_MIXER_ADVANCED; break; } } // // stock controls // // // peakmeter // mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = dwLineID; mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_PEAKMETER; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls(hmx , &mxlc , MIXER_GETLINECONTROLSF_ONEBYTYPE); if (mmr == MMSYSERR_NOERROR) { pvcd->dwMeterID = mxc.dwControlID; pvcd->dwSupport |= VCD_SUPPORTF_MIXER_METER; pvcd->dwSupport |= Mixer_CheckBadDriver(hmx , &mxlc , &mxc , mxc.dwControlID , dwLineID); } // // mute // mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = dwLineID; mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls(hmx , &mxlc , MIXER_GETLINECONTROLSF_ONEBYTYPE); if (mmr == MMSYSERR_NOERROR) { pvcd->fdwMuteControl = mxc.fdwControl; pvcd->dwMuteID = mxc.dwControlID; pvcd->dwSupport |= VCD_SUPPORTF_MIXER_MUTE; pvcd->dwVisible |= VCD_VISIBLEF_MIXER_MUTE; pvcd->dwSupport |= Mixer_CheckBadDriver(hmx , &mxlc , &mxc , mxc.dwControlID , dwLineID); } // // volume // mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = dwLineID; mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls(hmx , &mxlc , MIXER_GETLINECONTROLSF_ONEBYTYPE); if (mmr == MMSYSERR_NOERROR) { pvcd->fdwVolumeControl = mxc.fdwControl; pvcd->dwVolumeID = mxc.dwControlID; pvcd->dwSupport |= VCD_SUPPORTF_MIXER_VOLUME; pvcd->dwSupport |= Mixer_CheckBadDriver(hmx , &mxlc , &mxc , mxc.dwControlID , dwLineID); } // // mixer // mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = dwLineID; mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MIXER; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls(hmx , &mxlc , MIXER_GETLINECONTROLSF_ONEBYTYPE); if (mmr == MMSYSERR_NOERROR) { pvcd->dwMixerID = mxc.dwControlID; pvcd->cMixer = mxc.cMultipleItems; pvcd->dwSupport |= VCD_SUPPORTF_MIXER_MIXER; pvcd->dwSupport |= Mixer_CheckBadDriver(hmx , &mxlc , &mxc , mxc.dwControlID , dwLineID); } // // mux // mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = dwLineID; mxlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MUX; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls(hmx , &mxlc , MIXER_GETLINECONTROLSF_ONEBYTYPE); if (mmr == MMSYSERR_NOERROR) { pvcd->dwMuxID = mxc.dwControlID; pvcd->cMux = mxc.cMultipleItems; pvcd->dwSupport |= VCD_SUPPORTF_MIXER_MUX; pvcd->dwSupport |= Mixer_CheckBadDriver(hmx , &mxlc , &mxc , mxc.dwControlID , dwLineID); } if (!(pvcd->dwSupport & ( VCD_SUPPORTF_MIXER_MUTE | VCD_SUPPORTF_MIXER_METER | VCD_SUPPORTF_MIXER_VOLUME))) { if (IsDestinationMux(hmx, dwLineID) && !(pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUX)) { // // Visible, and not hidden // pvcd->dwSupport |= VCD_SUPPORTF_VISIBLE; pvcd->dwSupport &= ~VCD_SUPPORTF_DEFAULT; } else { // // make it invisible in the UI. // pvcd->dwSupport |= VCD_SUPPORTF_HIDDEN; } } else { // // Visible, and not hidden // pvcd->dwSupport |= VCD_SUPPORTF_VISIBLE; } } /* * Mixer_CreateVolumeDescription * * */ PVOLCTRLDESC Mixer_CreateVolumeDescription( HMIXEROBJ hmx, int iDest, DWORD* pcvd ) { MMRESULT mmr; PVOLCTRLDESC pvcdPrev = NULL, pvcd = NULL; MIXERLINE mlDst; DWORD cLines = 0; DWORD dwSupport = 0L; UINT iSrc; int newDest=0; ZeroMemory(&mlDst, sizeof(mlDst)); mlDst.cbStruct = sizeof(mlDst); mlDst.dwDestination = iDest; mmr = mixerGetLineInfo(hmx , &mlDst , MIXER_GETLINEINFOF_DESTINATION); if(!mlDst.cConnections) { //No lines to list. Try with a different mixer ID. GetDestination(0, &newDest); mlDst.dwDestination = newDest; mmr = mixerGetLineInfo(hmx , &mlDst , MIXER_GETLINEINFOF_DESTINATION); //Even if we do not get any connections here lets continue. Nothing more we can do. //This will be taken care of before opening the dialog. } if (mmr == MMSYSERR_NOERROR) { if (mlDst.cChannels == 1L) dwSupport |= VCD_SUPPORTF_MONO; if (mlDst.fdwLine & MIXERLINE_LINEF_DISCONNECTED) dwSupport |= VCD_SUPPORTF_DISABLED; // // a default type // dwSupport |= VCD_SUPPORTF_DEFAULT; } else { // // we need to add it anyway s.t. a UI comes up // dwSupport = VCD_SUPPORTF_DISABLED; } pvcd = PVCD_AddLine(NULL , iDest , VCD_TYPE_MIXER , mlDst.szShortName , mlDst.szName , dwSupport , &cLines ); if (!pvcd) return NULL; Mixer_InitLineControls( hmx, pvcd, mlDst.dwLineID ); pvcdPrev = pvcd; for (iSrc = 0; iSrc < mlDst.cConnections; iSrc++) { MIXERLINE mlSrc; mlSrc.cbStruct = sizeof(mlSrc); mlSrc.dwDestination = iDest; mlSrc.dwSource = iSrc; mmr = mixerGetLineInfo(hmx , &mlSrc , MIXER_GETLINEINFOF_SOURCE); dwSupport = 0L; if (mmr == MMSYSERR_NOERROR) { if (mlSrc.cChannels == 1L) { dwSupport |= VCD_SUPPORTF_MONO; } if (mlSrc.fdwLine & MIXERLINE_LINEF_DISCONNECTED) dwSupport |= VCD_SUPPORTF_DISABLED; // // Mark these types as "default" just to lessen the shock on // some advanced sound cards. // if (mlDst.dwComponentType == MIXERLINE_COMPONENTTYPE_DST_SPEAKERS || mlDst.dwComponentType == MIXERLINE_COMPONENTTYPE_DST_HEADPHONES) { switch (mlSrc.dwComponentType) { case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT: case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC: case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER: case MIXERLINE_COMPONENTTYPE_SRC_LINE: dwSupport |= VCD_SUPPORTF_DEFAULT; break; } } else if (mlDst.dwComponentType == MIXERLINE_COMPONENTTYPE_DST_WAVEIN || mlDst.dwComponentType == MIXERLINE_COMPONENTTYPE_DST_VOICEIN) { switch (mlSrc.dwComponentType) { case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE: case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC: case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER: case MIXERLINE_COMPONENTTYPE_SRC_LINE: case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED: dwSupport |= VCD_SUPPORTF_DEFAULT; break; } } } else { // // we need to add it anyway s.t. lookups aren't under counted // dwSupport = VCD_SUPPORTF_DISABLED; } pvcd = PVCD_AddLine(pvcdPrev , iDest , VCD_TYPE_MIXER , mlSrc.szShortName , mlSrc.szName , dwSupport , &cLines ); if (pvcd) { Mixer_InitLineControls( hmx, &pvcd[cLines-1], mlSrc.dwLineID ); pvcdPrev = pvcd; } } // // Fixup dependencies // Mixer_SetLines(hmx, pvcdPrev, cLines); *pcvd = cLines; return pvcdPrev; } /* * Mixer_IsValidRecordingDestination * * */ BOOL Mixer_IsValidRecordingDestination (HMIXEROBJ hmx, MIXERLINE* pmlDst) { BOOL fReturn = FALSE; if (pmlDst && MIXERLINE_COMPONENTTYPE_DST_WAVEIN == pmlDst -> dwComponentType) { UINT uiSrc; MIXERLINE mlSrc; for (uiSrc = 0; uiSrc < pmlDst -> cConnections; uiSrc++) { mlSrc.cbStruct = sizeof (mlSrc); mlSrc.dwDestination = pmlDst -> dwDestination; mlSrc.dwSource = uiSrc; if (SUCCEEDED (mixerGetLineInfo (hmx, &mlSrc, MIXER_GETLINEINFOF_SOURCE))) { switch (mlSrc.dwComponentType) { case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE: case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC: case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER: case MIXERLINE_COMPONENTTYPE_SRC_LINE: case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED: fReturn = TRUE; break; } } } } return fReturn; } /* * Mixer_CleanupVolumeDescription * * */ void Mixer_CleanupVolumeDescription( PVOLCTRLDESC avcd, DWORD cvcd) { if (cvcd == 0) return; if (avcd[0].pdblCacheMix) { GlobalFreePtr(avcd[0].pdblCacheMix); } if (avcd[0].dwSupport & VCD_SUPPORTF_MIXER_MIXER) { if (avcd[0].amcd_bMixer) GlobalFreePtr(avcd[0].amcd_bMixer); } if (avcd[0].dwSupport & VCD_SUPPORTF_MIXER_MUX) { if (avcd[0].amcd_bMux) GlobalFreePtr(avcd[0].amcd_bMux); } } /***************************************************************************** * * ACTIVE GET/SET CODE * *****************************************************************************/ static MMRESULT Mixer_GetMixerLineInfo( HMIXEROBJ hmx, // handle to mixer LPMIXERLINE pml, // Returns destination info DWORD dwLineID // ) { if (!pml || !hmx) return MMSYSERR_INVALPARAM; // Get mixerline info ZeroMemory( pml, sizeof(*pml) ); pml->cbStruct = sizeof(*pml); pml->dwLineID = dwLineID; return (mixerGetLineInfo (hmx, pml, MIXER_GETLINEINFOF_LINEID)); } /* * Mixer_GetMixerVolume * * */ static MMRESULT Mixer_GetMixerVolume( PMIXUIDIALOG pmxud, // app instance PVOLCTRLDESC pvcd, // volume to change MIXERCONTROLDETAILS_UNSIGNED* pmcdVolume, // array for volume levels LPDWORD lpSize // size of array (or return size needed) ) { MMRESULT mmr; MIXERLINE ml; MIXERCONTROLDETAILS mxcd; DWORD cChannels; if (!lpSize || !pmxud) return MMSYSERR_INVALPARAM; // Get mixerline info if (pvcd->fdwVolumeControl & MIXERCONTROL_CONTROLF_UNIFORM) { cChannels = 1; } else { mmr = Mixer_GetMixerLineInfo ((HMIXEROBJ)(pmxud->hmx), &ml, pvcd->dwLineID); if (MMSYSERR_NOERROR != mmr) { return mmr; } cChannels = ml.cChannels; } if (!pmcdVolume) { // Just return size needed *lpSize = cChannels * sizeof (MIXERCONTROLDETAILS_UNSIGNED); return MMSYSERR_NOERROR; } else { // Verify passed array size if (*lpSize < cChannels * sizeof (MIXERCONTROLDETAILS_UNSIGNED)) return MMSYSERR_INVALPARAM; } // Get volume levels ZeroMemory (&mxcd, sizeof (mxcd)); mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pvcd->dwVolumeID; mxcd.cChannels = cChannels; mxcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED); mxcd.paDetails = (LPVOID) pmcdVolume; mmr = mixerGetControlDetails((HMIXEROBJ)(pmxud->hmx), &mxcd, MIXER_OBJECTF_HANDLE | MIXER_GETCONTROLDETAILSF_VALUE); return mmr; } static MMRESULT Mixer_Mute( HMIXEROBJ hmx, PVOLCTRLDESC pvcd, PMIXERCONTROLDETAILS pmxcd, DWORD fMute) { MIXERLINE ml; DWORD cChannels; DWORD dwSize; LPDWORD lpdwCurrent; UINT uiIndx; MMRESULT mmr; // Check the parameters if (!hmx || !pvcd || !pmxcd) return MMSYSERR_INVALPARAM; // Get mixerline info if (pvcd->fdwMuteControl & MIXERCONTROL_CONTROLF_UNIFORM) { cChannels = 1; } else { mmr = Mixer_GetMixerLineInfo(hmx, &ml, pvcd->dwLineID); if (MMSYSERR_NOERROR != mmr) { return mmr; } cChannels = ml.cChannels; } dwSize = (DWORD)(cChannels * sizeof(DWORD)); pmxcd->paDetails = LocalAlloc (LPTR, dwSize); if (!pmxcd->paDetails) return MMSYSERR_NOMEM; for (uiIndx = 0; uiIndx < cChannels; uiIndx++) { lpdwCurrent = ((LPDWORD)pmxcd->paDetails + uiIndx); *lpdwCurrent = fMute; } pmxcd->cbStruct = sizeof(*pmxcd); pmxcd->dwControlID = pvcd->dwMuteID ; pmxcd->cChannels = cChannels; pmxcd->cMultipleItems = 0; pmxcd->cbDetails = sizeof(DWORD); mmr = mixerSetControlDetails(hmx , pmxcd , MIXER_SETCONTROLDETAILSF_VALUE); LocalFree (pmxcd->paDetails); return mmr; } /* * Mixer_GetControl * * Change a UI control in response to a device or initialization event * * */ void Mixer_GetControl( PMIXUIDIALOG pmxud, HWND hctl, int imxul, int itype) { PMIXUILINE pmxul = &pmxud->amxul[imxul]; PVOLCTRLDESC pvcd = pmxul->pvcd; DWORD dwID = 0L; BOOL fSet = FALSE; switch (itype) { case MIXUI_VUMETER: fSet = (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_METER); if (fSet) dwID = pmxul->pvcd->dwMeterID; break; case MIXUI_SWITCH: fSet = (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUTE) && (pmxul->pvcd->dwVisible & VCD_VISIBLEF_MIXER_MUTE); if (fSet) { dwID = pmxul->pvcd->dwMuteID; break; } fSet = (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUX) && (pmxul->pvcd->dwVisible & VCD_VISIBLEF_MIXER_MUX); if (fSet) { dwID = pmxul->pvcd->dwMuxID; break; } fSet = (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_MIXER) && (pmxul->pvcd->dwVisible & VCD_VISIBLEF_MIXER_MIXER); if (fSet) { dwID = pmxul->pvcd->dwMixerID; break; } break; case MIXUI_VOLUME: case MIXUI_BALANCE: fSet = (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_VOLUME); if (fSet) dwID = pmxul->pvcd->dwVolumeID; break; default: return; } if (fSet) Mixer_GetControlFromID(pmxud, dwID); } /* * Mixer_SetVolume * * - Change a mixerControl in response to a user event * */ MMRESULT Mixer_SetVolume ( PMIXUIDIALOG pmxud, // app instance PVOLCTRLDESC pvcd, // volume to change DWORD dwVolume, // volume value VOLUME_MAX to VOLUME_MIN LPDWORD lpdwBalance // Balance desired (NULL == No Balance) 0 to 64 ) { MIXERLINE ml; DWORD cChannels; DWORD dwSize; MIXERCONTROLDETAILS_UNSIGNED* pmcdVolume; MMRESULT mmr; // Check the parameters if ( !pvcd || !pmxud || (dwVolume > VOLUME_MAX) ) return MMSYSERR_INVALPARAM; // Find needed buffer size for volumes if (pvcd->fdwVolumeControl & MIXERCONTROL_CONTROLF_UNIFORM) { cChannels = 1; } else { mmr = Mixer_GetMixerLineInfo ((HMIXEROBJ)(pmxud->hmx), &ml, pvcd->dwLineID); if (MMSYSERR_NOERROR != mmr) { return mmr; } cChannels = ml.cChannels; } dwSize = (DWORD)(cChannels * sizeof (MIXERCONTROLDETAILS_UNSIGNED)); // Create volume buffer pmcdVolume = LocalAlloc (LPTR, dwSize); if (!pmcdVolume) return MMSYSERR_NOMEM; // Note: From here on, do not return without releasing 'pmcdVolume'. mmr = Mixer_GetMixerVolume (pmxud, pvcd, pmcdVolume, &dwSize); if (MMSYSERR_NOERROR == mmr) { MIXERCONTROLDETAILS mcd; ZeroMemory (&mcd, sizeof (mcd)); // Create volume mix cache if necessary // if we have no cache we make one of course // other wise we first check that not all the volumes of the channels are equal to zero if (!pvcd->pdblCacheMix || !Mixer_AreChannelsAtMinimum(pmcdVolume,cChannels)) { Mixer_RefreshMixCache (pvcd, pmcdVolume, cChannels); } // Create volume buffer for new values mcd.paDetails = LocalAlloc (LPTR, dwSize); if (!mcd.paDetails || !pvcd->pdblCacheMix) mmr = MMSYSERR_NOMEM; // Caculate the new volume & balance if (MMSYSERR_NOERROR == mmr) { UINT uiIndx; MIXERCONTROLDETAILS_UNSIGNED* pmcdCurrent; // Account for Balance (only for Stereo) if ( lpdwBalance && (cChannels == 2) && (*lpdwBalance <= 64) ) { MIXERCONTROLDETAILS_UNSIGNED* pmcdLeft = ((MIXERCONTROLDETAILS_UNSIGNED*)mcd.paDetails); MIXERCONTROLDETAILS_UNSIGNED* pmcdRight = ((MIXERCONTROLDETAILS_UNSIGNED*)mcd.paDetails + 1); long lBalance = *lpdwBalance; lBalance -= 32; // -32 to 32 range // Caculate volume based on balance and refresh mix cache if (lBalance > 0) // Balance Right { // Left if (lBalance == 32) // Pegged Right pmcdLeft -> dwValue = 0; else pmcdLeft -> dwValue = dwVolume - (lBalance * (dwVolume - VOLUME_MIN))/32; // Right pmcdRight -> dwValue = dwVolume; } if (lBalance < 0) // Balance Left { // Left pmcdLeft -> dwValue = dwVolume; // Right if (lBalance == -32) // Pegged Left pmcdRight -> dwValue = 0; else pmcdRight -> dwValue = dwVolume - (-lBalance * (dwVolume - VOLUME_MIN))/32; } if (lBalance == 0) // Balance Centered { // Left pmcdLeft -> dwValue = dwVolume; // Right pmcdRight -> dwValue = dwVolume; } Mixer_RefreshMixCache (pvcd, mcd.paDetails, cChannels); } else { // Caculate the new volume level for each of the channels. For volume levels // at the current max, we simply set the newly requested level (in this case // the cache value is 1.0). For those less than the max, we set a value that // is a percentage of the max. This maintains the relative distance of the // channel levels from each other. for (uiIndx = 0; uiIndx < cChannels; uiIndx++) { pmcdCurrent = ((MIXERCONTROLDETAILS_UNSIGNED*)mcd.paDetails + uiIndx); // The 0.5f forces rounding (instead of truncation) pmcdCurrent -> dwValue = (DWORD)(*(pvcd->pdblCacheMix + uiIndx) * (double) dwVolume + 0.5f); } } mcd.cbStruct = sizeof (mcd); mcd.dwControlID = pvcd -> dwVolumeID; mcd.cChannels = cChannels; mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED); // seems like it would be sizeof(mcd.paDetails), // but actually, it is the size of a single value // and is multiplied by channel in the driver. // Apply new value only if it is different. This prevents unessary calls to // mixerSetControlDetails() when we are pegged. if (memcmp (pmcdVolume, mcd.paDetails, dwSize)) { mixerSetControlDetails ((HMIXEROBJ)(pmxud->hmx), &mcd, MIXER_SETCONTROLDETAILSF_VALUE); } } // Free new volume array if (mcd.paDetails) LocalFree (mcd.paDetails); } // Free volume array LocalFree (pmcdVolume); return mmr; } /* * Mixer_GetControlFromID * * */ void Mixer_GetControlFromID( PMIXUIDIALOG pmxud, DWORD dwControlID) { MIXERLINE mxl; MIXERLINECONTROLS mxlc; MIXERCONTROL mxc; MIXERCONTROLDETAILS mxcd; PMIXUILINE pmxul; PMIXUICTRL pmxuc; PVOLCTRLDESC pvcd; DWORD ivcd; BOOL fBarf = FALSE; MMRESULT mmr; // // Retrieve the control information // mxlc.cbStruct = sizeof(mxlc); mxlc.dwControlID = dwControlID; mxlc.cControls = 1; mxlc.cbmxctrl = sizeof(mxc); mxlc.pamxctrl = &mxc; mmr = mixerGetLineControls((HMIXEROBJ)(pmxud->hmx) , &mxlc , MIXER_GETLINECONTROLSF_ONEBYID); if (mmr != MMSYSERR_NOERROR) return; if (!(pmxud->dwFlags & MXUD_FLAGSF_BADDRIVER)) { // // The *correct* code for this lookup using the mixer API. // // Is this our current destination line? // mxl.cbStruct = sizeof(mxl); mxl.dwLineID = mxlc.dwLineID; mmr = mixerGetLineInfo((HMIXEROBJ)(pmxud->hmx) , &mxl , MIXER_GETLINEINFOF_LINEID); if (mmr != MMSYSERR_NOERROR) return; if (mxl.dwDestination != pmxud->iDest) return; // // Is this a source line or a destination line? // ivcd = (mxl.fdwLine & MIXERLINE_LINEF_SOURCE)? 1 + mxl.dwSource : 0; pvcd = &pmxud->avcd[ivcd]; // // a bad driver was detected! // if (pvcd->dwLineID != mxlc.dwLineID) { pmxud->dwFlags |= MXUD_FLAGSF_BADDRIVER; } } if (pmxud->dwFlags & MXUD_FLAGSF_BADDRIVER) { PVOLCTRLDESC pvcdTmp; // // take evasive action if this was a bad driver by doing a brute force // search. // pvcd = NULL; for (ivcd = 0; ivcd < pmxud->cvcd; ivcd ++) { pvcdTmp = &pmxud->avcd[ivcd]; if ( ( (pvcdTmp->dwSupport & VCD_SUPPORTF_MIXER_VOLUME) && pvcdTmp->dwVolumeID == dwControlID ) || ( (pvcdTmp->dwSupport & VCD_SUPPORTF_MIXER_MUTE) && pvcdTmp->dwMuteID == dwControlID ) || ( (pvcdTmp->dwSupport & VCD_SUPPORTF_MIXER_MIXER) && pvcdTmp->dwMixerID == dwControlID ) || ( (pvcdTmp->dwSupport & VCD_SUPPORTF_MIXER_MUX) && pvcdTmp->dwMuxID == dwControlID ) || ( (pvcdTmp->dwSupport & VCD_SUPPORTF_MIXER_METER) && pvcdTmp->dwMeterID == dwControlID ) ) { pvcd = pvcdTmp; break; } } if (pvcd == NULL) return; } pmxul = pvcd->pmxul; // // Go through our visible lines to determine if this control affects // any visible control and change them. // switch (mxc.dwControlType) { case MIXERCONTROL_CONTROLTYPE_VOLUME: { MIXERCONTROLDETAILS_UNSIGNED* pmcdVolume; DWORD cChannels; DWORD dwSize; MIXERLINE ml; // // A nonvisible line should be shunned // if (pmxul == NULL) return; // Find needed buffer size for volumes if (pvcd->fdwVolumeControl & MIXERCONTROL_CONTROLF_UNIFORM) { cChannels = 1; } else { mmr = Mixer_GetMixerLineInfo ((HMIXEROBJ)(pmxud->hmx), &ml, pvcd->dwLineID); if (MMSYSERR_NOERROR != mmr) { return; } cChannels = ml.cChannels; } dwSize = (DWORD)(cChannels * sizeof (MIXERCONTROLDETAILS_UNSIGNED)); // Create volume buffer pmcdVolume = LocalAlloc (LPTR, dwSize); if (!pmcdVolume) return; // Note : Do not return without releasing 'pmcdVolume'. if (Mixer_GetMixerVolume (pmxud, pvcd, pmcdVolume, &dwSize) == MMSYSERR_NOERROR) { UINT uindx; DWORD dwVolume; DWORD dwMax = 0; // Set Volume slider for (uindx = 0; uindx < cChannels; uindx++) dwMax = max (dwMax, (pmcdVolume + uindx) -> dwValue); dwVolume = VOLUME_TO_SLIDER(dwMax); dwVolume = VOLUME_TICS - dwVolume; pmxuc = &pmxul->acr[MIXUI_VOLUME]; if (pmxuc->state) { SendMessage(pmxuc->hwnd, TBM_SETPOS, TRUE, dwVolume); } // Set Balance Slider pmxuc = &pmxul->acr[MIXUI_BALANCE]; if (dwVolume < VOLUME_TICS && pmxuc->state && 2 >= cChannels) { long lBalance; double dblBalance; if (1 >= cChannels) lBalance = 0; else { // Stereo dblBalance = (double)(32 * (long)(pmcdVolume -> dwValue - (pmcdVolume + 1) -> dwValue)) / (double)(dwMax - VOLUME_MIN); lBalance = (long)((32.0F - dblBalance) + 0.5F); // 0.5 forces rounding } SendMessage(pmxuc->hwnd, TBM_SETPOS, TRUE, lBalance); } } LocalFree (pmcdVolume); break; } case MIXERCONTROL_CONTROLTYPE_MIXER: { DWORD i; mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pvcd->dwMixerID ; mxcd.cChannels = 1; mxcd.cMultipleItems = pvcd->cMixer; mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN); mxcd.paDetails = (LPVOID)pvcd->amcd_bMixer; mmr = mixerGetControlDetails((HMIXEROBJ)(pmxud->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr == MMSYSERR_NOERROR) { for (i = 0; i < pmxud->cvcd; i++) { pvcd = &pmxud->avcd[i]; if ( (pvcd->dwSupport & VCD_SUPPORTF_MIXER_MIXER) && (pvcd->dwVisible & VCD_VISIBLEF_MIXER_MIXER) && pvcd->pmxul) { pmxuc = &pvcd->pmxul->acr[MIXUI_SWITCH]; if (pmxuc->state == MIXUI_CONTROL_INITIALIZED) { SendMessage(pmxuc->hwnd , BM_SETCHECK , pvcd->amcd_bMixer[pvcd->iMixer].fValue, 0); } } } } break; } case MIXERCONTROL_CONTROLTYPE_MUX: { DWORD i; mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pvcd->dwMuxID ; mxcd.cChannels = 1; mxcd.cMultipleItems = pvcd->cMux; mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN); mxcd.paDetails = (LPVOID)pvcd->amcd_bMux; mmr = mixerGetControlDetails((HMIXEROBJ)(pmxud->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr == MMSYSERR_NOERROR) { for (i = 0; i < pmxud->cvcd; i++) { pvcd = &pmxud->avcd[i]; if ( (pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUX) && (pvcd->dwVisible & VCD_VISIBLEF_MIXER_MUX) && pvcd->pmxul) { pmxuc = &pvcd->pmxul->acr[MIXUI_SWITCH]; if (pmxuc->state == MIXUI_CONTROL_INITIALIZED) SendMessage(pmxuc->hwnd , BM_SETCHECK , pvcd->amcd_bMux[pvcd->iMux].fValue, 0); } } } break; } case MIXERCONTROL_CONTROLTYPE_MUTE: { DWORD fChecked; // // A nonvisible line should be shunned // if (pmxul == NULL) return; if (! (pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUTE && pvcd->dwVisible & VCD_VISIBLEF_MIXER_MUTE)) return; pmxuc = &pmxul->acr[MIXUI_SWITCH]; if (pmxuc->state != MIXUI_CONTROL_INITIALIZED) break; mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pvcd->dwMuteID; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&fChecked; mmr = mixerGetControlDetails((HMIXEROBJ)(pmxud->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr != MMSYSERR_NOERROR) break; SendMessage(pmxuc->hwnd, BM_SETCHECK, fChecked, 0); break; } case MIXERCONTROL_CONTROLTYPE_PEAKMETER: { LONG lVol; DWORD dwVol; // // A nonvisible line should be shunned // if (pmxul == NULL) return; pmxuc = &pmxul->acr[MIXUI_VUMETER]; if (pmxuc->state != MIXUI_CONTROL_INITIALIZED) break; mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pvcd->dwMeterID; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&lVol; mmr = mixerGetControlDetails((HMIXEROBJ)(pmxud->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr != MMSYSERR_NOERROR) break; dwVol = (DWORD)abs(lVol); dwVol = (VOLUME_TICS * dwVol) / 32768; SendMessage(pmxuc->hwnd, VU_SETPOS, 0, dwVol); break; } default: return; } } /* * Mixer_SetControl * * - Change a mixerControl in response to a user event * */ void Mixer_SetControl( PMIXUIDIALOG pmxud, // app instance HWND hctl, // hwnd of control that changed int iLine, // visible line index of control that changed int iCtl) // control id%line of control that changed { MMRESULT mmr; MIXERCONTROLDETAILS mxcd; PMIXUILINE pmxul; PMIXUICTRL pmxuc; PVOLCTRLDESC pvcd = NULL; if ((DWORD)iLine >= pmxud->cmxul) return; pmxul = &pmxud->amxul[iLine]; pvcd = pmxul->pvcd; if (iCtl <= MIXUI_LAST) { pmxuc = &pmxul->acr[iCtl]; } switch (iCtl) { case MIXUI_ADVANCED: Mixer_Advanced(pmxud, pvcd->dwLineID, pvcd->szName); break; case MIXUI_MULTICHANNEL: // Note: This will always be true: // (MXUL_STYLEF_DESTINATION & pmxul->dwStyle) Mixer_Multichannel(pmxud, pvcd->dwVolumeID); break; case MIXUI_VOLUME: case MIXUI_BALANCE: { // Make sure we have a volume slider if ( pmxul->acr[MIXUI_VOLUME].state != MIXUI_CONTROL_UNINITIALIZED) { DWORD dwVolume; DWORD dwBalance; LPDWORD lpdwBalance = NULL; dwVolume = (DWORD)SendMessage( pmxul->acr[MIXUI_VOLUME].hwnd , TBM_GETPOS , 0 , 0 ); dwVolume = VOLUME_TICS - dwVolume; dwVolume = SLIDER_TO_VOLUME(dwVolume); // See if we have a balance slider as well if ( pmxul->acr[MIXUI_BALANCE].state != MIXUI_CONTROL_UNINITIALIZED) { dwBalance = (DWORD)SendMessage(pmxul->acr[MIXUI_BALANCE].hwnd , TBM_GETPOS , 0 , 0); lpdwBalance = &dwBalance; } Mixer_SetVolume (pmxud, pvcd, dwVolume, lpdwBalance); } break; } case MIXUI_SWITCH: { LONG fChecked; if (pmxuc->state != MIXUI_CONTROL_INITIALIZED) break; fChecked = (LONG)SendMessage(pmxuc->hwnd, BM_GETCHECK, 0, 0); // // it's unlikely that there is a mixer and a mux and a mute // representing the same line. It's most important that when a line // is selected that the user gets a response. If there is a mute // but no mux, then mute and mixer should be OFF and ON // respectively and vice versa. If there is a mux and a mute the // same is true. // If there is a mux and a mixer... then the mux select should // correspond. // if ( pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUTE && pvcd->dwVisible & VCD_VISIBLEF_MIXER_MUTE ) { mmr = Mixer_Mute((HMIXEROBJ)(pmxud->hmx), pvcd, &mxcd, fChecked); } if (pvcd->dwSupport & VCD_SUPPORTF_MIXER_MIXER && pvcd->dwVisible & VCD_VISIBLEF_MIXER_MIXER ) { // // get all other mixer settings, make sure this one is checked // mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pvcd->dwMixerID ; mxcd.cChannels = 1; mxcd.cMultipleItems = pvcd->cMixer; mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN); mxcd.paDetails = (LPVOID)pvcd->amcd_bMixer; mmr = mixerGetControlDetails((HMIXEROBJ)(pmxud->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr == MMSYSERR_NOERROR) { pvcd->amcd_bMixer[pvcd->iMixer].fValue = fChecked; mmr = mixerSetControlDetails((HMIXEROBJ)(pmxud->hmx) , &mxcd , MIXER_SETCONTROLDETAILSF_VALUE); } if (fChecked && pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUTE) { mmr = Mixer_Mute((HMIXEROBJ)(pmxud->hmx), pvcd, &mxcd, FALSE); } } if (pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUX && pvcd->dwVisible & VCD_VISIBLEF_MIXER_MUX ) { DWORD i; // // get all other mux settings, make sure this one is checked // or unchecked and all others are not. // for (i = 0; i < pvcd->cMux; i++) pvcd->amcd_bMux[i].fValue = FALSE; pvcd->amcd_bMux[pvcd->iMux].fValue = TRUE; mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pvcd->dwMuxID ; mxcd.cChannels = 1; mxcd.cMultipleItems = pvcd->cMux; mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN); mxcd.paDetails = (LPVOID)pvcd->amcd_bMux; mmr = mixerSetControlDetails((HMIXEROBJ)(pmxud->hmx) , &mxcd , MIXER_SETCONTROLDETAILSF_VALUE); if (fChecked && pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUTE) { mmr = Mixer_Mute((HMIXEROBJ)(pmxud->hmx), pvcd, &mxcd, FALSE); } } break; } default: break; } } /* * Mixer_PollingUpdate * * Controls that need to be updated by a timer. * * */ void Mixer_PollingUpdate( PMIXUIDIALOG pmxud) { DWORD i; MMRESULT mmr; MIXERLINE mxl; // // For all visible mixer lines, locate the control id's that need to be // updated. // for (i = 0; i < pmxud->cmxul; i++) { PMIXUICTRL pmxuc = &pmxud->amxul[i].acr[MIXUI_VUMETER]; PVOLCTRLDESC pvcd = pmxud->amxul[i].pvcd; if (pmxuc->state == MIXUI_CONTROL_UNINITIALIZED) continue; if (!(pvcd->dwSupport & VCD_SUPPORTF_MIXER_METER)) continue; // // Is the line active? // mxl.cbStruct = sizeof(MIXERLINE); mxl.dwLineID = pvcd->dwLineID; mmr = mixerGetLineInfo((HMIXEROBJ)(pmxud->hmx) , &mxl , MIXER_GETLINEINFOF_LINEID); // // Force non active or invalid lines to 0 // if (mmr != MMSYSERR_NOERROR || !(mxl.fdwLine & MIXERLINE_LINEF_ACTIVE)) { SendMessage(pmxuc->hwnd, VU_SETPOS, 0, 0L); continue; } // // Force a visible update // Mixer_GetControlFromID(pmxud, pvcd->dwMeterID); } } void ShowAndEnableWindow (HWND hWnd, BOOL fEnable) { ShowWindow (hWnd, fEnable ? SW_SHOW : SW_HIDE); EnableWindow (hWnd, fEnable); } /* * Mixer_Init * * Control initialization * */ BOOL Mixer_Init( PMIXUIDIALOG pmxud) { MMRESULT mmr; MIXERLINE mlDst; DWORD iline; TCHAR achFmt[256]; TCHAR achTitle[256]; TCHAR achAccessible[256]; int x; ZeroMemory (achFmt, sizeof (achFmt)); // Inital value for prefix mmr = mixerOpen((LPHMIXER)&pmxud->hmx , pmxud->mxid , (DWORD_PTR)pmxud->hwnd , 0 , CALLBACK_WINDOW); if (mmr != MMSYSERR_NOERROR) { return FALSE; } else { DeviceChange_Init(pmxud->hwnd, pmxud->mxid); } if (mixerMessage((HMIXER)ULongToPtr(pmxud->mxid), DRV_QUERYDEVNODE, (DWORD_PTR)&pmxud->dwDevNode, 0L)) pmxud->dwDevNode = 0L; LoadString(pmxud->hInstance, IDS_APPTITLE, achFmt, SIZEOF(achFmt)); mlDst.cbStruct = sizeof ( mlDst ); mlDst.dwDestination = pmxud->iDest; mmr = mixerGetLineInfo((HMIXEROBJ)ULongToPtr(pmxud->mxid) , &mlDst , MIXER_GETLINEINFOF_DESTINATION); if (mmr == MMSYSERR_NOERROR) { lstrcpy(achTitle, mlDst.szName); } else { LoadString(pmxud->hInstance, IDS_APPBASE, achTitle, SIZEOF(achTitle)); } SetWindowText(pmxud->hwnd, achTitle); // // since we cannot get a WM_PARENTNOTIFY, we need to run through // all controls and make appropriate modifications. // for ( iline = 0 ; iline < pmxud->cmxul ; iline++ ) { PMIXUILINE pmxul = &pmxud->amxul[iline]; PMIXUICTRL amxuc = pmxul->acr; HWND ctrl; ctrl = Volume_GetLineItem(pmxud->hwnd, iline, IDC_LINELABEL); if (ctrl) { if (pmxud->dwStyle & MXUD_STYLEF_SMALL) Static_SetText(ctrl, pmxul->pvcd->szShortName); else Static_SetText(ctrl, pmxul->pvcd->szName); } // for MSAA (accessibility), we need to put the control name on the sliders for (x = IDC_ACCESS_BALANCE; x <= IDC_ACCESS_VOLUME; x++) { ctrl = Volume_GetLineItem(pmxud->hwnd, iline, x); if (ctrl) { Static_GetText(ctrl, achFmt, sizeof(achFmt)/sizeof(TCHAR)); if (pmxud->dwStyle & MXUD_STYLEF_SMALL) { wsprintf(achAccessible,achFmt,pmxul->pvcd->szShortName); Static_SetText(ctrl, achAccessible); } else { wsprintf(achAccessible,achFmt,pmxul->pvcd->szName); Static_SetText(ctrl, achAccessible); } } } // // Master Control Multichannel Support // // Init multichannel support for master control if available. Note that if a master // control exisits on the dialog, it is currently in the first position, but we do // NOT rely on that fact here. // Note: Not only must there be multiple channels, but Volume must also be // Supported to manipulate the channels. if (mlDst.cChannels > 2L && MXUL_STYLEF_DESTINATION & pmxul->dwStyle && pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_VOLUME) { int idc; for (idc = IDC_MASTER_BALANCE_ICON_2; idc >= IDC_MULTICHANNEL; idc--) { ctrl = Volume_GetLineItem (pmxud->hwnd, iline, idc); if (ctrl) ShowAndEnableWindow (ctrl, (IDC_MULTICHANNEL == idc)); } ctrl = Volume_GetLineItem (pmxud->hwnd, iline, IDC_BALANCE); if (ctrl) ShowAndEnableWindow (ctrl, FALSE); switch (mlDst.dwComponentType) { case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS: // No Change break; case MIXERLINE_COMPONENTTYPE_DST_WAVEIN: case MIXERLINE_COMPONENTTYPE_DST_VOICEIN: // Recording LoadString(pmxud->hInstance, IDS_MC_RECORDING, achFmt, SIZEOF(achFmt)); SetWindowText (ctrl, achFmt); break; default: // Anything else... LoadString(pmxud->hInstance, IDS_MC_LEVEL, achFmt, SIZEOF(achFmt)); SetWindowText (ctrl, achFmt); break; } } // // Advanced escape // if (MXUD_ADVANCED(pmxud) && !(pmxud->dwStyle & MXUD_STYLEF_SMALL)) { HWND hadv = Volume_GetLineItem(pmxud->hwnd, iline, IDC_ADVANCED); if (hadv) { ShowWindow(hadv,(pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_ADVANCED)?SW_SHOW:SW_HIDE); EnableWindow(hadv, (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_ADVANCED)?TRUE:FALSE); } } if (pmxul->pvcd->dwSupport & VCD_SUPPORTF_DISABLED) continue; // // allow init of control structures // if (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_VOLUME) { amxuc[MIXUI_VOLUME].state = MIXUI_CONTROL_ENABLED; if (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MONO) { amxuc[MIXUI_BALANCE].state = MIXUI_CONTROL_UNINITIALIZED; } else amxuc[MIXUI_BALANCE].state = MIXUI_CONTROL_ENABLED; } if (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_METER) amxuc[MIXUI_VUMETER].state = MIXUI_CONTROL_ENABLED; if (pmxul->pvcd->dwSupport & VCD_SUPPORTF_MIXER_MUTE) amxuc[MIXUI_SWITCH].state = MIXUI_CONTROL_ENABLED; if ((pmxul->pvcd->dwSupport & ( VCD_SUPPORTF_MIXER_MIXER | VCD_SUPPORTF_MIXER_MUX)) && (pmxul->pvcd->dwVisible & ( VCD_VISIBLEF_MIXER_MIXER | VCD_VISIBLEF_MIXER_MUX))) { // // No longer make the mute visible // pmxul->pvcd->dwVisible &= ~VCD_VISIBLEF_MIXER_MUTE; amxuc[MIXUI_SWITCH].state = MIXUI_CONTROL_ENABLED; ctrl = Volume_GetLineItem(pmxud->hwnd, iline, IDC_SWITCH); if (ctrl) { TCHAR ach[256]; if (LoadString(pmxud->hInstance, IDS_SELECT, ach, SIZEOF(ach))) Button_SetText(ctrl, ach); } } } return TRUE; } /* * Mixer_Shutdown * * Close handles, etc.. * */ void Mixer_Shutdown( PMIXUIDIALOG pmxud) { if (pmxud->hmx) { mixerClose(pmxud->hmx); pmxud->hmx = NULL; } Mixer_CleanupVolumeDescription(pmxud->avcd, pmxud->cvcd); } /* - - - - - - - - - */ typedef struct tagAdv { PMIXUIDIALOG pmxud; // IN DWORD dwLineID; // IN HMIXER hmx; // IN LPTSTR szName; // IN DWORD dwSupport; DWORD dwBassID; DWORD dwTrebleID; DWORD dwSwitch1ID; DWORD dwSwitch2ID; } ADVPARAM, *PADVPARAM; #define GETPADVPARAM(x) (ADVPARAM *)GetWindowLongPtr(x, DWLP_USER) #define SETPADVPARAM(x,y) SetWindowLongPtr(x, DWLP_USER, y) #define ADV_HAS_BASS 0x00000001 #define ADV_HAS_TREBLE 0x00000002 #define ADV_HAS_SWITCH1 0x00000004 #define ADV_HAS_SWITCH2 0x00000008 void Mixer_Advanced_Update( PADVPARAM pap, HWND hwnd) { MIXERCONTROLDETAILS mxcd; DWORD dwValue = 0; MMRESULT mmr; if (pap->dwSupport & ADV_HAS_TREBLE) { mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pap->dwTrebleID ; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&dwValue; mmr = mixerGetControlDetails((HMIXEROBJ)(pap->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr == MMSYSERR_NOERROR) { dwValue = VOLUME_TO_SLIDER(dwValue); SendMessage(GetDlgItem(hwnd, IDC_TREBLE), TBM_SETPOS, TRUE, dwValue); } } if (pap->dwSupport & ADV_HAS_BASS) { mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pap->dwBassID; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&dwValue; mmr = mixerGetControlDetails((HMIXEROBJ)(pap->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr == MMSYSERR_NOERROR) { dwValue = VOLUME_TO_SLIDER(dwValue); SendMessage(GetDlgItem(hwnd, IDC_BASS), TBM_SETPOS, TRUE, dwValue); } } if (pap->dwSupport & ADV_HAS_SWITCH1) { mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pap->dwSwitch1ID; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&dwValue; mmr = mixerGetControlDetails((HMIXEROBJ)(pap->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr == MMSYSERR_NOERROR) { Button_SetCheck(GetDlgItem(hwnd,IDC_SWITCH1),dwValue); } } if (pap->dwSupport & ADV_HAS_SWITCH2) { mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pap->dwSwitch2ID; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&dwValue; mmr = mixerGetControlDetails((HMIXEROBJ)(pap->hmx) , &mxcd , MIXER_GETCONTROLDETAILSF_VALUE); if (mmr == MMSYSERR_NOERROR) { Button_SetCheck(GetDlgItem(hwnd,IDC_SWITCH2),dwValue); } } } void Mixer_Advanced_OnMixmControlChange( HWND hwnd, HMIXER hmx, DWORD dwControlID) { PADVPARAM pap = GETPADVPARAM(hwnd); if (!pap) return; if ( ((pap->dwSupport & ADV_HAS_BASS) && dwControlID == pap->dwBassID) || ((pap->dwSupport & ADV_HAS_TREBLE) && dwControlID == pap->dwTrebleID) || ((pap->dwSupport & ADV_HAS_SWITCH1) && dwControlID == pap->dwSwitch1ID) || ((pap->dwSupport & ADV_HAS_SWITCH2) && dwControlID == pap->dwSwitch2ID) ) { Mixer_Advanced_Update(pap,hwnd); } } BOOL Mixer_Advanced_OnInitDialog( HWND hwnd, HWND hwndFocus, LPARAM lParam) { PADVPARAM pap; MIXERLINECONTROLS mxlc; MIXERCONTROL *pmxc; MIXERLINE ml; MMRESULT mmr; DWORD iCtrl, iSwitch1, iSwitch2; TCHAR ach[MIXER_LONG_NAME_CHARS + 24]; TCHAR achFmt[256]; HWND hBass,hTreble,hSwitch1,hSwitch2; SETPADVPARAM(hwnd, lParam); pap = GETPADVPARAM(hwnd); if (!pap) EndDialog(hwnd, FALSE); // // clone the mixer handle to catch callbacks // #ifndef _WIN64 mmr = mixerOpen((LPHMIXER)&pap->hmx , (UINT)pap->pmxud->hmx , (DWORD_PTR)hwnd , 0 , CALLBACK_WINDOW | MIXER_OBJECTF_HMIXER ); #else mmr = mixerOpen((LPHMIXER)&pap->hmx , (UINT)pap->pmxud->mxid , (DWORD_PTR)hwnd , 0 , CALLBACK_WINDOW | MIXER_OBJECTF_HMIXER ); #endif if (mmr != MMSYSERR_NOERROR) EndDialog(hwnd, FALSE); // // Get all controls. // ml.cbStruct = sizeof(ml); ml.dwLineID = pap->dwLineID; mmr = mixerGetLineInfo((HMIXEROBJ)pap->hmx , &ml , MIXER_GETLINEINFOF_LINEID); if (mmr != MMSYSERR_NOERROR || ml.cControls == 0L) EndDialog(hwnd, FALSE); pmxc = (MIXERCONTROL *)GlobalAllocPtr(GHND, sizeof(MIXERCONTROL) * ml.cControls); if (!pmxc) { EndDialog(hwnd, FALSE); return FALSE; // Bail on error } mxlc.cbStruct = sizeof(mxlc); mxlc.dwLineID = pap->dwLineID; mxlc.cControls = ml.cControls; mxlc.cbmxctrl = sizeof(MIXERCONTROL); mxlc.pamxctrl = pmxc; mmr = mixerGetLineControls((HMIXEROBJ)(pap->hmx) , &mxlc , MIXER_GETLINECONTROLSF_ALL); if (mmr != MMSYSERR_NOERROR) { GlobalFreePtr(pmxc); EndDialog(hwnd, FALSE); } pap->dwSupport = 0L; for (iCtrl = 0; iCtrl < ml.cControls; iCtrl++) { switch (pmxc[iCtrl].dwControlType) { case MIXERCONTROL_CONTROLTYPE_BASS: if (!(pap->dwSupport & ADV_HAS_BASS)) { pap->dwBassID = pmxc[iCtrl].dwControlID; pap->dwSupport |= ADV_HAS_BASS; } break; case MIXERCONTROL_CONTROLTYPE_TREBLE: if (!(pap->dwSupport & ADV_HAS_TREBLE)) { pap->dwTrebleID = pmxc[iCtrl].dwControlID; pap->dwSupport |= ADV_HAS_TREBLE; } break; case MIXERCONTROL_CONTROLTYPE_BOOLEAN: case MIXERCONTROL_CONTROLTYPE_MONO: case MIXERCONTROL_CONTROLTYPE_STEREOENH: case MIXERCONTROL_CONTROLTYPE_ONOFF: case MIXERCONTROL_CONTROLTYPE_LOUDNESS: if (!(pap->dwSupport & ADV_HAS_SWITCH1)) { pap->dwSwitch1ID = pmxc[iCtrl].dwControlID; pap->dwSupport |= ADV_HAS_SWITCH1; iSwitch1 = iCtrl; } else if (!(pap->dwSupport & ADV_HAS_SWITCH2)) { pap->dwSwitch2ID = pmxc[iCtrl].dwControlID; pap->dwSupport |= ADV_HAS_SWITCH2; iSwitch2 = iCtrl; } break; } } // // // hBass = GetDlgItem(hwnd, IDC_BASS); hTreble = GetDlgItem(hwnd, IDC_TREBLE); hSwitch1 = GetDlgItem(hwnd, IDC_SWITCH1); hSwitch2 = GetDlgItem(hwnd, IDC_SWITCH2); SendMessage(hBass, TBM_SETRANGE, 0, MAKELONG(0, VOLUME_TICS)); SendMessage(hBass, TBM_SETTICFREQ, (VOLUME_TICS + 5)/6, 0 ); SendMessage(hTreble, TBM_SETRANGE, 0, MAKELONG(0, VOLUME_TICS)); SendMessage(hTreble, TBM_SETTICFREQ, (VOLUME_TICS + 5)/6, 0 ); if (!(pap->dwSupport & ADV_HAS_BASS)) { SendMessage(hBass, TBM_SETPOS, 64, 0 ); EnableWindow(GetDlgItem(hwnd, IDC_TXT_LOW1), FALSE); EnableWindow(GetDlgItem(hwnd, IDC_TXT_HI1), FALSE); } EnableWindow(hBass, (pap->dwSupport & ADV_HAS_BASS)); if (!(pap->dwSupport & ADV_HAS_TREBLE)) { SendMessage(hTreble, TBM_SETPOS, 64, 0 ); EnableWindow(GetDlgItem(hwnd, IDC_TXT_LOW2), FALSE); EnableWindow(GetDlgItem(hwnd, IDC_TXT_HI2), FALSE); } EnableWindow(hTreble, (pap->dwSupport & ADV_HAS_TREBLE)); if (pap->dwSupport & ADV_HAS_SWITCH1) { LoadString(pap->pmxud->hInstance, IDS_ADV_SWITCH1, achFmt, SIZEOF(achFmt)); wsprintf(ach, achFmt, pmxc[iSwitch1].szName); SetWindowText(hSwitch1, ach); ShowWindow(hSwitch1, SW_SHOW); ShowWindow(GetDlgItem(hwnd, IDC_TXT_SWITCHES), SW_SHOW); ShowWindow(GetDlgItem(hwnd, IDC_GRP_OTHER), SW_SHOW); } EnableWindow(hSwitch1, (pap->dwSupport & ADV_HAS_SWITCH1)); if (pap->dwSupport & ADV_HAS_SWITCH2) { LoadString(pap->pmxud->hInstance, IDS_ADV_SWITCH2, achFmt, SIZEOF(achFmt)); wsprintf(ach, achFmt, pmxc[iSwitch2].szName); SetWindowText(hSwitch2, ach); ShowWindow(hSwitch2, SW_SHOW); } EnableWindow(hSwitch2, (pap->dwSupport & ADV_HAS_SWITCH2)); if (pap->dwSupport & (ADV_HAS_SWITCH1 | ADV_HAS_SWITCH2)) { RECT rcGrp,rcGrp2,rcClose,rcWnd; DWORD dwDY=0L; POINT pos; HWND hClose = GetDlgItem(hwnd, IDOK); HWND hGrp2 = GetDlgItem(hwnd, IDC_GRP_OTHER); GetWindowRect(GetDlgItem(hwnd, IDC_GRP_TONE), &rcGrp); GetWindowRect(GetDlgItem(hwnd, IDC_GRP_OTHER), &rcGrp2); GetWindowRect(hClose, &rcClose); GetWindowRect(hwnd, &rcWnd); if (pap->dwSupport & ADV_HAS_SWITCH2) { RECT rc1, rc2; GetWindowRect(hSwitch1,&rc1); GetWindowRect(hSwitch2,&rc2); rcGrp2.bottom += rc2.bottom - rc1.bottom; } dwDY = rcGrp2.bottom - rcGrp.bottom; // // resize our main window // MoveWindow(hwnd, rcWnd.left , rcWnd.top , rcWnd.right - rcWnd.left , (rcWnd.bottom - rcWnd.top) + dwDY , FALSE); // // move the close button // MapWindowPoints(NULL, hwnd, (LPPOINT)&rcClose, 2); pos.x = rcClose.left; pos.y = rcClose.top; MoveWindow(hClose, pos.x , pos.y + dwDY , rcClose.right - rcClose.left , rcClose.bottom - rcClose.top , FALSE); // // resize our group box if necessary // if (pap->dwSupport & ADV_HAS_SWITCH2) { MapWindowPoints(NULL, hwnd, (LPPOINT)&rcGrp2, 2); pos.x = rcGrp2.left; pos.y = rcGrp2.top; MoveWindow(hGrp2, pos.x , pos.y , rcGrp2.right - rcGrp2.left , rcGrp2.bottom - rcGrp2.top , FALSE); } } GlobalFreePtr(pmxc); { TCHAR achTitle[MIXER_LONG_NAME_CHARS+256]; LoadString(pap->pmxud->hInstance, IDS_ADV_TITLE, achFmt, SIZEOF(achFmt)); wsprintf(achTitle, achFmt, pap->szName); SetWindowText(hwnd, achTitle); } Mixer_Advanced_Update(pap, hwnd); return TRUE; } void Mixer_Advanced_OnXScroll( HWND hwnd, HWND hwndCtl, UINT code, int pos) { PADVPARAM pap; MIXERCONTROLDETAILS mxcd; DWORD dwVol; MMRESULT mmr; pap = GETPADVPARAM(hwnd); if (!pap) return; if (pap->dwSupport & ADV_HAS_TREBLE) { dwVol = (DWORD)SendMessage( GetDlgItem(hwnd, IDC_TREBLE) , TBM_GETPOS , 0 , 0 ); dwVol = SLIDER_TO_VOLUME(dwVol); mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pap->dwTrebleID ; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&dwVol; mixerSetControlDetails((HMIXEROBJ)(pap->hmx) , &mxcd , MIXER_SETCONTROLDETAILSF_VALUE); } if (pap->dwSupport & ADV_HAS_BASS) { dwVol = (DWORD)SendMessage( GetDlgItem(hwnd, IDC_BASS) , TBM_GETPOS , 0 , 0 ); dwVol = SLIDER_TO_VOLUME(dwVol); mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = pap->dwBassID; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&dwVol; mmr = mixerSetControlDetails((HMIXEROBJ)(pap->hmx) , &mxcd , MIXER_SETCONTROLDETAILSF_VALUE); } } void Mixer_Advanced_OnSwitch( HWND hwnd, int id, HWND hwndCtl) { PADVPARAM pap; MIXERCONTROLDETAILS mxcd; DWORD dwValue; MMRESULT mmr; pap = GETPADVPARAM(hwnd); if (!pap) return; dwValue = Button_GetCheck(hwndCtl); mxcd.cbStruct = sizeof(mxcd); mxcd.dwControlID = (id == IDC_SWITCH1)?pap->dwSwitch1ID:pap->dwSwitch2ID; mxcd.cChannels = 1; mxcd.cMultipleItems = 0; mxcd.cbDetails = sizeof(DWORD); mxcd.paDetails = (LPVOID)&dwValue; mmr = mixerSetControlDetails((HMIXEROBJ)(pap->hmx) , &mxcd , MIXER_SETCONTROLDETAILSF_VALUE); } BOOL Mixer_Advanced_OnCommand( HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) { switch (id) { case IDOK: EndDialog(hwnd, TRUE); break; case IDCANCEL: EndDialog(hwnd, FALSE); break; case IDC_SWITCH1: Mixer_Advanced_OnSwitch(hwnd, id, hwndCtl); break; case IDC_SWITCH2: Mixer_Advanced_OnSwitch(hwnd, id, hwndCtl); break; } return FALSE; } INT_PTR CALLBACK Mixer_Advanced_Proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { switch (msg) { case WM_INITDIALOG: HANDLE_WM_INITDIALOG(hwnd, wparam, lparam, Mixer_Advanced_OnInitDialog); return TRUE; case MM_MIXM_CONTROL_CHANGE: HANDLE_MM_MIXM_CONTROL_CHANGE(hwnd , wparam , lparam , Mixer_Advanced_OnMixmControlChange); break; case WM_CLOSE: EndDialog(hwnd, FALSE); break; case WM_HSCROLL: HANDLE_WM_XSCROLL(hwnd, wparam, lparam, Mixer_Advanced_OnXScroll); break; case WM_COMMAND: HANDLE_WM_COMMAND(hwnd, wparam, lparam, Mixer_Advanced_OnCommand); break; case WM_DESTROY: { PADVPARAM pap = GETPADVPARAM(hwnd); if (pap) { if (pap->hmx) mixerClose(pap->hmx); } break; } default: break; } return FALSE; } /* * Advanced Features for specific mixer lines. */ void Mixer_Advanced( PMIXUIDIALOG pmxud, DWORD dwLineID, LPTSTR szName) { ADVPARAM advp; ZeroMemory(&advp, sizeof(ADVPARAM)); advp.pmxud = pmxud; advp.dwLineID = dwLineID; advp.szName = szName; DialogBoxParam(pmxud->hInstance , MAKEINTRESOURCE(IDD_ADVANCED) , pmxud->hwnd , Mixer_Advanced_Proc , (LPARAM)(LPVOID)&advp); } typedef void (*MULTICHANNELFUNC)(HWND, UINT, DWORD, DWORD); void Mixer_Multichannel (PMIXUIDIALOG pmxud, DWORD dwVolumeID) { HMODULE hModule; MULTICHANNELFUNC fnMultiChannel; if (pmxud) { hModule = (HMODULE) LoadLibrary (TEXT ("mmsys.cpl")); if (hModule) { fnMultiChannel = (MULTICHANNELFUNC) GetProcAddress (hModule, "Multichannel"); if (fnMultiChannel) { (*fnMultiChannel)(pmxud->hwnd, pmxud->mxid, pmxud->iDest, dwVolumeID); } FreeLibrary (hModule); } } }