Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.

Dismiss

Finding the correct DLL to control the Sndvol32 exe

2 views

Skip to first unread message

Per J

unread,

Mar 17, 2001, 4:45:34 PM3/17/01

Hello

I think this is the right group to ask about how to find the right DLL and
the right exported function
to call, in general? (There must be a "registry" somewhere, where all is
documented?)

My specific problem is how to communicate with the little "yellow speaker"
program, called sndvol32.exe.
I have an application that uses the soundcard and the volume settings, but I
want to set the volume to a
certain value when the application starts up. It's a very simple thing I
want to do, indeed.

I suspect that the winmm.dll have those setting possibilities, but are not
sure.
How do I know which header file to look at?

When I use QuickView to look at Winmm.dll, I can see there is a function
namned auxSetVolume, or something like that.
How do I go on?
I suppose that there is a header file somewhere, where there is a function
with the same name,
and where I can find the parameter list and their types?

Very thankful for any help!

Per

Richard Jernigan

unread,

Apr 11, 2001, 12:13:27 AM4/11/01

#include <windows.h>
#include <mmsystem.h>

/*
* MASTER PLAYBACK
____________________________________________________________
*
*/

LONG Volume_GetMasterOut (void)
{
LONG dwVol = 100;

HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERLINE mxl;
mxl.cbStruct = sizeof(mxl);
mxl.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
if (mixerGetLineInfo ((HMIXEROBJ)hmx, &mxl,
MIXER_GETLINEINFOF_COMPONENTTYPE) == 0)
{
MIXERCONTROL mxctrl;
memset (&mxctrl, 0x00, sizeof(MIXERCONTROL));
mxctrl.cbStruct = sizeof(mxctrl);

MIXERLINECONTROLS mxlctrl;
memset (&mxlctrl, 0x00, sizeof(mxlctrl));
mxlctrl.cbStruct = sizeof(mxlctrl);
mxlctrl.dwLineID = mxl.dwLineID;
mxlctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
mxlctrl.cControls = 1;
mxlctrl.cbmxctrl = sizeof(MIXERCONTROL);
mxlctrl.pamxctrl = &mxctrl;

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

MIXERCONTROLDETAILS mxcd;
memset (&mxcd, 0x00, sizeof(mxcd));
mxcd.cbStruct = sizeof(mxcd);
mxcd.dwControlID = mxctrl.dwControlID;
mxcd.cChannels = cChannels;
mxcd.hwndOwner = 0;
mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
mxcd.paDetails = (LPVOID)pUnsigned;
mixerGetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

if (mxctrl.Bounds.dwMaximum != mxctrl.Bounds.dwMinimum)
{
if (pUnsigned[0].dwValue <= mxctrl.Bounds.dwMinimum)
dwVol = 0;
else if (pUnsigned[0].dwValue >= mxctrl.Bounds.dwMaximum)
dwVol = 100;
else
dwVol = (pUnsigned[0].dwValue - mxctrl.Bounds.dwMinimum) *
100 / (mxctrl.Bounds.dwMaximum - mxctrl.Bounds.dwMinimum);
}

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
return dwVol;
}

void Volume_SetMasterOut (LONG dwVol)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

for (size_t iChannel = 0; iChannel < cChannels; ++iChannel)
{
pUnsigned[iChannel].dwValue = mxctrl.Bounds.dwMinimum +
(mxctrl.Bounds.dwMaximum-mxctrl.Bounds.dwMinimum) * dwVol / 100;
}
mixerSetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
}

void Volume_UnmuteMasterOut (void)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERLINECONTROLS mxlctrl;
memset (&mxlctrl, 0x00, sizeof(mxlctrl));
mxlctrl.cbStruct = sizeof(mxlctrl);
mxlctrl.dwLineID = mxl.dwLineID;
mxlctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
mxlctrl.cControls = 1;
mxlctrl.cbmxctrl = sizeof MIXERCONTROL;
mxlctrl.pamxctrl = &mxctrl;

if (mixerGetLineControls ((HMIXEROBJ)hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN) * cChannels;
LPMIXERCONTROLDETAILS_BOOLEAN pDetails;
pDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)GlobalAlloc (GMEM_FIXED,
cbDetails);

mixerGetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

for (size_t ii = 0; ii < cChannels; ++ii)
pDetails[ii].fValue = 0;

mixerSetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

GlobalFree ((HGLOBAL)pDetails);
}
}

mixerClose(hmx);

if (Volume_GetMasterOut() < 10)
Volume_SetMasterOut (50);
}

/*
* WAVEOUT
____________________________________________________________________
*
*/

LONG Volume_GetOut (void)
{
LONG dwVol = 100;

HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERLINE mxl;
mxl.cbStruct = sizeof(mxl);
mxl.dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
if (mixerGetLineInfo ((HMIXEROBJ)hmx, &mxl,
MIXER_GETLINEINFOF_COMPONENTTYPE) == 0)
{
size_t cConnections = mxl.cConnections;
for (size_t iConn = 0; iConn < cConnections; ++iConn)
{
mxl.dwSource = iConn;
mixerGetLineInfo ((HMIXEROBJ)hmx, &mxl,
MIXER_GETLINEINFOF_DESTINATION);
if (MIXERLINE_COMPONENTTYPE_DST_SPEAKERS == mxl.dwComponentType)
break;
}

MIXERCONTROL mxctrl;
memset (&mxctrl, 0x00, sizeof(MIXERCONTROL));
mxctrl.cbStruct = sizeof(mxctrl);

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
return dwVol;
}

void Volume_SetOut (LONG dwVol)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERCONTROL mxctrl;
memset (&mxctrl, 0x00, sizeof(MIXERCONTROL));
mxctrl.cbStruct = sizeof(mxctrl);

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
}

void Volume_UnmuteOut (void)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERCONTROL mxctrl;
memset (&mxctrl, 0x00, sizeof(mxctrl));
mxctrl.cbStruct = sizeof(mxctrl);

MIXERLINECONTROLS mxlctrl;
memset (&mxlctrl, 0x00, sizeof(mxlctrl));
mxlctrl.cbStruct = sizeof(mxlctrl);
mxlctrl.dwLineID = mxl.dwLineID;
mxlctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
mxlctrl.cControls = 1;
mxlctrl.cbmxctrl = sizeof MIXERCONTROL;
mxlctrl.pamxctrl = &mxctrl;

if (mixerGetLineControls ((HMIXEROBJ)hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN) * cChannels;
LPMIXERCONTROLDETAILS_BOOLEAN pDetails;
pDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)GlobalAlloc (GMEM_FIXED,
cbDetails);

mixerGetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

for (size_t ii = 0; ii < cChannels; ++ii)
pDetails[ii].fValue = 0;

mixerSetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

GlobalFree ((HGLOBAL)pDetails);
}

mixerClose(hmx);
}

if (Volume_GetOut() < 50)
Volume_SetOut (75);
}

/*
* MASTER RECORD
______________________________________________________________
*
*/

LONG Volume_GetMasterIn (void)
{
LONG dwVol = 100;

HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
return dwVol;
}

void Volume_SetMasterIn (LONG dwVol)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
}

void Volume_UnmuteMasterIn (void)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERLINECONTROLS mxlctrl;
memset (&mxlctrl, 0x00, sizeof(mxlctrl));
mxlctrl.cbStruct = sizeof(mxlctrl);
mxlctrl.dwLineID = mxl.dwLineID;
mxlctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
mxlctrl.cControls = 1;
mxlctrl.cbmxctrl = sizeof MIXERCONTROL;
mxlctrl.pamxctrl = &mxctrl;

if (mixerGetLineControls ((HMIXEROBJ)hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN) * cChannels;
LPMIXERCONTROLDETAILS_BOOLEAN pDetails;
pDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)GlobalAlloc (GMEM_FIXED,
cbDetails);

mixerGetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

for (size_t ii = 0; ii < cChannels; ++ii)
pDetails[ii].fValue = 0;

mixerSetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

GlobalFree ((HGLOBAL)pDetails);
}
}

mixerClose (hmx);

if (Volume_GetMasterIn() < 25)
Volume_SetMasterIn (75);
}

/*
* WAVEIN
_____________________________________________________________________
*
*/

LONG Volume_GetIn (void)
{
LONG dwVol = 100;

HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERLINE mxl;
mxl.cbStruct = sizeof(mxl);
mxl.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
if (mixerGetLineInfo ((HMIXEROBJ)hmx, &mxl,
MIXER_GETLINEINFOF_COMPONENTTYPE) == 0)
{
size_t cConnections = mxl.cConnections;
for (size_t iConn = 0; iConn < cConnections; ++iConn)
{
mxl.dwSource = iConn;
mixerGetLineInfo ((HMIXEROBJ)hmx, &mxl, MIXER_GETLINEINFOF_SOURCE);
if (MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE == mxl.dwComponentType)
break;
}

MIXERCONTROL mxctrl;
memset (&mxctrl, 0x00, sizeof(MIXERCONTROL));
mxctrl.cbStruct = sizeof(mxctrl);

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
return dwVol;
}

void Volume_SetIn (LONG dwVol)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERCONTROL mxctrl;
memset (&mxctrl, 0x00, sizeof(MIXERCONTROL));
mxctrl.cbStruct = sizeof(mxctrl);

if (mixerGetLineControls ((HMIXEROBJ) hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbUnsigned = cChannels *
sizeof(MIXERCONTROLDETAILS_UNSIGNED);
LPMIXERCONTROLDETAILS_UNSIGNED pUnsigned;
pUnsigned = (LPMIXERCONTROLDETAILS_UNSIGNED)GlobalAlloc
(GMEM_FIXED, cbUnsigned);

GlobalFree (pUnsigned);
}
}

mixerClose(hmx);
}

void Volume_SelectIn (void)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

LPMIXERCONTROL aControls;
aControls = (LPMIXERCONTROL)GlobalAlloc (GMEM_FIXED, cbControls);
memset (aControls, 0x00, cbControls);

MIXERLINECONTROLS mxlctrl;
memset (&mxlctrl, 0x00, sizeof(mxlctrl));
mxlctrl.cbStruct = sizeof(mxlctrl);
mxlctrl.dwLineID = mxl.dwLineID;
mxlctrl.dwControlID = 0;
mxlctrl.cControls = mxl.cControls;
mxlctrl.cbmxctrl = sizeof(MIXERCONTROL);
mxlctrl.pamxctrl = aControls;

mixerGetLineControls ((HMIXEROBJ)hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ALL);

for (size_t iControl = 0; iControl < mxl.cControls; ++iControl)
{
if ((aControls[iControl].dwControlType &
MIXERCONTROL_CT_CLASS_MASK) == MIXERCONTROL_CT_CLASS_LIST)
break;
}

if (iControl < mxl.cControls)
{
BOOL bOneItemOnly = FALSE;
switch (aControls[iControl].dwControlType)
{
case MIXERCONTROL_CONTROLTYPE_MUX:
case MIXERCONTROL_CONTROLTYPE_SINGLESELECT:
bOneItemOnly = TRUE;
break;
}

DWORD cChannels = mxl.cChannels;
if (aControls[iControl].fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

DWORD cMultipleItems = 0;
if (aControls[iControl].fdwControl &
MIXERCONTROL_CONTROLF_MULTIPLE)
cMultipleItems = aControls[iControl].cMultipleItems;

// Get the text description of each item
size_t cbText = sizeof(MIXERCONTROLDETAILS_LISTTEXT) * cChannels *
cMultipleItems;

LPMIXERCONTROLDETAILS_LISTTEXT pText;
pText = (LPMIXERCONTROLDETAILS_LISTTEXT)GlobalAlloc (GMEM_FIXED,
cbText);

MIXERCONTROLDETAILS mxcd;
memset (&mxcd, 0x00, sizeof(mxcd));
mxcd.cbStruct = sizeof(mxcd);
mxcd.dwControlID = aControls[iControl].dwControlID;
mxcd.cChannels = cChannels;
mxcd.hwndOwner = (HWND)cMultipleItems;
mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXT);
mxcd.paDetails = (LPVOID)pText;
mixerGetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_GETCONTROLDETAILSF_LISTTEXT);

size_t cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN) * cChannels
* cMultipleItems;
LPMIXERCONTROLDETAILS_BOOLEAN pDetails;
pDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)GlobalAlloc (GMEM_FIXED,
cbDetails);
mxcd.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mxcd.paDetails = pDetails;
mixerGetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_GETCONTROLDETAILSF_VALUE);

for (DWORD iItem = 0; iItem < cMultipleItems; iItem += cChannels)
{
if (!lstrcmp (pText[iItem].szName, "Microphone"))
pDetails[ iItem ].fValue = pDetails[ iItem
+cChannels -1 ].fValue = 1;
else if (bOneItemOnly)
pDetails[ iItem ].fValue = pDetails[ iItem
+cChannels -1 ].fValue = 0;
}

mixerSetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_GETCONTROLDETAILSF_VALUE);

GlobalFree ((HGLOBAL)pText);
GlobalFree ((HGLOBAL)pDetails);
}

GlobalFree ((HGLOBAL)aControls);
}

mixerClose (hmx);
}

void Volume_UnmuteIn (void)
{
HMIXER hmx;
mixerOpen (&hmx, 0, 0, 0, 0);

MIXERCONTROL mxctrl;
memset (&mxctrl, 0x00, sizeof(mxctrl));
mxctrl.cbStruct = sizeof(mxctrl);

MIXERLINECONTROLS mxlctrl;
memset (&mxlctrl, 0x00, sizeof(mxlctrl));
mxlctrl.cbStruct = sizeof(mxlctrl);
mxlctrl.dwLineID = mxl.dwLineID;
mxlctrl.dwControlType = MIXERCONTROL_CONTROLTYPE_MUTE;
mxlctrl.cControls = 1;
mxlctrl.cbmxctrl = sizeof MIXERCONTROL;
mxlctrl.pamxctrl = &mxctrl;

if (mixerGetLineControls ((HMIXEROBJ)hmx, &mxlctrl,
MIXER_GETLINECONTROLSF_ONEBYTYPE) == 0)
{
DWORD cChannels = mxl.cChannels;
if (mxctrl.fdwControl & MIXERCONTROL_CONTROLF_UNIFORM)
cChannels = 1;

size_t cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN) * cChannels;
LPMIXERCONTROLDETAILS_BOOLEAN pDetails;
pDetails = (LPMIXERCONTROLDETAILS_BOOLEAN)GlobalAlloc (GMEM_FIXED,
cbDetails);

mixerGetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

for (size_t ii = 0; ii < cChannels; ++ii)
pDetails[ii].fValue = 0;

mixerSetControlDetails ((HMIXEROBJ)hmx, &mxcd,
MIXER_SETCONTROLDETAILSF_VALUE);

GlobalFree ((HGLOBAL)pDetails);
}
}

mixerClose (hmx);

Volume_SelectIn();

if (Volume_GetIn() < 50)
Volume_SetIn (85);
}

0 new messages