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

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

Audio

开发平台：

Visual C++

VolumeOutWave.cpp：源码内容
  1. // VolumeOutWave.cpp : Module interface implementation.
  2. // Developer : Alex Chmut
  3. // Created : 8/11/98
  4. #include "StdAfx.h"
  5. #include "VolumeOutWave.h"
  7. /////////////////////////////////////////////////////////////////////////////
  8. //  Defines
  9. #define BAD_DWORD (DWORD)-1
  10. #define WND_CLASS_NAME "Wave Output Volume Msg Wnd Class"
  11. #define WND_NAME "Wave Output Volume Msg Wnd"
  13. /////////////////////////////////////////////////////////////////////////////
  14. //  Globals
  15. PCVolumeOutWave 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. CVolumeOutWave::CVolumeOutWave()
  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. CVolumeOutWave::~CVolumeOutWave()
  68. {
  69. if ( m_bOK )
  70. Done();
  71. g_pThis = NULL;
  72. }
  73. //////////////
  74. bool CVolumeOutWave::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(".WaveOutputVolume: 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(".WaveOutputVolume: 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(".WaveOutputVolume: 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(".WaveOutputVolume: FAILURE: Could not open Mixer. mmResult=%dn", mmResult );
  119. ::DestroyWindow( m_hWnd );
  120. return false;
  121. }
  122. return true;
  123. }
  124. //////////////
  125. void CVolumeOutWave::Done()
  126. {
  127. if ( mixerClose( (HMIXER)m_dwMixerHandle ) != MMSYSERR_NOERROR )
  128. {
  129. TRACE(".WaveOutputVolume: WARNING: Could not close Mixer.n" );
  130. }
  131. ::DestroyWindow( m_hWnd );
  132. m_bInitialized = false;
  133. m_bOK = false;
  134. }
  135. //////////////
  136. void CVolumeOutWave::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 CVolumeOutWave::Initialize()
  149. {
  150. MMRESULT mmResult;
  151. if ( !m_bOK )
  152. return false;
  153. TRACE(".WaveOutputVolume: Initializing for Source WaveOut Line ..n" );
  154. MIXERLINE MixerLine;
  155. memset( &MixerLine, 0, sizeof(MIXERLINE) );
  156. MixerLine.cbStruct = sizeof(MIXERLINE);
  157. MixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
  158. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &MixerLine, MIXER_GETLINEINFOF_COMPONENTTYPE );
  159. if ( mmResult != MMSYSERR_NOERROR )
  160. {
  161. TRACE(".WaveOutputVolume: FAILURE: Could not get WaveOut Destionation Line for the WaveOut 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(".WaveOutputVolume: "%s" Volume control for the WaveOut Source Line adopted.n", Control.szShortName );
  185. } else {
  186. TRACE(".WaveOutputVolume: WARNING: The Volume Control is disabled.n" );
  187. }
  188. } else {
  189. TRACE(".WaveOutputVolume: WARNING: Could not get the WaveOut 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 CVolumeOutWave::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(".WaveOutputVolume: FAILURE: Could not get the WaveOut Destination Line while enabling. mmResult=%dn", mmResult );
  220. } else {
  221. TRACE(".WaveOutputVolume: FAILURE: Could not get the WaveOut 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(".WaveOutputVolume: FAILURE: Out of memory while enabling the line.n" );
  236. } else {
  237. TRACE(".WaveOutputVolume: 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. TRACE(".WaveOutputVolume: FAILURE: Out of memory while enabling the line.n" );
  302. continue;
  303. }
  304. for ( int nItem = 0; nItem < nMultipleItems; nItem++ )
  305. {
  306. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  307. {
  308. aDetails[nItem+nChannel].fValue = lValue;
  309. }
  310. }
  311. } else {
  312. nMultipleItems = 0;
  313. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  314. if ( !aDetails )
  315. {
  316. if ( bEnable )
  317. {
  318. TRACE(".WaveOutputVolume: FAILURE: Out of memory while enabling the line.n" );
  319. } else {
  320. TRACE(".WaveOutputVolume: FAILURE: Out of memory while disabling the line.n" );
  321. }
  322. continue;
  323. }
  324. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  325. {
  326. aDetails[nChannel].fValue = (LONG)lValue;
  327. }
  328. }
  329. ControlDetails.cChannels = nChannels;
  330. ControlDetails.cMultipleItems = nMultipleItems;
  331. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
  332. ControlDetails.paDetails = &aDetails[0];
  333. mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, 0L );
  334. if ( mmResult == MMSYSERR_NOERROR )
  335. {
  336. if ( bEnable )
  337. {
  338. TRACE(".WaveOutputVolume: Enabling Line: WaveOut Line control "%s"(0x%X) has been set to %d.n", aControls[i].szShortName, aControls[i].dwControlType, lValue );
  339. } else {
  340. TRACE(".WaveOutputVolume: Disabling Line: WaveOut Line control "%s"(0x%X) has been set to %d.n", aControls[i].szShortName, aControls[i].dwControlType, lValue );
  341. }
  342. bAnyEnabled = true;
  343. }
  344. free( aDetails );
  345. }
  346. }
  347. } else {
  348. if ( bEnable )
  349. {
  350. TRACE(".WaveOutputVolume: FAILURE: Could not get the line controls while enabling. mmResult=%dn", mmResult );
  351. } else {
  352. TRACE(".WaveOutputVolume: FAILURE: Could not get the line controls while disabling. mmResult=%dn", mmResult );
  353. }
  354. }
  355. free( aControls );
  356. if ( !bAnyEnabled )
  357. {
  358. if ( bEnable )
  359. {
  360. TRACE(".WaveOutputVolume: WARNING: No controls were found for enabling the line.n" );
  361. } else {
  362. TRACE(".WaveOutputVolume: WARNING: No controls were found for disabling the line.n" );
  363. }
  364. }
  365. }
  366. //////////////////////////////////////////////
  367. // IVolume interface
  368. //////////////
  369. bool CVolumeOutWave::IsAvailable()
  370. {
  371. return m_bAvailable;
  372. }
  373. //////////////
  374. void CVolumeOutWave::Enable()
  375. {
  376. EnableLine( true );
  377. }
  378. //////////////
  379. void CVolumeOutWave::Disable()
  380. {
  381. EnableLine( false );
  382. }
  383. //////////////
  384. DWORD CVolumeOutWave::GetVolumeMetric()
  385. {
  386. if ( !m_bAvailable )
  387. return BAD_DWORD;
  388. return m_dwVolumeStep;
  389. }
  390. //////////////
  391. DWORD CVolumeOutWave::GetMinimalVolume()
  392. {
  393. if ( !m_bAvailable )
  394. return BAD_DWORD;
  395. return m_dwMinimalVolume;
  396. }
  397. //////////////
  398. DWORD CVolumeOutWave::GetMaximalVolume()
  399. {
  400. if ( !m_bAvailable )
  401. return BAD_DWORD;
  402. return m_dwMaximalVolume;
  403. }
  404. //////////////
  405. DWORD CVolumeOutWave::GetCurrentVolume()
  406. {
  407. if ( !m_bAvailable )
  408. return BAD_DWORD;
  409. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  410. if ( !aDetails )
  411. return BAD_DWORD;
  412. MIXERCONTROLDETAILS ControlDetails;
  413. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  414. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  415. ControlDetails.dwControlID = m_dwVolumeControlID;
  416. ControlDetails.cChannels = m_nChannelCount;
  417. ControlDetails.cMultipleItems = 0;
  418. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  419. ControlDetails.paDetails = &aDetails[0];
  420. MMRESULT mmResult = mixerGetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_GETCONTROLDETAILSF_VALUE );
  421. DWORD dw = aDetails[0].dwValue;
  422. free( aDetails );
  423. if ( mmResult != MMSYSERR_NOERROR )
  424. {
  425. TRACE(".WaveOutputVolume: FAILURE: Could not get volume. mmResult=%dn", mmResult );
  426. return BAD_DWORD;
  427. }
  428. return dw;
  429. }
  430. //////////////
  431. void CVolumeOutWave::SetCurrentVolume( DWORD dwValue )
  432. {
  433. if ( !m_bAvailable || (dwValue<m_dwMinimalVolume) || (dwValue>m_dwMaximalVolume) )
  434. return;
  435. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  436. if ( !aDetails )
  437. return;
  438. for ( int i = 0; i < m_nChannelCount; i++ )
  439. {
  440. aDetails[i].dwValue = dwValue;
  441. }
  442. MIXERCONTROLDETAILS ControlDetails;
  443. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  444. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  445. ControlDetails.dwControlID = m_dwVolumeControlID;
  446. ControlDetails.cChannels = m_nChannelCount;
  447. ControlDetails.cMultipleItems = 0;
  448. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  449. ControlDetails.paDetails = &aDetails[0];
  450. MMRESULT mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_SETCONTROLDETAILSF_VALUE );
  451. free( aDetails );
  452. if ( mmResult != MMSYSERR_NOERROR )
  453. {
  454. TRACE(".WaveOutputVolume: FAILURE: Could not set volume(%d) mmResult=%dn", dwValue, mmResult );
  455. }
  456. }
  457. //////////////
  458. void CVolumeOutWave::RegisterNotificationSink( PONMICVOULUMECHANGE pfUserSink, DWORD dwUserValue )
  459. {
  460. m_pfUserSink = pfUserSink;
  461. m_dwUserValue = dwUserValue;
  462. }
  463. ////////////////////////////////////////////////////////////////////////
  464. LRESULT CALLBACK CVolumeOutWave::MixerWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  465. {
  466. if ( uMsg == MM_MIXM_CONTROL_CHANGE )
  467. {
  468. if ( g_pThis )
  469. {
  470. g_pThis->OnControlChanged( (DWORD)lParam );
  471. }
  472. }
  473. return ::DefWindowProc( hwnd, uMsg, wParam, lParam);
  474. }