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

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

IP电话/视频会议

开发平台：

Visual C++

VolumeOutMaster.cpp：源码内容
  1. //NetTalk
  2. /*------------------------------------------------------------------------------*
  3.  =============================
  4.    模块名称: VolumeOutMaster.cpp
  5.  =============================
  6.  
  7.  [版权]
  8.  
  9.    2000-2002  115软件工厂  版权所有
  10.                                               
  11. *------------------------------------------------------------------------------*/
  13. #include <Windows.h>
  15. #include "VolumeOutMaster.h"
  16. /*------------------------------------------------------------------------------*/
  17. /////////////////////////////////////////////////////////////////////////////
  18. //  Defines
  19. #define BAD_DWORD (DWORD)-1
  20. #define WND_CLASS_NAME "Master Output Volume Msg Wnd Class"
  21. #define WND_NAME "Master Output Volume Msg Wnd"
  22. /*------------------------------------------------------------------------------*/
  23. /////////////////////////////////////////////////////////////////////////////
  24. //  Globals
  25. PCVolumeOutMaster g_pThis = NULL;
  26. /*------------------------------------------------------------------------------*/
  27. ////////////////////////////////////////////////////////////
  28. /*------------------------------------------------------------------------------*/
  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. CVolumeOutMaster::CVolumeOutMaster()
  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. CVolumeOutMaster::~CVolumeOutMaster()
  80. {
  81. if ( m_bOK )
  82. Done();
  83. g_pThis = NULL;
  84. }
  85. /*------------------------------------------------------------------------------*/
  86. //////////////
  87. bool CVolumeOutMaster::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 CVolumeOutMaster::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 CVolumeOutMaster::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 CVolumeOutMaster::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_DST_SPEAKERS;
  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 CVolumeOutMaster::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. if ( bEnable )
  312. {
  313. } else {
  314. }
  315. continue;
  316. }
  317. for ( int nItem = 0; nItem < nMultipleItems; nItem++ )
  318. {
  319. /*
  320. if ( ( aControls[i].dwControlType & MIXERCONTROL_CONTROLTYPE_SINGLESELECT )
  321.   && ( nItem > 0 ) )
  322. {
  323. lValue = (LONG)!((BOOL)lValue);
  324. }
  325. */
  326. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  327. {
  328. aDetails[nItem+nChannel].fValue = lValue;
  329. }
  330. }
  331. } else {
  332. nMultipleItems = 0;
  333. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  334. if ( !aDetails )
  335. {
  336. if ( bEnable )
  337. {
  338. } else {
  339. }
  340. continue;
  341. }
  342. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  343. {
  344. aDetails[nChannel].fValue = (LONG)lValue;
  345. }
  346. }
  347. ControlDetails.cChannels = nChannels;
  348. ControlDetails.cMultipleItems = nMultipleItems;
  349. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
  350. ControlDetails.paDetails = &aDetails[0];
  351. mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, 0L );
  352. if ( mmResult == MMSYSERR_NOERROR )
  353. {
  354. if ( bEnable )
  355. {
  356. } else {
  357. }
  358. bAnyEnabled = true;
  359. }
  360. free( aDetails );
  361. }
  362. }
  363. } else {
  364. if ( bEnable )
  365. {
  366. } else {
  367. }
  368. }
  369. free( aControls );
  370. if ( !bAnyEnabled )
  371. {
  372. if ( bEnable )
  373. {
  374. } else {
  375. }
  376. }
  377. }
  378. /*------------------------------------------------------------------------------*/
  379. //////////////////////////////////////////////
  380. // IVolume interface
  381. //////////////
  382. bool CVolumeOutMaster::IsAvailable()
  383. {
  384. return m_bAvailable;
  385. }
  386. /*------------------------------------------------------------------------------*/
  387. //////////////
  388. void CVolumeOutMaster::Enable()
  389. {
  390. EnableLine( true );
  391. }
  392. /*------------------------------------------------------------------------------*/
  393. void CVolumeOutMaster::Disable()
  394. {
  395. EnableLine( false );
  396. }
  397. /*------------------------------------------------------------------------------*/
  398. //////////////
  399. DWORD CVolumeOutMaster::GetVolumeMetric()
  400. {
  401. if ( !m_bAvailable )
  402. return BAD_DWORD;
  403. return m_dwVolumeStep;
  404. }
  405. /*------------------------------------------------------------------------------*/
  406. //////////////
  407. DWORD CVolumeOutMaster::GetMinimalVolume()
  408. {
  409. if ( !m_bAvailable )
  410. return BAD_DWORD;
  411. return m_dwMinimalVolume;
  412. }
  413. /*------------------------------------------------------------------------------*/
  414. //////////////
  415. DWORD CVolumeOutMaster::GetMaximalVolume()
  416. {
  417. if ( !m_bAvailable )
  418. return BAD_DWORD;
  419. return m_dwMaximalVolume;
  420. }
  421. /*------------------------------------------------------------------------------*/
  422. //////////////
  423. DWORD CVolumeOutMaster::GetCurrentVolume()
  424. {
  425. if ( !m_bAvailable )
  426. return BAD_DWORD;
  427. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  428. if ( !aDetails )
  429. return BAD_DWORD;
  430. MIXERCONTROLDETAILS ControlDetails;
  431. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  432. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  433. ControlDetails.dwControlID = m_dwVolumeControlID;
  434. ControlDetails.cChannels = m_nChannelCount;
  435. ControlDetails.cMultipleItems = 0;
  436. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  437. ControlDetails.paDetails = &aDetails[0];
  438. MMRESULT mmResult = mixerGetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_GETCONTROLDETAILSF_VALUE );
  439. DWORD dw = aDetails[0].dwValue;
  440. free( aDetails );
  441. if ( mmResult != MMSYSERR_NOERROR )
  442. {
  443. return BAD_DWORD;
  444. }
  445. return dw;
  446. }
  447. /*------------------------------------------------------------------------------*/
  448. //////////////
  449. void CVolumeOutMaster::SetCurrentVolume( DWORD dwValue )
  450. {
  451. if ( !m_bAvailable || (dwValue<m_dwMinimalVolume) || (dwValue>m_dwMaximalVolume) )
  452. return;
  453. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  454. if ( !aDetails )
  455. return;
  456. for ( int i = 0; i < m_nChannelCount; i++ )
  457. {
  458. aDetails[i].dwValue = dwValue;
  459. }
  460. MIXERCONTROLDETAILS ControlDetails;
  461. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  462. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  463. ControlDetails.dwControlID = m_dwVolumeControlID;
  464. ControlDetails.cChannels = m_nChannelCount;
  465. ControlDetails.cMultipleItems = 0;
  466. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  467. ControlDetails.paDetails = &aDetails[0];
  468. MMRESULT mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_SETCONTROLDETAILSF_VALUE );
  469. free( aDetails );
  470. if ( mmResult != MMSYSERR_NOERROR )
  471. {
  472. }
  473. }
  474. /*------------------------------------------------------------------------------*/
  475. //////////////
  476. void CVolumeOutMaster::RegisterNotificationSink( PONMICVOULUMECHANGE pfUserSink, DWORD dwUserValue )
  477. {
  478. m_pfUserSink = pfUserSink;
  479. m_dwUserValue = dwUserValue;
  480. }
  481. /*------------------------------------------------------------------------------*/
  482. ////////////////////////////////////////////////////////////////////////
  483. LRESULT CALLBACK CVolumeOutMaster::MixerWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  484. {
  485. if ( uMsg == MM_MIXM_CONTROL_CHANGE )
  486. {
  487. if ( g_pThis )
  488. {
  489. g_pThis->OnControlChanged( (DWORD)lParam );
  490. }
  491. }
  492. return ::DefWindowProc( hwnd, uMsg, wParam, lParam);
  493. }