mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2611 lines
77 KiB
2611 lines
77 KiB
/*****************************************************************************
|
|
*
|
|
* Component: sndvol32.exe
|
|
* File: mixer.c
|
|
* Purpose: mixer api specific implementations
|
|
*
|
|
* Copyright (c) 1985-1999 Microsoft Corporation
|
|
*
|
|
*****************************************************************************/
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
#include <commctrl.h>
|
|
|
|
#include <math.h>
|
|
#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);
|
|
}
|
|
}
|
|
}
|