able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/ui/conf/mixer.cpp

982 lines
28 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
#include <mixer.h>
//
// private APIs
//
#define MAX_MICROPHONE_DEVS 10
static MMRESULT mixerGetControlValue ( HMIXER, MIXVOLUME *, DWORD, UINT );
static MMRESULT mixerSetControlValue ( HMIXER, MIXVOLUME *, DWORD, UINT );
static MMRESULT mixerGetControlId ( HMIXER, DWORD *, DWORD, DWORD );
static MMRESULT mixerGetControlByType ( HMIXER, DWORD, DWORD, MIXERCONTROL *pMixerControl);
// used for AGC detection
static const char *szGain = "gain";
static const char *szBoost = "boost";
static const char *szAGC = "agc";
struct AGCDetails
{
WORD wMID; // manufacturer ID
WORD wPID; // product ID
DWORD dwAGCID; // AGC ID
};
// we shouldn't have to use this table scheme anymore.
// CMixerDevice::DetectAGC will autodetect the control ID
static const AGCDetails AGCList[] =
{
// MID PID AGCID
{2, 409, 27}, // Creative Labs
{21, 42, 13}, // Turtle Beach Tropez
{132, 3, 2072}, // Crystal MMX
{384, 7, 28}, // Xitel Storm 3d PCI
{385, 32, 35} // Aztech PCI-331
};
static BOOL GetAGCID(WORD wMID, WORD wPID, DWORD *pdwAGCID)
{
int nIndex;
int nAGCEntries = sizeof(AGCList) / sizeof(AGCDetails);
for (nIndex = 0; nIndex < nAGCEntries; nIndex++)
{
if ( (AGCList[nIndex].wMID == wMID) &&
(AGCList[nIndex].wPID == wPID))
{
*pdwAGCID = AGCList[nIndex].dwAGCID;
return TRUE;
}
}
return FALSE;
}
/********************************************************************************\
* *
* void NewMixVolume(MIXVOLUME* lpMixVolDest, const MIXVOLUME& mixVolSource, *
* DWORD dwNewVolume) *
* *
* NewMixVolume takes the current mixer value (mixVolSource), and converts it *
* to its adjusted value (lpMixVolDest) using the new volume settings *
* (dwNewVolume) and the proportionality between the left and right volumes of *
* mixVolSource. Note that if mixVolSource's left and right volumes are both *
* equal to zero, then their proportionality is set to 1/1. *
* *
* March 2001 Matthew Maddin (mmaddin@microsoft) *
* *
\********************************************************************************/
void NewMixVolume(MIXVOLUME* lpMixVolDest, const MIXVOLUME& mixVolSource, DWORD dwNewVolume)
{
// If the source's left volume is the greater than the right volume,
// then it is the used to calculate the proportionality.
if(mixVolSource.leftVolume == max(mixVolSource.leftVolume, mixVolSource.rightVolume))
{
// Set the left volume to the new value.
lpMixVolDest->leftVolume = dwNewVolume;
// If the left volume is non-zero, then continue with the proportionality calculation.
if(mixVolSource.leftVolume)
{
// Calculate proportionality using the equation: NewRight = OldRight * (NewLeft/OldLeft)
// where (NewLeft/OldLeft) Is the proportionality.
lpMixVolDest->rightVolume = (mixVolSource.rightVolume*lpMixVolDest->leftVolume)/mixVolSource.leftVolume;
}
// Otherwise we cannot compute the proportionality and reset it to 1/1.
// Note that 1/1 is not necessarily the 'correct' value.
else
{
// To maintain a ratio of 1/1 the right volume must equal the left volume.
lpMixVolDest->rightVolume = lpMixVolDest->leftVolume;
}
}
// Otherwise use the right volume to calculate the proportionality.
else
{
// Set the right volume to the new value.
lpMixVolDest->rightVolume = dwNewVolume;
// If the right volume is non-zero, then continue with the proportionality calculation.
if(mixVolSource.rightVolume)
{
// Calculate proportionality using the equation: NewLeft = OldLeft * (NewRight/OldRight)
// where (NewRight/OldRight) Is the proportionality.
lpMixVolDest->leftVolume = (mixVolSource.leftVolume*lpMixVolDest->rightVolume)/mixVolSource.rightVolume;
}
// Otherwise we cannot compute the proportionality and reset it to 1/1.
// Note that 1/1 is not necessarily the 'correct' value.
else
{
// To maintain a ratio of 1/1 the left volume must equal the right volume.
lpMixVolDest->leftVolume = lpMixVolDest->rightVolume;
}
}
}
//
// Init
//
// Enumerate all existing mixers in the system. For each mixer,
// we enumerate all lines with destination Speaker and WaveIn.
// For each such line, we cache the control id and control value
// of volume control. An invalid flag will be tagged to any control
// not supported by this mixer.
// When an application is finished with all mixers operations,
// it must call ReleaseAllMixers to free all memory resources and
// mixers.
//
// THIS MUST BE THE FIRST API TO CALL TO START MIXER OPERATIONS.
//
// Input: The handle of the window which will handle all callback
// messages MM_MIXM_CONTROL_CHANGE and MM_MIXM_LINE_CHANGE.
//
// Output: TRUE if success; otherwise, FALSE.
//
BOOL CMixerDevice::Init( HWND hWnd, UINT uWaveDevId, DWORD dwFlags)
{
UINT uMixerIdx, uDstIdx, uSrcIdx, uMixerIdCheck;
MMRESULT mmr = MMSYSERR_NOERROR;
MIXERLINE mlDst, mlSrc;
UINT_PTR nMixers, nWaveInDevs, uIndex;
//get the mixer device corresponding to the wave device
#ifndef _WIN64
mmr = mixerGetID((HMIXEROBJ)uWaveDevId, &uMixerIdx, dwFlags);
#else
mmr = MMSYSERR_NODRIVER;
#endif
if ((mmr != MMSYSERR_NOERROR) && (mmr != MMSYSERR_NODRIVER)) {
return FALSE;
}
// a simple fix for cheesy sound cards that don't make a
// direct mapping between waveDevice and mixer device
// e.g. MWAVE cards and newer SB NT 4 drivers
// If there is only ONE mixer device and if no other waveIn device
// uses it, then it is probably valid.
if ((mmr == MMSYSERR_NODRIVER) && (dwFlags == MIXER_OBJECTF_WAVEIN))
{
nMixers = mixerGetNumDevs();
nWaveInDevs = waveInGetNumDevs();
if (nMixers == 1)
{
uMixerIdx = 0;
for (uIndex = 0; uIndex < nWaveInDevs; uIndex++)
{
mmr = mixerGetID((HMIXEROBJ)uIndex, &uMixerIdCheck, dwFlags);
if ((mmr == MMSYSERR_NOERROR) && (uMixerIdCheck == uMixerIdx))
{
return FALSE; // the mixer belongs to another waveIn Device
}
}
}
else
{
return FALSE;
}
}
// open the mixer such that we can get notification messages
mmr = mixerOpen (
&m_hMixer,
uMixerIdx,
(DWORD_PTR) hWnd,
0,
(hWnd ? CALLBACK_WINDOW : 0) | MIXER_OBJECTF_MIXER);
if (mmr != MMSYSERR_NOERROR) {
return FALSE;
}
// get mixer caps
mmr = mixerGetDevCaps (uMixerIdx, &(m_mixerCaps), sizeof (MIXERCAPS));
if ((mmr != MMSYSERR_NOERROR) || (0 == m_mixerCaps.cDestinations)) {
mixerClose(m_hMixer);
return FALSE;
}
for (uDstIdx = 0; uDstIdx < m_mixerCaps.cDestinations; uDstIdx++)
{
ZeroMemory (&mlDst, sizeof (mlDst));
mlDst.cbStruct = sizeof (mlDst);
mlDst.dwDestination = uDstIdx;
// get the mixer line for this destination
mmr = mixerGetLineInfo ((HMIXEROBJ)m_hMixer, &mlDst,
MIXER_GETLINEINFOF_DESTINATION | MIXER_OBJECTF_HMIXER);
if (mmr != MMSYSERR_NOERROR) continue;
// examine the type of this destination line
if (((MIXER_OBJECTF_WAVEOUT == dwFlags) &&
(MIXERLINE_COMPONENTTYPE_DST_SPEAKERS == mlDst.dwComponentType)) ||
((MIXER_OBJECTF_WAVEIN == dwFlags) &&
(MIXERLINE_COMPONENTTYPE_DST_WAVEIN == mlDst.dwComponentType)))
{
// fill in more info about DstLine
m_DstLine.ucChannels = mlDst.cChannels;
if (!(mlDst.fdwLine & MIXERLINE_LINEF_DISCONNECTED))
{
// get id and value of volume control
mmr = mixerGetControlId (
m_hMixer,
&m_DstLine.dwControlId,
mlDst.dwLineID,
MIXERCONTROL_CONTROLTYPE_VOLUME);
m_DstLine.fIdValid = (mmr == MMSYSERR_NOERROR);
m_DstLine.dwLineId = mlDst.dwLineID;
m_DstLine.dwCompType = mlDst.dwComponentType;
m_DstLine.dwConnections = mlDst.cConnections;
// -----------------------------------------------------
// enumerate all sources for this destination
for (uSrcIdx = 0; uSrcIdx < mlDst.cConnections; uSrcIdx++)
{
// get the info of the line with specific src and dst...
ZeroMemory (&mlSrc, sizeof (mlSrc));
mlSrc.cbStruct = sizeof (mlSrc);
mlSrc.dwDestination = uDstIdx;
mlSrc.dwSource = uSrcIdx;
mmr = mixerGetLineInfo (
(HMIXEROBJ)m_hMixer,
&mlSrc,
MIXER_GETLINEINFOF_SOURCE | MIXER_OBJECTF_HMIXER);
if (mmr == MMSYSERR_NOERROR)
{
if (((MIXERLINE_COMPONENTTYPE_DST_SPEAKERS == mlDst.dwComponentType) &&
(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT == mlSrc.dwComponentType)) ||
((MIXERLINE_COMPONENTTYPE_DST_WAVEIN == mlDst.dwComponentType) &&
(MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE == mlSrc.dwComponentType)))
{
// fill in more info about this source
m_SrcLine.ucChannels = mlSrc.cChannels;
// get id and value of volume control
mmr = mixerGetControlId (
m_hMixer,
&m_SrcLine.dwControlId,
mlSrc.dwLineID,
MIXERCONTROL_CONTROLTYPE_VOLUME);
m_SrcLine.fIdValid = (mmr == MMSYSERR_NOERROR);
m_SrcLine.dwLineId = mlSrc.dwLineID;
m_SrcLine.dwCompType = mlSrc.dwComponentType;
m_SrcLine.dwConnections = mlSrc.cConnections;
m_SrcLine.dwControls = mlSrc.cControls;
DetectAGC();
break;
}
}
}
}
break;
}
}
return TRUE;
}
CMixerDevice* CMixerDevice::GetMixerForWaveDevice( HWND hWnd, UINT uWaveDevId, DWORD dwFlags)
{
CMixerDevice* pMixerDev = new CMixerDevice;
if (NULL != pMixerDev)
{
if (!pMixerDev->Init(hWnd, uWaveDevId, dwFlags))
{
delete pMixerDev;
pMixerDev = NULL;
}
}
return pMixerDev;
}
// general method for setting the volume
// for recording, this will try to set both the master and microphone volume controls
// for playback, it will only set the WaveOut playback line (master line stays put)
BOOL CMixerDevice::SetVolume(MIXVOLUME * pdwVolume)
{
BOOL fSetMain=FALSE, fSetSub;
BOOL fMicrophone;
// is this the microphone channel ?
fMicrophone = ((m_DstLine.dwCompType == MIXERLINE_COMPONENTTYPE_DST_WAVEIN) ||
(m_SrcLine.dwCompType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE));
fSetSub = SetSubVolume(pdwVolume);
if ((fMicrophone) || (!fSetSub))
{
fSetMain = SetMainVolume(pdwVolume);
}
return (fSetSub || fSetMain);
}
BOOL CMixerDevice::SetMainVolume(MIXVOLUME * pdwVolume)
{
MMRESULT mmr = MMSYSERR_ERROR;
if (m_DstLine.fIdValid) {
mmr = mixerSetControlValue (
m_hMixer,
pdwVolume,
m_DstLine.dwControlId,
2);
}
return (mmr == MMSYSERR_NOERROR);
}
BOOL CMixerDevice::SetSubVolume(MIXVOLUME * pdwVolume)
{
MMRESULT mmr = MMSYSERR_ERROR;
if (m_SrcLine.fIdValid)
{
mmr = mixerSetControlValue (
m_hMixer,
pdwVolume,
m_SrcLine.dwControlId,
m_SrcLine.ucChannels);
}
return (mmr == MMSYSERR_NOERROR);
}
//
// Gets the volume (0 - 65535) of the master volume
// returns TRUE if succesful,
// returns FALSE if it fails or if this control is not available
//
BOOL CMixerDevice::GetMainVolume(MIXVOLUME * pdwVolume)
{
BOOL fRet = FALSE;
if (m_DstLine.fIdValid)
{
MMRESULT mmr = ::mixerGetControlValue(
m_hMixer,
pdwVolume,
m_DstLine.dwControlId,
2);
fRet = (mmr == MMSYSERR_NOERROR);
}
return fRet;
}
//
// Gets the volume (0 - 65535) of the sub volume
// returns TRUE if succesful,
// returns FALSE if it fails or if this control is not available
//
BOOL CMixerDevice::GetSubVolume(MIXVOLUME * pdwVolume)
{
BOOL fRet = FALSE;
if (m_SrcLine.fIdValid)
{
MMRESULT mmr = ::mixerGetControlValue(
m_hMixer,
pdwVolume,
m_SrcLine.dwControlId,
m_SrcLine.ucChannels);
fRet = (mmr == MMSYSERR_NOERROR);
}
return fRet;
}
BOOL CMixerDevice::GetVolume(MIXVOLUME * pdwVol)
{
MIXVOLUME dwSub={0,0}, dwMain={0,0};
BOOL fSubAvail, fMainAvail, fMicrophone;
// is this the microphone channel ?
fMicrophone = ((m_DstLine.dwCompType == MIXERLINE_COMPONENTTYPE_DST_WAVEIN) ||
(m_SrcLine.dwCompType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE));
fSubAvail = GetSubVolume(&dwSub);
fMainAvail = GetMainVolume(&dwMain);
if ((!fSubAvail) && (!fMainAvail))
{
pdwVol->leftVolume = 0;
pdwVol->rightVolume = 0;
return FALSE;
}
// don't return an average volume in the case of the speaker mixer
if (fSubAvail && fMainAvail && fMicrophone)
{
pdwVol->leftVolume = dwSub.leftVolume;
pdwVol->rightVolume = dwSub.rightVolume;
}
else if (fSubAvail)
{
pdwVol->leftVolume = dwSub.leftVolume;
pdwVol->rightVolume = dwSub.rightVolume;
}
else
{
pdwVol->leftVolume = dwMain.leftVolume;
pdwVol->rightVolume = dwMain.rightVolume;
}
return TRUE;
}
// Return the value of the Auto Gain Control
// Returns FALSE if the control is not supported.
// pfOn is OUTPUT, OPTIONAL - value of AGC
BOOL CMixerDevice::GetAGC(BOOL *pfOn)
{
MIXVOLUME dwValue;
MMRESULT mmr;
if ((m_SrcLine.fIdValid==FALSE) || (m_SrcLine.fAgcAvailable==FALSE))
{
return FALSE;
}
mmr = mixerGetControlValue(m_hMixer, &dwValue, m_SrcLine.dwAGCID, 1);
if (mmr != MMSYSERR_NOERROR)
{
return FALSE;
}
if (pfOn)
{
*pfOn = dwValue.leftVolume || dwValue.rightVolume;
}
return TRUE;
}
/*
Hack API to turn MIC Auto Gain Control on or off.
Its a hack because it only works on SB16/AWE32 cards.
*/
BOOL CMixerDevice::SetAGC(BOOL fOn)
{
MIXVOLUME dwValue;
MMRESULT mmr;
if ((m_SrcLine.fIdValid==FALSE) || (m_SrcLine.fAgcAvailable==FALSE))
{
return FALSE;
}
mmr = mixerGetControlValue(m_hMixer, &dwValue, m_SrcLine.dwAGCID, 1);
if (mmr != MMSYSERR_NOERROR)
{
return FALSE;
}
if (dwValue.leftVolume == (DWORD)fOn && dwValue.rightVolume == (DWORD)fOn)
{
return TRUE;
}
dwValue.leftVolume = fOn;
dwValue.rightVolume = fOn;
mmr = mixerSetControlValue(m_hMixer, &dwValue, m_SrcLine.dwAGCID, 1);
return (mmr == MMSYSERR_NOERROR);
}
// this method tries to determine if an AGC control is available by
// looking for a microphone sub-control that has a corresponding text
// string with the words "gain", "boost", or "agc" in in.
// If it can't auto-detect it through string compares, it falls
// back to a table lookup scheme. (Auto-detect will probably not work
// in localized versions of the driver. But hardly anyone localizes
// their drivers.)
BOOL CMixerDevice::DetectAGC()
{
MIXERLINECONTROLS mlc;
MIXERCONTROL *aMC=NULL;
MIXERCONTROL *pMC;
MMRESULT mmrQuery;
DWORD dwIndex;
if ((m_SrcLine.fIdValid == FALSE) || (m_SrcLine.dwCompType != MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE))
{
return FALSE;
}
// make sure that dwControls isn't set to something outrageous
if ((m_SrcLine.dwControls > 0) && (m_SrcLine.dwControls < 30))
{
aMC = new MIXERCONTROL[m_SrcLine.dwControls];
mlc.cbStruct = sizeof(MIXERLINECONTROLS);
mlc.dwLineID = m_SrcLine.dwLineId;
mlc.dwControlType = 0; // not set ???
mlc.cControls = m_SrcLine.dwControls;
mlc.cbmxctrl = sizeof(MIXERCONTROL); // set to sizeof 1 MC structure
mlc.pamxctrl = aMC;
mmrQuery = mixerGetLineControls((HMIXEROBJ)m_hMixer, &mlc, MIXER_OBJECTF_HMIXER|MIXER_GETLINECONTROLSF_ALL );
if (mmrQuery == MMSYSERR_NOERROR)
{
for (dwIndex = 0; dwIndex < mlc.cControls; dwIndex++)
{
pMC = &aMC[dwIndex];
// make sure we don't get a fader, mute, or some other control
if ( (!(pMC->dwControlType & MIXERCONTROL_CT_CLASS_SWITCH)) ||
(pMC->dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE) )
{
continue;
}
CharLower(pMC->szName); // CharLower is a Win32 string function
CharLower(pMC->szShortName);
if ( _StrStr(pMC->szName, szGain) || _StrStr(pMC->szName, szBoost) || _StrStr(pMC->szName, szAGC) ||
_StrStr(pMC->szShortName, szGain) || _StrStr(pMC->szShortName, szBoost) || _StrStr(pMC->szShortName, szAGC) )
{
m_SrcLine.fAgcAvailable = TRUE;
m_SrcLine.dwAGCID = pMC->dwControlID;
TRACE_OUT(("CMixerDevice::DetectAGC - Autodetected control ID %d as AGC\r\n", m_SrcLine.dwAGCID));
break;
}
}
}
}
// if we didn't find the mixer dynamically, consult our old list
if (!m_SrcLine.fAgcAvailable)
{
m_SrcLine.fAgcAvailable = GetAGCID(m_mixerCaps.wMid, m_mixerCaps.wPid, &(m_SrcLine.dwAGCID));
}
if (aMC)
delete [] aMC;
return m_SrcLine.fAgcAvailable;
}
BOOL CMixerDevice::EnableMicrophone()
{
MIXERLINE mixerLine;
MIXERCONTROL mixerControl;
MIXERCONTROLDETAILS mixerControlDetails, mixerControlDetailsOrig;
UINT uIndex, numItems, numMics, numMicsSet, fMicFound;
UINT uMicIndex = 0;
UINT aMicIndices[MAX_MICROPHONE_DEVS];
MIXERCONTROLDETAILS_LISTTEXT *aListText = NULL;
MIXERCONTROLDETAILS_BOOLEAN *aEnableList = NULL;
MMRESULT mmr;
BOOL fLoopback=FALSE;
UINT uLoopbackIndex=0;
// check to see if component type is valid (which means the line exists!)
// even if the volume control doesn't exist or isn't slidable,
// there may still be a select switch
if ((m_SrcLine.dwCompType != MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE) ||
(m_DstLine.dwCompType != MIXERLINE_COMPONENTTYPE_DST_WAVEIN))
{
return FALSE;
}
// try to find the mixer list
if ( (MMSYSERR_NOERROR != mixerGetControlByType(m_hMixer, m_DstLine.dwLineId, MIXERCONTROL_CT_CLASS_LIST, &mixerControl))
&& (MMSYSERR_NOERROR != mixerGetControlByType(m_hMixer, m_DstLine.dwLineId, MIXERCONTROL_CONTROLTYPE_MIXER, &mixerControl))
&& (MMSYSERR_NOERROR != mixerGetControlByType(m_hMixer, m_DstLine.dwLineId, MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT, &mixerControl))
&& (MMSYSERR_NOERROR != mixerGetControlByType(m_hMixer, m_DstLine.dwLineId, MIXERCONTROL_CONTROLTYPE_MUX, &mixerControl))
&& (MMSYSERR_NOERROR != mixerGetControlByType(m_hMixer, m_DstLine.dwLineId, MIXERCONTROL_CONTROLTYPE_SINGLESELECT, &mixerControl))
)
{
TRACE_OUT(("CMixerDevice::EnableMicrophone-Unable to find mixer list!"));
// if no mixer list, see if there is a "mute" control...
return UnMuteVolume();
// note: even though we don't have a mixer mux/select control
// we could still find a way to mute the loopback line
// unfortunately, we don't have the code that finds the line id
// of the loopback control
}
ZeroMemory(&mixerControlDetails, sizeof(MIXERCONTROLDETAILS));
mixerControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixerControlDetails.dwControlID = mixerControl.dwControlID;
if (MIXERCONTROL_CONTROLF_UNIFORM & mixerControl.fdwControl)
mixerControlDetails.cChannels = 1;
else
mixerControlDetails.cChannels = m_DstLine.ucChannels;
if (MIXERCONTROL_CONTROLF_MULTIPLE & mixerControl.fdwControl)
mixerControlDetails.cMultipleItems = (UINT)mixerControl.cMultipleItems;
else
mixerControlDetails.cMultipleItems = 1;
// weirdness - you have to set cbDetails to the size of a single LISTTEXT item
// setting it to anything larger will make the call fail
mixerControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXT);
numItems = mixerControlDetails.cMultipleItems;
if (m_DstLine.dwConnections > numItems)
numItems = m_DstLine.dwConnections;
aListText = new MIXERCONTROLDETAILS_LISTTEXT[numItems];
aEnableList = new MIXERCONTROLDETAILS_BOOLEAN[numItems];
if ((aListText == NULL) || (aEnableList == NULL))
{
WARNING_OUT(("CMixerDevice::EnableMicrophone-Out of memory"));
return FALSE;
}
ZeroMemory(aListText, sizeof(MIXERCONTROLDETAILS_LISTTEXT)*numItems);
ZeroMemory(aEnableList, sizeof(MIXERCONTROLDETAILS_BOOLEAN)*numItems);
mixerControlDetails.paDetails = aListText;
// preserve the settings, some values will change after this call
mixerControlDetailsOrig = mixerControlDetails;
// query for the text of the list
mmr = mixerGetControlDetails((HMIXEROBJ)m_hMixer, &mixerControlDetails,
MIXER_GETCONTROLDETAILSF_LISTTEXT
|MIXER_OBJECTF_HMIXER);
// some sound cards don't specify CONTROLF_MULTIPLE
// try doing what sndvol32 does for MUX controls
if (mmr != MMSYSERR_NOERROR)
{
mixerControlDetails = mixerControlDetailsOrig;
mixerControlDetails.cChannels = 1;
mixerControlDetails.cMultipleItems = m_DstLine.dwConnections;
mixerControlDetailsOrig = mixerControlDetails;
mmr = mixerGetControlDetails((HMIXEROBJ)m_hMixer, &mixerControlDetails,
MIXER_GETCONTROLDETAILSF_LISTTEXT
|MIXER_OBJECTF_HMIXER);
}
if (mmr != MMSYSERR_NOERROR)
{
delete [] aListText;
delete [] aEnableList;
return FALSE;
}
// enumerate for the microphone
numMics = 0;
fMicFound = FALSE;
for (uIndex = 0; uIndex < mixerControlDetails.cMultipleItems; uIndex++)
{
// dwParam1 of the listText structure is the LineID of the source
// dwParam2 should be the component type, but unfoturnately not
// all sound cards obey this rule.
ZeroMemory (&mixerLine, sizeof(MIXERLINE));
mixerLine.cbStruct = sizeof(MIXERLINE);
mixerLine.dwLineID = aListText[uIndex].dwParam1;
mmr = mixerGetLineInfo ((HMIXEROBJ)m_hMixer, &mixerLine,
MIXER_GETLINEINFOF_LINEID | MIXER_OBJECTF_HMIXER);
if ((mmr == MMSYSERR_NOERROR) &&
(mixerLine.dwComponentType == m_SrcLine.dwCompType) &&
(numMics < MAX_MICROPHONE_DEVS))
{
aMicIndices[numMics] = uIndex;
numMics++;
}
if (aListText[uIndex].dwParam1 == m_SrcLine.dwLineId)
{
uMicIndex = uIndex;
fMicFound = TRUE; // can't rely on uIndex or uNumMics not zero
}
if ((mmr == MMSYSERR_NOERROR) &&
(mixerLine.dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT))
{
fLoopback = TRUE;
uLoopbackIndex = uIndex;
}
}
if (fMicFound == FALSE)
{
delete [] aListText;
delete [] aEnableList;
return FALSE;
}
// now we know which position in the array to set, let's do it.
mixerControlDetails = mixerControlDetailsOrig;
mixerControlDetails.paDetails = aEnableList;
mixerControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
// find out what's already marked as set.
mmr = mixerGetControlDetails((HMIXEROBJ)m_hMixer, &mixerControlDetails,
MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
if ( (mmr == MMSYSERR_NOERROR) &&
( (aEnableList[uMicIndex].fValue != 1) || (fLoopback && aEnableList[uLoopbackIndex].fValue == 1) )
)
{
// how many microphone's are already enabled ?
// if another microphone is already enabled and if the device is MUX type
// we won't attempt to turn one on.
numMicsSet = 0;
for (uIndex = 0; uIndex < numMics; uIndex++)
{
if ((aEnableList[aMicIndices[uIndex]].fValue == 1) &&
(uIndex != uMicIndex))
{
numMicsSet++;
}
}
if ( (mixerControl.dwControlType == MIXERCONTROL_CONTROLTYPE_MUX)
||(mixerControl.dwControlType == MIXERCONTROL_CONTROLTYPE_SINGLESELECT))
{
ZeroMemory(aEnableList, sizeof(aEnableList)*numItems);
aEnableList[uMicIndex].fValue = 1;
if (numMicsSet == 0)
{
mmr = mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mixerControlDetails,
MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
}
else
{
mmr = MMSYSERR_ERROR; // a mike has already been enabled
}
}
else
{
mixerControlDetails = mixerControlDetailsOrig;
mixerControlDetails.paDetails = aEnableList;
mixerControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
// enable the microphone
aEnableList[uMicIndex].fValue = 1;
mmr = mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mixerControlDetails,
MIXER_GETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
// disable the loopback input
if (fLoopback)
{
aEnableList[uLoopbackIndex].fValue = 0;
mixerSetControlDetails((HMIXEROBJ)m_hMixer, &mixerControlDetails,
MIXER_GETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
}
}
}
delete []aEnableList;
delete []aListText;
return (mmr == MMSYSERR_NOERROR);
}
BOOL CMixerDevice::UnMuteVolume()
{
MIXERCONTROL mixerControl;
MIXERCONTROLDETAILS mixerControlDetails;
MIXERCONTROLDETAILS_BOOLEAN mcdb;
MMRESULT mmrMaster=MMSYSERR_ERROR, mmrSub=MMSYSERR_ERROR;
// try to unmute the master volume (playback only)
if (m_DstLine.dwCompType == MIXERLINE_COMPONENTTYPE_DST_SPEAKERS)
{
mmrMaster = mixerGetControlByType(m_hMixer,
m_DstLine.dwLineId, MIXERCONTROL_CONTROLTYPE_MUTE,
&mixerControl);
if (mmrMaster == MMSYSERR_NOERROR)
{
ZeroMemory(&mixerControlDetails, sizeof(MIXERCONTROLDETAILS));
mixerControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixerControlDetails.dwControlID = mixerControl.dwControlID;
mixerControlDetails.cChannels = 1;
mixerControlDetails.cMultipleItems = 0;
mcdb.fValue = 0;
mixerControlDetails.paDetails = &mcdb;
mixerControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mmrMaster = mixerSetControlDetails((HMIXEROBJ)m_hMixer,
&mixerControlDetails,
MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
}
}
// Unmute the source line
// this will unmute WaveOut, and possibly the microphone
// (Use EnableMicrophone() above to handle all the potential microphone cases)
if ((m_SrcLine.dwCompType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE) ||
(m_SrcLine.dwCompType == MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT))
{
mmrSub = mixerGetControlByType(m_hMixer,
m_SrcLine.dwLineId, MIXERCONTROL_CONTROLTYPE_MUTE,
&mixerControl);
if (mmrSub == MMSYSERR_NOERROR)
{
ZeroMemory(&mixerControlDetails, sizeof(MIXERCONTROLDETAILS));
mixerControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
mixerControlDetails.dwControlID = mixerControl.dwControlID;
mixerControlDetails.cChannels = 1;
mixerControlDetails.cMultipleItems = 0;
mcdb.fValue = 0;
mixerControlDetails.paDetails = &mcdb;
mixerControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mmrSub = mixerSetControlDetails((HMIXEROBJ)m_hMixer,
&mixerControlDetails,
MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
}
}
return ((mmrSub == MMSYSERR_NOERROR) || (mmrMaster == MMSYSERR_NOERROR));
}
//////////////////////////////////////////////////
//
// The following are private APIs
//
static MMRESULT mixerGetControlValue ( HMIXER hMixer, MIXVOLUME *pdwValue,
DWORD dwControlId, UINT ucChannels )
{
MIXERCONTROLDETAILS mxcd;
MMRESULT mmr;
ZeroMemory (&mxcd, sizeof (mxcd));
mxcd.cbStruct = sizeof (mxcd);
mxcd.dwControlID = dwControlId;
mxcd.cChannels = ucChannels;
mxcd.cbDetails = sizeof (MIXVOLUME);
mxcd.paDetails = (PVOID) pdwValue;
mmr = mixerGetControlDetails ((HMIXEROBJ) hMixer, &mxcd,
MIXER_GETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER);
return mmr;
}
static MMRESULT mixerSetControlValue ( HMIXER hMixer, MIXVOLUME * pdwValue,
DWORD dwControlId, UINT ucChannels )
{
MIXERCONTROLDETAILS mxcd;
MMRESULT mmr;
ZeroMemory (&mxcd, sizeof (mxcd));
mxcd.cbStruct = sizeof (mxcd);
mxcd.dwControlID = dwControlId;
mxcd.cChannels = ucChannels;
mxcd.cbDetails = sizeof (MIXVOLUME);
mxcd.paDetails = (PVOID) pdwValue;
mmr = mixerSetControlDetails ((HMIXEROBJ) hMixer, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER);
return mmr;
}
static MMRESULT mixerGetControlId ( HMIXER hMixer, DWORD *pdwControlId,
DWORD dwLineId, DWORD dwControlType )
{
MIXERLINECONTROLS mxlc;
MIXERCONTROL mxc;
MMRESULT mmr;
ZeroMemory (&mxlc, sizeof (mxlc));
ZeroMemory (&mxc, sizeof (mxc));
mxlc.cbStruct = sizeof (mxlc);
mxlc.dwLineID = dwLineId;
mxlc.dwControlType = dwControlType;
mxlc.cControls = 1;
mxlc.cbmxctrl = sizeof (mxc);
mxlc.pamxctrl = &mxc;
mmr = mixerGetLineControls ((HMIXEROBJ) hMixer, &mxlc,
MIXER_GETLINECONTROLSF_ONEBYTYPE | MIXER_OBJECTF_HMIXER);
*pdwControlId = mxc.dwControlID;
return mmr;
}
// similar to above, except returns the whole control
static MMRESULT mixerGetControlByType ( HMIXER hMixer, DWORD dwLineId, DWORD dwControlType, MIXERCONTROL *pMixerControl)
{
MIXERLINECONTROLS mxlc;
MMRESULT mmr;
ZeroMemory (&mxlc, sizeof (mxlc));
ZeroMemory (pMixerControl, sizeof (MIXERCONTROL));
mxlc.cbStruct = sizeof (mxlc);
mxlc.dwLineID = dwLineId;
mxlc.dwControlType = dwControlType;
mxlc.cControls = 1;
mxlc.cbmxctrl = sizeof (MIXERCONTROL);
mxlc.pamxctrl = pMixerControl;
mmr = mixerGetLineControls ((HMIXEROBJ) hMixer, &mxlc,
MIXER_GETLINECONTROLSF_ONEBYTYPE | MIXER_OBJECTF_HMIXER);
return mmr;
}
Reference in a new issue Copy permalink