开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
VolumeOutMaster.cpp
资源名称：volume_manipulation.zip　[点击查看]
上传用户：lywczg
上传日期：2007-01-03
资源大小：15k
文件大小：15k
源码类别：

Audio

开发平台：

Visual C++

VolumeOutMaster.cpp：源码内容
  1. // VolumeOutMaster.cpp : Module interface implementation.
  2. // Developer : Alex Chmut
  3. // Created : 8/11/98
  4. #include "StdAfx.h"
  5. #include "VolumeOutMaster.h"
  7. /////////////////////////////////////////////////////////////////////////////
  8. //  Defines
  9. #define BAD_DWORD (DWORD)-1
  10. #define WND_CLASS_NAME "Master Output Volume Msg Wnd Class"
  11. #define WND_NAME "Master Output Volume Msg Wnd"
  13. /////////////////////////////////////////////////////////////////////////////
  14. //  Globals
  15. PCVolumeOutMaster g_pThis = NULL;
  17. ////////////////////////////////////////////////////////////
  19. //{{{ Audio specific functions
  20. #define AUDFREQ 22050 // Frequency
  21. #define AUDCHANNELS 1 // Number of channels
  22. #define AUDBITSMPL 16 // Number of bits per sample
  23. inline
  24. void SetDeviceType( WAVEFORMATEX* pwfe )
  25. {
  26. memset( pwfe, 0, sizeof(WAVEFORMATEX) );
  27. WORD  nBlockAlign = (AUDCHANNELS*AUDBITSMPL)/8;
  28. DWORD nSamplesPerSec = AUDFREQ;
  29. pwfe->wFormatTag = WAVE_FORMAT_PCM;
  30. pwfe->nChannels = AUDCHANNELS;
  31. pwfe->nBlockAlign = nBlockAlign;
  32. pwfe->nSamplesPerSec = nSamplesPerSec;
  33. pwfe->wBitsPerSample = AUDBITSMPL;
  34. pwfe->nAvgBytesPerSec = nSamplesPerSec*nBlockAlign;
  35. }
  36. //}}} Audio specific functions
  38. /////////////////////////////////////////////////////////////////////////////
  39. //  Implementation
  40. //////////////
  41. CVolumeOutMaster::CVolumeOutMaster()
  42. : m_bOK(false),
  43. m_bInitialized(false),
  44. m_bAvailable(false),
  46. m_uMixerID(0L),
  47. m_dwMixerHandle(0L),
  48. m_hWnd(NULL),
  50. m_dwMinimalVolume(BAD_DWORD),
  51. m_dwMaximalVolume(BAD_DWORD),
  53. m_pfUserSink(NULL),
  54. m_dwUserValue(0L)
  55. {
  56. if ( m_bOK = Init() )
  57. {
  58. g_pThis = this;
  59. if ( !Initialize() )
  60. {
  61. Done();
  62. g_pThis = NULL;
  63. }
  64. }
  65. }
  66. //////////////
  67. CVolumeOutMaster::~CVolumeOutMaster()
  68. {
  69. if ( m_bOK )
  70. Done();
  71. g_pThis = NULL;
  72. }
  73. //////////////
  74. bool CVolumeOutMaster::Init()
  75. {
  76. if ( !mixerGetNumDevs() )
  77. return false;
  78. // Getting Mixer ID
  79. HWAVEOUT hwaveOut;
  80. MMRESULT mmResult;
  81. WAVEFORMATEX WaveFmt;
  82. SetDeviceType( &WaveFmt );
  83. mmResult = waveOutOpen( &hwaveOut, WAVE_MAPPER, &WaveFmt, 0L, 0L, CALLBACK_NULL );
  84. if ( mmResult != MMSYSERR_NOERROR )
  85. {
  86. TRACE(".MasterOutputVolume: FAILURE: Could not open WaveOut Mapper. mmResult=%dn", mmResult );
  87. return false;
  88. } else {
  89. mmResult = mixerGetID( (HMIXEROBJ)hwaveOut, &m_uMixerID, MIXER_OBJECTF_HWAVEOUT );
  90. waveOutClose( hwaveOut );
  91. if ( mmResult != MMSYSERR_NOERROR )
  92. {
  93. TRACE(".MasterOutputVolume: FAILURE: WaveOut Mapper in Mixer is not available. mmResult=%dn", mmResult );
  94. return false;
  95. }
  96. }
  97. // Exposing Window to Mixer
  98. WNDCLASSEX wcx;
  99. memset( &wcx, 0, sizeof(WNDCLASSEX) );
  100. wcx.cbSize = sizeof(WNDCLASSEX);
  101. wcx.lpszClassName = WND_CLASS_NAME;
  102. wcx.lpfnWndProc = (WNDPROC)MixerWndProc;
  103. ::RegisterClassEx(&wcx);
  104. m_hWnd = CreateWindow( WND_CLASS_NAME,
  105. WND_NAME,
  106. WS_POPUP | WS_DISABLED,
  107. 0, 0, 0, 0,
  108. NULL, NULL, NULL, NULL );
  109. if ( !m_hWnd )
  110. {
  111. TRACE(".MasterOutputVolume: FAILURE: Could not create internal window.n" );
  112. return false;
  113. }
  114. ::ShowWindow(m_hWnd, SW_HIDE);
  115. mmResult = mixerOpen( (LPHMIXER)&m_dwMixerHandle, m_uMixerID, (DWORD)m_hWnd, 0L, CALLBACK_WINDOW );
  116. if ( mmResult != MMSYSERR_NOERROR )
  117. {
  118. TRACE(".MasterOutputVolume: FAILURE: Could not open Mixer. mmResult=%dn", mmResult );
  119. ::DestroyWindow( m_hWnd );
  120. return false;
  121. }
  122. return true;
  123. }
  124. //////////////
  125. void CVolumeOutMaster::Done()
  126. {
  127. if ( mixerClose( (HMIXER)m_dwMixerHandle ) != MMSYSERR_NOERROR )
  128. {
  129. TRACE(".MasterOutputVolume: WARNING: Could not close Mixer.n" );
  130. }
  131. ::DestroyWindow( m_hWnd );
  132. m_bInitialized = false;
  133. m_bOK = false;
  134. }
  135. //////////////
  136. void CVolumeOutMaster::OnControlChanged( DWORD dwControlID )
  137. {
  138. if ( m_dwVolumeControlID == dwControlID )
  139. {
  140. DWORD dwVolume = GetCurrentVolume();
  141. if ( (dwVolume!=BAD_DWORD) && (m_pfUserSink) )
  142. {
  143. (*m_pfUserSink)( dwVolume, m_dwUserValue );
  144. }
  145. }
  146. }
  147. //////////////
  148. bool CVolumeOutMaster::Initialize()
  149. {
  150. MMRESULT mmResult;
  151. if ( !m_bOK )
  152. return false;
  153. TRACE(".MasterOutputVolume: Initializing for Source MasterOut Line ..n" );
  154. MIXERLINE MixerLine;
  155. memset( &MixerLine, 0, sizeof(MIXERLINE) );
  156. MixerLine.cbStruct = sizeof(MIXERLINE);
  157. MixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
  158. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &MixerLine, MIXER_GETLINEINFOF_COMPONENTTYPE );
  159. if ( mmResult != MMSYSERR_NOERROR )
  160. {
  161. TRACE(".MasterOutputVolume: FAILURE: Could not get Speakers Destionation Line for the MasterOut Source Line while initilaizing. mmResult=%dn", mmResult );
  162. return false;
  163. }
  165. MIXERCONTROL Control;
  166. memset( &Control, 0, sizeof(MIXERCONTROL) );
  167. Control.cbStruct = sizeof(MIXERCONTROL);
  169. MIXERLINECONTROLS LineControls;
  170. memset( &LineControls, 0, sizeof(MIXERLINECONTROLS) );
  171. LineControls.cbStruct = sizeof(MIXERLINECONTROLS);
  173. LineControls.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
  174. LineControls.dwLineID = MixerLine.dwLineID;
  175. LineControls.cControls = 1;
  176. LineControls.cbmxctrl = sizeof(MIXERCONTROL);
  177. LineControls.pamxctrl = &Control;
  178. mmResult = mixerGetLineControls( (HMIXEROBJ)m_dwMixerHandle, &LineControls, MIXER_GETLINECONTROLSF_ONEBYTYPE );
  179. if ( mmResult == MMSYSERR_NOERROR )
  180. {
  181. if ( !(Control.fdwControl & MIXERCONTROL_CONTROLF_DISABLED) )
  182. {
  183. m_bAvailable = true;
  184. TRACE(".MasterOutputVolume: "%s" Volume control for the Speakers Source Line adopted.n", Control.szShortName );
  185. } else {
  186. TRACE(".MasterOutputVolume: WARNING: The Volume Control is disabled.n" );
  187. }
  188. } else {
  189. TRACE(".MasterOutputVolume: WARNING: Could not get the Speakers Source line Volume Control while initilaizing. mmResult=%dn", mmResult );
  190. }
  192. m_nChannelCount = MixerLine.cChannels;
  193. m_dwLineID = LineControls.dwLineID;
  194. m_dwVolumeControlID = Control.dwControlID;
  195. m_dwMinimalVolume = Control.Bounds.dwMinimum;
  196. m_dwMaximalVolume = Control.Bounds.dwMaximum;
  197. m_dwVolumeStep = Control.Metrics.cSteps;
  199. m_bInitialized = true;
  200. return true;
  201. }
  202. //////////////
  203. void CVolumeOutMaster::EnableLine( bool bEnable )
  204. {
  205. if ( !m_bInitialized )
  206. return;
  207. bool bAnyEnabled = false;
  208. MMRESULT mmResult;
  210. MIXERLINE lineDestination;
  211. memset( &lineDestination, 0, sizeof(MIXERLINE) );
  212. lineDestination.cbStruct = sizeof(MIXERLINE);
  213. lineDestination.dwLineID = m_dwLineID;
  214. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &lineDestination, MIXER_GETLINEINFOF_LINEID );
  215. if ( mmResult != MMSYSERR_NOERROR )
  216. {
  217. if ( bEnable )
  218. {
  219. TRACE(".MasterOutputVolume: FAILURE: Could not get the Speakers Destination Line while enabling. mmResult=%dn", mmResult );
  220. } else {
  221. TRACE(".MasterOutputVolume: FAILURE: Could not get the Speakers Destination Line while disabling. mmResult=%dn", mmResult );
  222. }
  223. return;
  224. }
  225. // Getting all line's controls
  226. int nControlCount = lineDestination.cControls;
  227. int nChannelCount = lineDestination.cChannels;
  228. MIXERLINECONTROLS LineControls;
  229. memset( &LineControls, 0, sizeof(MIXERLINECONTROLS) );
  230. MIXERCONTROL* aControls = (MIXERCONTROL*)malloc( nControlCount * sizeof(MIXERCONTROL) );
  231. if ( !aControls )
  232. {
  233. if ( bEnable )
  234. {
  235. TRACE(".MasterOutputVolume: FAILURE: Out of memory while enabling the line.n" );
  236. } else {
  237. TRACE(".MasterOutputVolume: FAILURE: Out of memory while disabling the line.n" );
  238. }
  239. return;
  240. }
  241. memset( &aControls[0], 0, sizeof(nControlCount * sizeof(MIXERCONTROL)) );
  242. for ( int i = 0; i < nControlCount; i++ )
  243. {
  244. aControls[i].cbStruct = sizeof(MIXERCONTROL);
  245. }
  246. LineControls.cbStruct = sizeof(MIXERLINECONTROLS);
  247. LineControls.dwLineID = lineDestination.dwLineID;
  248. LineControls.cControls = nControlCount;
  249. LineControls.cbmxctrl = sizeof(MIXERCONTROL);
  250. LineControls.pamxctrl = &aControls[0];
  251. mmResult = mixerGetLineControls( (HMIXEROBJ)m_dwMixerHandle, &LineControls, MIXER_GETLINECONTROLSF_ALL );
  252. if ( mmResult == MMSYSERR_NOERROR )
  253. {
  254. for ( i = 0; i < nControlCount; i++ )
  255. {
  256. LONG lValue;
  257. bool bReadyToSet = false;
  258. switch (aControls[i].dwControlType)
  259. {
  260. case MIXERCONTROL_CONTROLTYPE_MUTE:
  261. lValue = (BOOL)!bEnable;
  262. bReadyToSet = true;
  263. break;
  264. case MIXERCONTROL_CONTROLTYPE_SINGLESELECT:
  265. lValue = (BOOL)bEnable;
  266. bReadyToSet = true;
  267. break;
  268. case MIXERCONTROL_CONTROLTYPE_MUX:
  269. lValue = (BOOL)bEnable;
  270. bReadyToSet = true;
  271. break;
  272. case MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT:
  273. lValue = (BOOL)bEnable;
  274. bReadyToSet = true;
  275. break;
  276. case MIXERCONTROL_CONTROLTYPE_MIXER:
  277. lValue = (BOOL)bEnable;
  278. bReadyToSet = true;
  279. break;
  280. }
  281. if ( bReadyToSet )
  282. {
  283. MIXERCONTROLDETAILS_BOOLEAN* aDetails = NULL;
  284. int nMultipleItems = aControls[i].cMultipleItems;
  285. int nChannels = nChannelCount;
  286. // MIXERCONTROLDETAILS
  287. MIXERCONTROLDETAILS ControlDetails;
  288. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  289. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  290. ControlDetails.dwControlID = aControls[i].dwControlID;
  291. if ( aControls[i].fdwControl & MIXERCONTROL_CONTROLF_UNIFORM )
  292. {
  293. nChannels = 1;
  294. }
  295. if ( aControls[i].fdwControl & MIXERCONTROL_CONTROLF_MULTIPLE )
  296. {
  297. nMultipleItems = aControls[i].cMultipleItems;
  298. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nMultipleItems*nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  299. if ( !aDetails )
  300. {
  301. if ( bEnable )
  302. {
  303. TRACE(".MasterOutputVolume: FAILURE: Out of memory while enabling the line.n" );
  304. } else {
  305. TRACE(".MasterOutputVolume: FAILURE: Out of memory while disabling the line.n" );
  306. }
  307. continue;
  308. }
  309. for ( int nItem = 0; nItem < nMultipleItems; nItem++ )
  310. {
  311. /*
  312. if ( ( aControls[i].dwControlType & MIXERCONTROL_CONTROLTYPE_SINGLESELECT )
  313.   && ( nItem > 0 ) )
  314. {
  315. lValue = (LONG)!((BOOL)lValue);
  316. }
  317. */
  318. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  319. {
  320. aDetails[nItem+nChannel].fValue = lValue;
  321. }
  322. }
  323. } else {
  324. nMultipleItems = 0;
  325. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  326. if ( !aDetails )
  327. {
  328. if ( bEnable )
  329. {
  330. TRACE(".MasterOutputVolume: FAILURE: Out of memory while enabling the line.n" );
  331. } else {
  332. TRACE(".MasterOutputVolume: FAILURE: Out of memory while disabling the line.n" );
  333. }
  334. continue;
  335. }
  336. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  337. {
  338. aDetails[nChannel].fValue = (LONG)lValue;
  339. }
  340. }
  341. ControlDetails.cChannels = nChannels;
  342. ControlDetails.cMultipleItems = nMultipleItems;
  343. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
  344. ControlDetails.paDetails = &aDetails[0];
  345. mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, 0L );
  346. if ( mmResult == MMSYSERR_NOERROR )
  347. {
  348. if ( bEnable )
  349. {
  350. TRACE(".MasterOutputVolume: Enabling Line: Speakers Line control "%s"(0x%X) has been set to %d.n", aControls[i].szShortName, aControls[i].dwControlType, lValue );
  351. } else {
  352. TRACE(".MasterOutputVolume: Disabling Line: Speakers Line control "%s"(0x%X) has been set to %d.n", aControls[i].szShortName, aControls[i].dwControlType, lValue );
  353. }
  354. bAnyEnabled = true;
  355. }
  356. free( aDetails );
  357. }
  358. }
  359. } else {
  360. if ( bEnable )
  361. {
  362. TRACE(".MasterOutputVolume: FAILURE: Could not get the line controls while enabling. mmResult=%dn", mmResult );
  363. } else {
  364. TRACE(".MasterOutputVolume: FAILURE: Could not get the line controls while disabling. mmResult=%dn", mmResult );
  365. }
  366. }
  367. free( aControls );
  368. if ( !bAnyEnabled )
  369. {
  370. if ( bEnable )
  371. {
  372. TRACE(".MasterOutputVolume: WARNING: No controls were found for enabling the line.n" );
  373. } else {
  374. TRACE(".MasterOutputVolume: WARNING: No controls were found for disabling the line.n" );
  375. }
  376. }
  377. }
  378. //////////////////////////////////////////////
  379. // IVolume interface
  380. //////////////
  381. bool CVolumeOutMaster::IsAvailable()
  382. {
  383. return m_bAvailable;
  384. }
  385. //////////////
  386. void CVolumeOutMaster::Enable()
  387. {
  388. EnableLine( true );
  389. }
  390. void CVolumeOutMaster::Disable()
  391. {
  392. EnableLine( false );
  393. }
  394. //////////////
  395. DWORD CVolumeOutMaster::GetVolumeMetric()
  396. {
  397. if ( !m_bAvailable )
  398. return BAD_DWORD;
  399. return m_dwVolumeStep;
  400. }
  401. //////////////
  402. DWORD CVolumeOutMaster::GetMinimalVolume()
  403. {
  404. if ( !m_bAvailable )
  405. return BAD_DWORD;
  406. return m_dwMinimalVolume;
  407. }
  408. //////////////
  409. DWORD CVolumeOutMaster::GetMaximalVolume()
  410. {
  411. if ( !m_bAvailable )
  412. return BAD_DWORD;
  413. return m_dwMaximalVolume;
  414. }
  415. //////////////
  416. DWORD CVolumeOutMaster::GetCurrentVolume()
  417. {
  418. if ( !m_bAvailable )
  419. return BAD_DWORD;
  420. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  421. if ( !aDetails )
  422. return BAD_DWORD;
  423. MIXERCONTROLDETAILS ControlDetails;
  424. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  425. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  426. ControlDetails.dwControlID = m_dwVolumeControlID;
  427. ControlDetails.cChannels = m_nChannelCount;
  428. ControlDetails.cMultipleItems = 0;
  429. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  430. ControlDetails.paDetails = &aDetails[0];
  431. MMRESULT mmResult = mixerGetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_GETCONTROLDETAILSF_VALUE );
  432. DWORD dw = aDetails[0].dwValue;
  433. free( aDetails );
  434. if ( mmResult != MMSYSERR_NOERROR )
  435. {
  436. TRACE(".MasterOutputVolume: FAILURE: Could not get volume. mmResult=%dn", mmResult );
  437. return BAD_DWORD;
  438. }
  439. return dw;
  440. }
  441. //////////////
  442. void CVolumeOutMaster::SetCurrentVolume( DWORD dwValue )
  443. {
  444. if ( !m_bAvailable || (dwValue<m_dwMinimalVolume) || (dwValue>m_dwMaximalVolume) )
  445. return;
  446. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  447. if ( !aDetails )
  448. return;
  449. for ( int i = 0; i < m_nChannelCount; i++ )
  450. {
  451. aDetails[i].dwValue = dwValue;
  452. }
  453. MIXERCONTROLDETAILS ControlDetails;
  454. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  455. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  456. ControlDetails.dwControlID = m_dwVolumeControlID;
  457. ControlDetails.cChannels = m_nChannelCount;
  458. ControlDetails.cMultipleItems = 0;
  459. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  460. ControlDetails.paDetails = &aDetails[0];
  461. MMRESULT mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_SETCONTROLDETAILSF_VALUE );
  462. free( aDetails );
  463. if ( mmResult != MMSYSERR_NOERROR )
  464. {
  465. TRACE(".MasterOutputVolume: FAILURE: Could not set volume(%d) mmResult=%dn", dwValue, mmResult );
  466. }
  467. }
  468. //////////////
  469. void CVolumeOutMaster::RegisterNotificationSink( PONMICVOULUMECHANGE pfUserSink, DWORD dwUserValue )
  470. {
  471. m_pfUserSink = pfUserSink;
  472. m_dwUserValue = dwUserValue;
  473. }
  474. ////////////////////////////////////////////////////////////////////////
  475. LRESULT CALLBACK CVolumeOutMaster::MixerWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  476. {
  477. if ( uMsg == MM_MIXM_CONTROL_CHANGE )
  478. {
  479. if ( g_pThis )
  480. {
  481. g_pThis->OnControlChanged( (DWORD)lParam );
  482. }
  483. }
  484. return ::DefWindowProc( hwnd, uMsg, wParam, lParam);
  485. }