aview-app 1.0.2

package/aardio/lib/sys/audioVolume/.res/volumeCtrl2.cpp

@@ -0,0 +1,446 @@
+
+#include "stdafx.h"
+#include "VolumeCtrl2.h"
+#pragma comment(lib, "Winmm.lib")
+
+extern "C" __declspec(dllexport) CVolumeCtrl2* __cdecl CreateVolumeCtrl() { 
+    return new CVolumeCtrl2();
+}
+    
+extern "C" __declspec(dllexport) void __cdecl DeleteVolumeCtrl( CVolumeCtrl2* pCtrl) {
+    delete pCtrl;
+}
+
+extern "C" __declspec(dllexport) int __cdecl GetVolume(CVolumeCtrl2* pCtrl) {
+	return pCtrl->GetVolume();
+}
+
+extern "C" __declspec(dllexport) void __cdecl SetVolume(CVolumeCtrl2* pCtrl,int nVol) {
+	pCtrl->SetVolume(nVol);;
+}
+
+extern "C" __declspec(dllexport) BOOL __cdecl GetMute(CVolumeCtrl2* pCtrl) {
+	return pCtrl->GetMute();
+}
+ 
+extern "C" __declspec(dllexport) void __cdecl SetMute(CVolumeCtrl2* pCtrl,BOOL bMute) {
+	pCtrl->SetMute(bMute);;
+}
+
+extern "C" __declspec(dllexport) IAudioMeterInformation * __cdecl GetMeterInfomation(CVolumeCtrl2* pCtrl) {
+	return pCtrl->GetMeterInfomation();
+}
+
+
+CVolumeCtrl2::CVolumeCtrl2(void)
+	:m_pEndptVolCtrl(NULL),
+	m_pEnumerator(NULL),
+	m_pDevice(NULL),
+	m_guidMyContext(GUID_NULL)
+{
+	m_bVistaLater = true;
+
+	OSVERSIONINFO info;
+	ZeroMemory(&info, sizeof(OSVERSIONINFO));
+	info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+	if(GetVersionEx(&info))
+	{
+		if(info.dwMajorVersion <= 5)
+		{
+			m_bVistaLater = false;
+		} 
+	}
+
+	if( m_bVistaLater )
+	{
+		InitEndPointVistaLater();
+	}
+}
+
+CVolumeCtrl2::~CVolumeCtrl2(void)
+{
+	if(m_bVistaLater)
+	{
+		UninitEndPointVistaLater();
+	} 
+}
+
+IAudioMeterInformation * CVolumeCtrl2::GetMeterInfomation()
+{
+	if(m_bVistaLater){
+		m_pMeterInfomation->AddRef();
+		return m_pMeterInfomation;
+	}
+	return NULL;
+}
+
+int CVolumeCtrl2::GetVolume()
+{
+	if(!m_bVistaLater){
+		return GetVolumeXp(0); 
+	}
+	else{
+		DWORD dwNewVol = 0;
+		GetVolumeVistaLater(&dwNewVol);
+		return dwNewVol;
+	}
+}
+
+BOOL CVolumeCtrl2::SetVolume(int nVol)
+{
+	if(!m_bVistaLater){
+		long nXPSetVol = nVol;
+		return SetVolumeXp(0, nXPSetVol);
+	}
+	else{
+		int nWin7SetVol = nVol ;
+		return SetVolumeVistaLater(nWin7SetVol);
+	}
+}
+
+BOOL CVolumeCtrl2::SetMute(BOOL bMute)
+{
+	if(!m_bVistaLater){
+		return SetMuteXp(0, bMute);
+	}
+	else{
+		return SetMuteVistaLater(bMute);
+	}
+}
+
+BOOL CVolumeCtrl2::GetMute()
+{
+	if(!m_bVistaLater){
+		return GetMuteXp(0);
+	}
+	else{
+		return GetMuteVistaLater();
+	}
+}
+
+
+unsigned int CVolumeCtrl2::GetVolumeXp(int   dev)
+{
+
+	long   device;
+	unsigned   int rt=0;
+	MIXERCONTROL   volCtrl;
+	HMIXER   hmixer;
+	switch   (dev)
+	{
+	case   1:
+		device=MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;   break;
+	case   2:
+		device=MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;   break;
+	case   3:
+		device=MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;   break;
+
+	default:
+		device=MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
+	}
+
+	if(mixerOpen(&hmixer,   0,   0,   0,   0))   return   0;
+	if(!GetVolumeControlXp(hmixer,device,MIXERCONTROL_CONTROLTYPE_VOLUME,&volCtrl))
+		return   0;
+	rt=GetVolumeValueXp(hmixer,&volCtrl)*MAX_VOL/volCtrl.Bounds.lMaximum;
+	mixerClose(hmixer);
+	return   rt;
+
+}
+
+
+BOOL CVolumeCtrl2::SetVolumeXp(long dev,long   vol)
+{ 
+	long   device;
+	BOOL   rc = FALSE;
+	MIXERCONTROL   volCtrl;
+	HMIXER   hmixer;
+	switch   (dev)
+	{
+	case   1:
+		device=MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;   break;
+	case   2:
+		device=MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;   break;
+	case   3:
+		device=MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;   break;
+
+	default:
+		device=MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
+	}
+
+	if(mixerOpen(&hmixer,   0,   0,   0,   0))   return   0;
+
+	if(GetVolumeControlXp(hmixer,device,MIXERCONTROL_CONTROLTYPE_VOLUME,&volCtrl))
+	{
+		vol=vol*volCtrl.Bounds.lMaximum/MAX_VOL;
+		if(SetVolumeValueXp(hmixer,&volCtrl,vol))
+			rc=true;
+	}
+	mixerClose(hmixer);
+	return   rc;
+}
+
+BOOL CVolumeCtrl2::SetMuteXp(long   dev,long   vol)
+{
+	long   device;
+	BOOL   rc = FALSE;
+	MIXERCONTROL   volCtrl;
+	HMIXER   hmixer;
+	switch   (dev)
+	{
+	case   1:
+		device=MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;   break;
+	case   2:
+		device=MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;   break;
+	case   3:
+		device=MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;   break;
+
+	default:
+		device=MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
+	}
+
+	if(mixerOpen(&hmixer,   0,   0,   0,   0))   return   0;
+	if(GetVolumeControlXp(hmixer,device,MIXERCONTROL_CONTROLTYPE_MUTE,&volCtrl))
+		if(SetMuteValueXp(hmixer,&volCtrl,(BOOL)vol))
+			rc=TRUE;
+	mixerClose(hmixer);
+	return   rc;
+}
+
+
+BOOL CVolumeCtrl2::GetMuteXp(long   dev)
+{
+	long   device;
+	BOOL   rc = FALSE;
+	MIXERCONTROL   volCtrl;
+	HMIXER   hmixer;
+	switch   (dev)
+	{
+	case   1:
+		device=MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;   break;
+	case   2:
+		device=MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;   break;
+	case   3:
+		device=MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;   break;
+	default:
+		device=MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
+	}
+
+	if(mixerOpen(&hmixer,   0,   0,   0,   0))   return   0;
+
+	if(GetVolumeControlXp(hmixer,device,MIXERCONTROL_CONTROLTYPE_MUTE,&volCtrl))
+		rc = GetMuteValueXp(hmixer,&volCtrl);
+	mixerClose(hmixer);
+	return   rc;
+
+}
+
+BOOL  CVolumeCtrl2::GetVolumeControlXp(HMIXER   hmixer   ,long   componentType,long   ctrlType,MIXERCONTROL*   mxc)
+{
+	MIXERLINECONTROLS   mxlc;
+	MIXERLINE   mxl;
+	mxl.cbStruct   =   sizeof(mxl);
+	mxl.dwComponentType   =   componentType;
+	if(!mixerGetLineInfo((HMIXEROBJ)hmixer,   &mxl,   MIXER_GETLINEINFOF_COMPONENTTYPE))
+	{
+		mxlc.cbStruct   =   sizeof(mxlc);
+		mxlc.dwLineID   =   mxl.dwLineID;
+		mxlc.dwControlType   =   ctrlType;
+		mxlc.cControls   =   1;
+		mxlc.cbmxctrl   =   sizeof(MIXERCONTROL);
+		mxlc.pamxctrl   =   mxc;
+
+		if(mixerGetLineControls((HMIXEROBJ)hmixer,&mxlc,MIXER_GETLINECONTROLSF_ONEBYTYPE))
+			return   FALSE;
+		else
+		{
+			return   TRUE;
+		}
+	}
+	return   FALSE;
+}
+
+long CVolumeCtrl2::GetMuteValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc)
+{
+	MIXERCONTROLDETAILS   mxcd;
+	MIXERCONTROLDETAILS_BOOLEAN   mxcdMute;
+	mxcd.hwndOwner   =   0;
+	mxcd.cbStruct   =   sizeof(mxcd);
+	mxcd.dwControlID   =   mxc-> dwControlID;
+	mxcd.cbDetails   =   sizeof(mxcdMute);
+	mxcd.paDetails   =   &mxcdMute;
+	mxcd.cChannels   =   1;
+	mxcd.cMultipleItems   =   0;
+	if   (mixerGetControlDetails((HMIXEROBJ)hmixer,   &mxcd,MIXER_OBJECTF_HMIXER|MIXER_GETCONTROLDETAILSF_VALUE))
+		return   -1;
+	return   mxcdMute.fValue;
+}
+
+unsigned int CVolumeCtrl2::GetVolumeValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc)
+{
+	MIXERCONTROLDETAILS   mxcd;
+	MIXERCONTROLDETAILS_UNSIGNED   vol;   vol.dwValue=0;
+	mxcd.hwndOwner   =   0;
+	mxcd.cbStruct   =   sizeof(mxcd);
+	mxcd.dwControlID   =   mxc-> dwControlID;
+	mxcd.cbDetails   =   sizeof(vol);
+	mxcd.paDetails   =   &vol;
+	mxcd.cChannels   =   1;
+	if(mixerGetControlDetails((HMIXEROBJ)hmixer,   &mxcd,   MIXER_OBJECTF_HMIXER|MIXER_GETCONTROLDETAILSF_VALUE))
+		return   -1;
+	return   vol.dwValue;
+}
+
+BOOL CVolumeCtrl2::SetMuteValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc,   BOOL   mute)
+{
+	MIXERCONTROLDETAILS   mxcd;
+	MIXERCONTROLDETAILS_BOOLEAN   mxcdMute;mxcdMute.fValue=mute;
+	mxcd.hwndOwner   =   0;
+	mxcd.dwControlID   =   mxc-> dwControlID;
+	mxcd.cbStruct   =   sizeof(mxcd);
+	mxcd.cbDetails   =   sizeof(mxcdMute);
+	mxcd.paDetails   =   &mxcdMute;
+	mxcd.cChannels   =   1;
+	mxcd.cMultipleItems   =   0;
+	if   (mixerSetControlDetails((HMIXEROBJ)hmixer,   &mxcd,   MIXER_OBJECTF_HMIXER|MIXER_SETCONTROLDETAILSF_VALUE))
+		return   FALSE;
+	return TRUE;
+}
+
+
+BOOL CVolumeCtrl2::SetVolumeValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc,   long   volume)
+{
+	MIXERCONTROLDETAILS   mxcd;
+	MIXERCONTROLDETAILS_UNSIGNED   vol;vol.dwValue   =   volume;
+	mxcd.hwndOwner   =   0;
+	mxcd.dwControlID   =   mxc-> dwControlID;
+	mxcd.cbStruct   =   sizeof(mxcd);
+	mxcd.cbDetails   =   sizeof(vol);
+	mxcd.paDetails   =   &vol;
+	mxcd.cChannels   =   1;
+	if(mixerSetControlDetails((HMIXEROBJ)hmixer,   &mxcd,   MIXER_OBJECTF_HMIXER|MIXER_SETCONTROLDETAILSF_VALUE))
+		return   FALSE;
+	return   TRUE;
+}
+
+
+BOOL CVolumeCtrl2::InitEndPointVistaLater()
+{
+	if(m_pEndptVolCtrl != NULL)
+		return FALSE;
+
+	//g_EPVolEvents.SetCallback(fCallback); //set callback
+
+	HRESULT hr = S_OK;
+
+	//CoInitialize(NULL);
+
+	hr = CoCreateGuid(&m_guidMyContext);
+	if(FAILED(hr))
+		return FALSE;
+
+	// Get enumerator for audio endpoint devices.
+	hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
+		NULL, CLSCTX_INPROC_SERVER,
+		__uuidof(IMMDeviceEnumerator),
+		(void**)&m_pEnumerator);
+	if(FAILED(hr))
+		return FALSE;
+
+	// Get default audio-rendering device.
+	hr = m_pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &m_pDevice);
+	if(FAILED(hr))
+		return FALSE;
+
+	hr = m_pDevice->Activate(__uuidof(IAudioEndpointVolume),
+		CLSCTX_ALL, NULL, (void**)&m_pEndptVolCtrl);
+	if(FAILED(hr))
+		return FALSE;
+
+
+	hr = m_pDevice->Activate(__uuidof(IAudioMeterInformation),
+		CLSCTX_ALL, NULL, (void**)&m_pMeterInfomation);
+ 
+	if(FAILED(hr))
+		return FALSE;
+
+	return TRUE;
+}
+
+
+BOOL CVolumeCtrl2::SetMuteVistaLater(BOOL bMute)
+{
+	if(m_pEndptVolCtrl)
+		m_pEndptVolCtrl->SetMute(bMute, &m_guidMyContext);
+	return TRUE;
+}
+
+BOOL CVolumeCtrl2::GetMuteVistaLater()
+{
+	BOOL bMute = FALSE;
+	if(m_pEndptVolCtrl)
+		m_pEndptVolCtrl->GetMute(&bMute);
+	return bMute;
+}
+
+BOOL CVolumeCtrl2::SetVolumeVistaLater(DWORD dwVolume)
+{
+	if((int)dwVolume < 0)
+		dwVolume = 0;
+	if((int)dwVolume > MAX_VOL)
+		dwVolume = MAX_VOL;
+
+	if(m_pEndptVolCtrl)
+	{
+		HRESULT hr = m_pEndptVolCtrl->SetMasterVolumeLevelScalar((float)dwVolume / MAX_VOL, &m_guidMyContext);
+		return SUCCEEDED(hr) ? TRUE : FALSE;
+	}
+
+	return FALSE;
+}
+
+BOOL CVolumeCtrl2::GetVolumeVistaLater(DWORD* pdwVolume)
+{
+	float fVolume;
+
+	if(m_pEndptVolCtrl)
+	{
+		m_pEndptVolCtrl->GetMasterVolumeLevelScalar(&fVolume);
+		if(pdwVolume != NULL)
+			*pdwVolume =(DWORD)( MAX_VOL * fVolume + 0.5);
+	}
+
+	return TRUE;
+}
+
+
+BOOL CVolumeCtrl2::UninitEndPointVistaLater()
+{
+	m_pEnumerator->Release();
+	m_pDevice->Release();
+	m_pEndptVolCtrl->Release();
+	m_pMeterInfomation->Release();
+
+	m_pEnumerator = NULL;
+	m_pDevice  = NULL;
+	m_pEndptVolCtrl  = NULL;
+	//CoUninitialize();
+	return TRUE;
+}
+
+BOOL APIENTRY DllMain( HMODULE hModule,
+                       DWORD  ul_reason_for_call,
+                       LPVOID lpReserved
+					 )
+{
+	switch (ul_reason_for_call)
+	{
+	case DLL_PROCESS_ATTACH:
+	case DLL_THREAD_ATTACH:
+	case DLL_THREAD_DETACH:
+	case DLL_PROCESS_DETACH:
+		break;
+	}
+	return TRUE;
+}
+

package/aardio/lib/sys/audioVolume/.res/volumeCtrl2.h

@@ -0,0 +1,52 @@
+
+#pragma once
+#include <Windows.h>
+#include <MMSystem.h>
+#include <mmdeviceapi.h>
+#include <endpointvolume.h>
+
+#define MAX_VOL 100
+
+class CVolumeCtrl2
+{
+public:
+	CVolumeCtrl2(void);
+	~CVolumeCtrl2(void);
+
+public:
+	virtual	int GetVolume();
+	virtual	BOOL SetVolume(int nVol);
+	virtual	BOOL SetMute(BOOL bMute);
+	virtual	BOOL GetMute();
+	IAudioMeterInformation * CVolumeCtrl2::GetMeterInfomation();
+
+protected:
+	unsigned int GetVolumeXp(int   dev);
+	BOOL SetVolumeXp(long   dev,long   vol);
+	BOOL SetMuteXp(long   dev,long   vol);
+	BOOL GetMuteXp(long   dev);
+
+	BOOL   GetVolumeControlXp(HMIXER   hmixer   ,long   componentType,long   ctrlType,MIXERCONTROL*   mxc) ;
+	unsigned int GetVolumeValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc) ;
+	BOOL   SetVolumeValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc,   long   volume) ;
+	long   GetMuteValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc) ;
+	BOOL   SetMuteValueXp(HMIXER   hmixer   ,MIXERCONTROL   *mxc,   BOOL   mute) ;
+
+protected:
+	BOOL InitEndPointVistaLater();
+	BOOL SetMuteVistaLater(BOOL bMute);
+	BOOL GetMuteVistaLater();
+	BOOL SetVolumeVistaLater(DWORD dwVolume);
+	BOOL GetVolumeVistaLater(DWORD* pdwVolume);
+	BOOL UninitEndPointVistaLater();
+protected: 
+	bool m_bVistaLater;
+
+protected:
+	IAudioEndpointVolume *m_pEndptVolCtrl;
+	IAudioMeterInformation *m_pMeterInfomation;
+	IMMDeviceEnumerator *m_pEnumerator;
+	IMMDevice *m_pDevice;
+	GUID m_guidMyContext;
+};
+

package/aardio/lib/sys/audioVolume/.res/volumeCtrl2.vcxproj

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{BD96A69B-BEA9-43A7-9A5B-D9FB56E5A181}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>volumeCtrl2</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;VOLUMECTRL2_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;VOLUMECTRL2_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <None Include="ReadMe.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="stdafx.h" />
+    <ClInclude Include="targetver.h" />
+    <ClInclude Include="VolumeCtrl2.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="volumeCtrl2.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

package/aardio/lib/sys/audioVolume/_.aardio

@@ -0,0 +1,102 @@
+import util.metaProperty;
+import com.interface.IAudioMeterInformation;
+
+namespace sys;
+
+class audioVolume {
+	ctor(){
+		this.handle = _dll.CreateVolumeCtrlP();
+		..table.gc(this,"delete")
+	};
+	delete = function(){
+		if(this.handle){
+			_dll.DeleteVolumeCtrl(this.handle);
+			this.handle = null;
+		}
+	};
+	@_metaProperty;
+}
+
+namespace audioVolume {
+   
+    
+    _dll = ..raw.loadDll($"~\lib\sys\audioVolume\.res\Release\volumeCtrl2.dll",,"cdecl");
+    _metaProperty = ..util.metaProperty(
+    
+    	volume = {
+    		_get = function(){ 
+    			if(owner.handle) return _dll.GetVolume(owner.handle);
+    		}
+    		_set = function(v){
+    			if(owner.handle)return _dll.SetVolume(owner.handle,v);
+    		} 	
+    	};
+    	
+    	mute = {
+    		_get = function(){ 
+    			if(owner.handle) return _dll.GetMuteB(owner.handle);
+    		}
+    		_set = function(v){
+    			if(owner.handle)return _dll.SetMute(owner.handle,v);
+    		} 	
+    	};
+    	
+    	getMeterInfomation = function(){
+    		if(owner.handle){
+    			if(owner["#MeterInfomation"] ) return owner["#MeterInfomation"] ;
+    			
+    			var pMeter = _dll.GetMeterInfomationP(owner.handle,v);
+    			if(pMeter){
+    				var meter = ..com.interface(pMeter,"IAudioMeterInformation");
+    				..com.Release(pMeter);
+    				
+    				owner["#MeterInfomation"] = {
+    						getPeakValue = function() {
+    							var hr,v = meter.GetPeakValue(0); 
+    							if( hr >= 0/*_SUCCEEDED*/){
+    								return v;
+    							}
+    						};
+    						getMeteringChannelCount = function() {
+    							var hr,v = meter.GetMeteringChannelCount(0); 
+    							if( hr >= 0/*_SUCCEEDED*/){
+    								return v;
+    							}
+    						}
+    						getChannelsPeakValues = function(count) {
+    							if(!count) count = owner.channelCount;
+    							if(!count) return;
+    							
+    							var hr,values = meter.GetChannelsPeakValues(count,{float v[]={length=count}}); 
+    							if( hr >= 0/*_SUCCEEDED*/){
+    								return values.v;
+    							}
+    						}
+    						queryHardwareSupport = function() {
+    							var hr,v = meter.QueryHardwareSupport(0); 
+    							if( hr >= 0/*_SUCCEEDED*/){
+    								return v;
+    							}
+    						}
+    				}; 
+    				owner["#MeterInfomation"].channelCount = owner["#MeterInfomation"].getMeteringChannelCount();
+    				
+    				return owner["#MeterInfomation"];
+    			}
+    		} 
+    	}
+    	
+    )
+}
+
+/**intellisense()
+sys.audioVolume = 系统音量控制
+sys.audioVolume() = 创建音量控制对象\n!stdSysAudioVolume.
+!stdSysAudioVolume.volume = 获取或设置系统音量,\n最小值为0,最大值为100
+!stdSysAudioVolume.mute = 获取或设置是否静音
+!stdSysAudioVolume.getMeterInfomation() = 获取实时音量信息\n!stdAudioMeterInfomation.
+!stdAudioMeterInfomation.getPeakValue() = 得到实时主音量百分比,\n最小值为0,最大值为1
+!stdAudioMeterInfomation.getMeteringChannelCount() = 返回声道数
+!stdAudioMeterInfomation.getChannelsPeakValues(.(count) = 返回@count参数指定数目声道的音量数组,\n音量最小值为0,最大值为1,\n参数必须与实际的声道数一致,\n可省略参数自动获取声道数
+!stdAudioMeterInfomation.queryHardwareSupport() = 是否硬件支持
+end intellisense**/