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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
VolumeOutWave.cpp
资源名称：网络视频电话系统.rar　[点击查看]
上传用户：oldpeter23
上传日期：2013-01-09
资源大小：1111k
文件大小：14k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

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