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

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

Audio

开发平台：

Visual C++

VolumeInXXX.cpp：源码内容
  1. // VolumeInXXX.cpp : Module interface implementation.
  2. // Developer : Alex Chmut
  3. // Created : 8/11/98
  4. #include "StdAfx.h"
  5. #include "VolumeInXXX.h"
  7. /////////////////////////////////////////////////////////////////////////////
  8. //  Defines
  9. #define BAD_DWORD (DWORD)-1
  10. #define WND_CLASS_NAME "Input Volume Msg Wnd Class"
  11. #define WND_NAME "Input Volume Msg Wnd"
  13. /////////////////////////////////////////////////////////////////////////////
  14. //  Globals
  15. PCVolumeInXXX 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. CVolumeInXXX::CVolumeInXXX( UINT uLineIndex )
  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_uMicrophoneSourceLineIndex(BAD_DWORD),
  52. m_dwMinimalVolume(BAD_DWORD),
  53. m_dwMaximalVolume(BAD_DWORD),
  55. m_pfUserSink(NULL),
  56. m_dwUserValue(0L)
  57. {
  58. if ( m_bOK = Init() )
  59. {
  60. g_pThis = this;
  61. if ( !Initialize( uLineIndex ) )
  62. {
  63. Done();
  64. g_pThis = NULL;
  65. }
  66. }
  67. }
  68. //////////////
  69. CVolumeInXXX::~CVolumeInXXX()
  70. {
  71. if ( m_bOK )
  72. Done();
  73. g_pThis = NULL;
  74. }
  75. //////////////
  76. bool CVolumeInXXX::Init()
  77. {
  78. if ( !mixerGetNumDevs() )
  79. return false;
  80. // Getting Mixer ID
  81. HWAVEIN hwaveIn;
  82. MMRESULT mmResult;
  83. WAVEFORMATEX WaveFmt;
  84. SetDeviceType( &WaveFmt );
  85. mmResult = waveInOpen( &hwaveIn, WAVE_MAPPER, &WaveFmt, 0L, 0L, CALLBACK_NULL );
  86. if ( mmResult != MMSYSERR_NOERROR )
  87. {
  88. TRACE(".InputXxxVolume: FAILURE: Could not open WaveIn Mapper. mmResult=%dn", mmResult );
  89. return false;
  90. } else {
  91. mmResult = mixerGetID( (HMIXEROBJ)hwaveIn, &m_uMixerID, MIXER_OBJECTF_HWAVEIN );
  92. waveInClose( hwaveIn );
  93. if ( mmResult != MMSYSERR_NOERROR )
  94. {
  95. TRACE(".InputXxxVolume: FAILURE: WaveIn Mapper in Mixer is not available. mmResult=%dn", mmResult );
  96. return false;
  97. }
  98. }
  99. // Exposing Window to Mixer
  100. WNDCLASSEX wcx;
  101. memset( &wcx, 0, sizeof(WNDCLASSEX) );
  102. wcx.cbSize = sizeof(WNDCLASSEX);
  103. wcx.lpszClassName = WND_CLASS_NAME;
  104. wcx.lpfnWndProc = (WNDPROC)MixerWndProc;
  105. ::RegisterClassEx(&wcx);
  106. m_hWnd = CreateWindow( WND_CLASS_NAME,
  107. WND_NAME,
  108. WS_POPUP | WS_DISABLED,
  109. 0, 0, 0, 0,
  110. NULL, NULL, NULL, NULL );
  111. if ( !m_hWnd )
  112. {
  113. TRACE(".InputXxxVolume: FAILURE: Could not create internal window.n" );
  114. return false;
  115. }
  116. ::ShowWindow(m_hWnd, SW_HIDE);
  117. mmResult = mixerOpen( (LPHMIXER)&m_dwMixerHandle, m_uMixerID, (DWORD)m_hWnd, 0L, CALLBACK_WINDOW );
  118. if ( mmResult != MMSYSERR_NOERROR )
  119. {
  120. TRACE(".InputXxxVolume: FAILURE: Could not open Mixer. mmResult=%dn", mmResult );
  121. ::DestroyWindow( m_hWnd );
  122. return false;
  123. }
  124. return true;
  125. }
  126. //////////////
  127. void CVolumeInXXX::Done()
  128. {
  129. if ( mixerClose( (HMIXER)m_dwMixerHandle ) != MMSYSERR_NOERROR )
  130. {
  131. TRACE(".InputXxxVolume: WARNING: Could not close Mixer.n" );
  132. }
  133. ::DestroyWindow( m_hWnd );
  134. m_bInitialized = false;
  135. m_bOK = false;
  136. }
  137. //////////////
  138. void CVolumeInXXX::OnControlChanged( DWORD dwControlID )
  139. {
  140. if ( m_dwVolumeControlID == dwControlID )
  141. {
  142. DWORD dwVolume = GetCurrentVolume();
  143. if ( (dwVolume!=BAD_DWORD) && (m_pfUserSink) )
  144. {
  145. (*m_pfUserSink)( dwVolume, m_dwUserValue );
  146. }
  147. }
  148. }
  149. //////////////
  150. bool CVolumeInXXX::Initialize( UINT uLineIndex )
  151. {
  152. MMRESULT mmResult;
  153. if ( !m_bOK )
  154. return false;
  155. TRACE(".InputXxxVolume: Initializing for the Source Line (%d) ..n", uLineIndex );
  156. MIXERLINE MixerLine;
  157. memset( &MixerLine, 0, sizeof(MIXERLINE) );
  158. MixerLine.cbStruct = sizeof(MIXERLINE);
  159. MixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
  160. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &MixerLine, MIXER_GETLINEINFOF_COMPONENTTYPE );
  161. if ( mmResult != MMSYSERR_NOERROR )
  162. {
  163. TRACE(".InputXxxVolume: FAILURE: Could not get WaveIn Destionation Line for the requested source while initilaizing. mmResult=%dn", mmResult );
  164. return false;
  165. }
  167. MIXERCONTROL Control;
  168. memset( &Control, 0, sizeof(MIXERCONTROL) );
  169. Control.cbStruct = sizeof(MIXERCONTROL);
  171. MIXERLINECONTROLS LineControls;
  172. memset( &LineControls, 0, sizeof(MIXERLINECONTROLS) );
  173. LineControls.cbStruct = sizeof(MIXERLINECONTROLS);
  175. MIXERLINE Line;
  176. memset( &Line, 0, sizeof(MIXERLINE) );
  177. Line.cbStruct = sizeof(MIXERLINE);
  179. if ( ( uLineIndex < MixerLine.cConnections ) )
  180. {
  181. Line.dwDestination = MixerLine.dwDestination;
  182. Line.dwSource = uLineIndex;
  183. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &Line, MIXER_GETLINEINFOF_SOURCE );
  184. if ( mmResult != MMSYSERR_NOERROR )
  185. {
  186. TRACE(".InputXxxVolume: FAILURE: Could not get the requested Source Line while initilaizing. mmResult=%dn", mmResult );
  187. return false;
  188. }
  189. TRACE(".InputXxxVolume: "%s" Source Line adopted.n", Line.szShortName );
  190. LineControls.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
  191. LineControls.dwLineID = Line.dwLineID;
  192. LineControls.cControls = 1;
  193. LineControls.cbmxctrl = sizeof(MIXERCONTROL);
  194. LineControls.pamxctrl = &Control;
  195. mmResult = mixerGetLineControls( (HMIXEROBJ)m_dwMixerHandle, &LineControls, MIXER_GETLINECONTROLSF_ONEBYTYPE );
  196. if ( mmResult == MMSYSERR_NOERROR )
  197. {
  198. if ( !(Control.fdwControl & MIXERCONTROL_CONTROLF_DISABLED) )
  199. {
  200. m_bAvailable = true;
  201. TRACE(".InputXxxVolume: "%s" Volume control for the Source Line adoptedn", Control.szShortName );
  202. } else {
  203. TRACE(".InputXxxVolume: WARNING: The Volume Control is disabled.n" );
  204. }
  205. } else {
  206. TRACE(".InputXxxVolume: WARNING: Could not get the requested Source Line Volume Control for the requested line while initilaizing. mmResult=%dn", mmResult );
  207. }
  208. } else {
  209. TRACE(".InputXxxVolume: FAILURE: Invalid Source Line index passed.n" );
  210. return false;
  211. }
  213. // Retrieving Microphone Source Line
  214. for ( UINT uLine = 0; uLine < MixerLine.cConnections; uLine++ )
  215. {
  216. MIXERLINE MicrophoneLine;
  217. memset( &MicrophoneLine, 0, sizeof(MIXERLINE) );
  218. MicrophoneLine.cbStruct = sizeof(MIXERLINE);
  219. MicrophoneLine.dwDestination = MixerLine.dwDestination;
  220. MicrophoneLine.dwSource = uLine;
  221. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &MicrophoneLine, MIXER_GETLINEINFOF_SOURCE );
  222. if ( mmResult == MMSYSERR_NOERROR )
  223. {
  224. if ( MicrophoneLine.dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE )
  225. {
  226. m_uMicrophoneSourceLineIndex = MicrophoneLine.dwSource;
  227. TRACE(".InputXxxVolume: Microphone Source Line "%s" has been found.n", MicrophoneLine.szShortName );
  228. break;
  229. }
  230. }
  231. }
  232. if ( m_uMicrophoneSourceLineIndex == BAD_DWORD )
  233. {
  234. TRACE(".InputXxxVolume: WARNING: Could not retrieve Microphone Source Line.n" );
  235. }
  237. m_uSourceLineIndex = uLineIndex;
  238. m_nChannelCount = Line.cChannels;
  239. m_dwLineID = LineControls.dwLineID;
  240. m_dwVolumeControlID = Control.dwControlID;
  241. m_dwMinimalVolume = Control.Bounds.dwMinimum;
  242. m_dwMaximalVolume = Control.Bounds.dwMaximum;
  243. m_dwVolumeStep = Control.Metrics.cSteps;
  245. m_bInitialized = true;
  246. return true;
  247. }
  248. //////////////////////////////////////////////
  249. bool CVolumeInXXX::GetMicrophoneSourceLineIndex( UINT* puLineIndex )
  250. {
  251. if ( !puLineIndex || !m_bInitialized || (m_uMicrophoneSourceLineIndex==BAD_DWORD) )
  252. return false;
  253. *puLineIndex = m_uMicrophoneSourceLineIndex;
  254. return true;
  255. }
  256. //////////////////////////////////////////////
  257. // IVolume interface
  258. //////////////
  259. bool CVolumeInXXX::IsAvailable()
  260. {
  261. return m_bAvailable;
  262. }
  263. //////////////
  264. void CVolumeInXXX::Enable()
  265. {
  266. if ( !m_bInitialized )
  267. return;
  268. bool bAnyEnabled = false;
  269. MMRESULT mmResult;
  271. MIXERLINE lineDestination;
  272. memset( &lineDestination, 0, sizeof(MIXERLINE) );
  273. lineDestination.cbStruct = sizeof(MIXERLINE);
  274. lineDestination.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
  275. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &lineDestination, MIXER_GETLINEINFOF_COMPONENTTYPE );
  276. if ( mmResult != MMSYSERR_NOERROR )
  277. {
  278. TRACE(".InputXxxVolume: FAILURE: Could not get the Destination Line while enabling. mmResult=%dn", mmResult );
  279. return;
  280. }
  281. // Getting all line's controls
  282. int nControlCount = lineDestination.cControls;
  283. int nChannelCount = lineDestination.cChannels;
  284. MIXERLINECONTROLS LineControls;
  285. memset( &LineControls, 0, sizeof(MIXERLINECONTROLS) );
  286. MIXERCONTROL* aControls = (MIXERCONTROL*)malloc( nControlCount * sizeof(MIXERCONTROL) );
  287. if ( !aControls )
  288. {
  289. TRACE(".InputXxxVolume: FAILURE: Out of memory while enabling the line.n" );
  290. return;
  291. }
  292. memset( &aControls[0], 0, sizeof(nControlCount * sizeof(MIXERCONTROL)) );
  293. for ( int i = 0; i < nControlCount; i++ )
  294. {
  295. aControls[i].cbStruct = sizeof(MIXERCONTROL);
  296. }
  297. LineControls.cbStruct = sizeof(MIXERLINECONTROLS);
  298. LineControls.dwLineID = lineDestination.dwLineID;
  299. LineControls.cControls = nControlCount;
  300. LineControls.cbmxctrl = sizeof(MIXERCONTROL);
  301. LineControls.pamxctrl = &aControls[0];
  302. mmResult = mixerGetLineControls( (HMIXEROBJ)m_dwMixerHandle, &LineControls, MIXER_GETLINECONTROLSF_ALL );
  303. if ( mmResult == MMSYSERR_NOERROR )
  304. {
  305. for ( i = 0; i < nControlCount; i++ )
  306. {
  307. if ( aControls[i].dwControlType & MIXERCONTROL_CT_UNITS_BOOLEAN )
  308. {
  309. MIXERCONTROLDETAILS_BOOLEAN* aDetails = NULL;
  310. int nMultipleItems = aControls[i].cMultipleItems;
  311. int nChannels = nChannelCount;
  312. // MIXERCONTROLDETAILS
  313. MIXERCONTROLDETAILS ControlDetails;
  314. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  315. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  316. ControlDetails.dwControlID = aControls[i].dwControlID;
  317. if ( aControls[i].fdwControl & MIXERCONTROL_CONTROLF_UNIFORM )
  318. {
  319. nChannels = 1;
  320. }
  321. if ( aControls[i].fdwControl & MIXERCONTROL_CONTROLF_MULTIPLE )
  322. {
  323. nMultipleItems = aControls[i].cMultipleItems;
  324. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nMultipleItems*nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  325. if ( !aDetails )
  326. {
  327. TRACE(".InputXxxVolume: FAILURE: Out of memory while enabling the line.n" );
  328. continue;
  329. }
  330. for ( int nItem = 0; nItem < nMultipleItems; nItem++ )
  331. {
  332. LONG lValue = FALSE;
  333. if ( nItem == (int)m_uSourceLineIndex )
  334. lValue = TRUE;
  335. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  336. {
  337. aDetails[nItem+nChannel].fValue = lValue;
  338. }
  339. }
  340. } else {
  341. nMultipleItems = 0;
  342. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  343. if ( !aDetails )
  344. {
  345. TRACE(".InputXxxVolume: FAILURE: Out of memory while enabling the line.n" );
  346. continue;
  347. }
  348. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  349. {
  350. aDetails[nChannel].fValue = (LONG)TRUE;
  351. }
  352. }
  353. ControlDetails.cChannels = nChannels;
  354. ControlDetails.cMultipleItems = nMultipleItems;
  355. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
  356. ControlDetails.paDetails = &aDetails[0];
  357. mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, 0L );
  358. if ( mmResult == MMSYSERR_NOERROR )
  359. {
  360. TRACE(".InputXxxVolume: Enabling Line: Line control "%s" has been enabled.n", aControls[i].szShortName );
  361. bAnyEnabled = true;
  362. }
  363. free( aDetails );
  364. }
  365. }
  366. } else {
  367. TRACE(".InputXxxVolume: FAILURE: Could not get the line's controls while enabling. mmResult=%dn", mmResult );
  368. }
  369. free( aControls );
  370. if ( !bAnyEnabled )
  371. {
  372. TRACE(".InputXxxVolume: WARNING: No controls were found for enabling the line.n" );
  373. }
  374. }
  375. //////////////
  376. void CVolumeInXXX::Disable()
  377. {
  378. TRACE(".InputXxxVolume: WARNING: Disable line has no sense. The function not implemented.n" );
  379. }
  380. //////////////
  381. DWORD CVolumeInXXX::GetVolumeMetric()
  382. {
  383. if ( !m_bAvailable )
  384. return BAD_DWORD;
  385. return m_dwVolumeStep;
  386. }
  387. //////////////
  388. DWORD CVolumeInXXX::GetMinimalVolume()
  389. {
  390. if ( !m_bAvailable )
  391. return BAD_DWORD;
  392. return m_dwMinimalVolume;
  393. }
  394. //////////////
  395. DWORD CVolumeInXXX::GetMaximalVolume()
  396. {
  397. if ( !m_bAvailable )
  398. return BAD_DWORD;
  399. return m_dwMaximalVolume;
  400. }
  401. //////////////
  402. DWORD CVolumeInXXX::GetCurrentVolume()
  403. {
  404. if ( !m_bAvailable )
  405. return BAD_DWORD;
  406. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  407. if ( !aDetails )
  408. return BAD_DWORD;
  409. MIXERCONTROLDETAILS ControlDetails;
  410. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  411. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  412. ControlDetails.dwControlID = m_dwVolumeControlID;
  413. ControlDetails.cChannels = m_nChannelCount;
  414. ControlDetails.cMultipleItems = 0;
  415. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  416. ControlDetails.paDetails = &aDetails[0];
  417. MMRESULT mmResult = mixerGetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_GETCONTROLDETAILSF_VALUE );
  418. DWORD dw = aDetails[0].dwValue;
  419. free( aDetails );
  420. if ( mmResult != MMSYSERR_NOERROR )
  421. {
  422. TRACE(".InputXxxVolume: FAILURE: Could not get volume. mmResult=%dn", mmResult );
  423. return BAD_DWORD;
  424. }
  425. return dw;
  426. }
  427. //////////////
  428. void CVolumeInXXX::SetCurrentVolume( DWORD dwValue )
  429. {
  430. if ( !m_bAvailable || (dwValue<m_dwMinimalVolume) || (dwValue>m_dwMaximalVolume) )
  431. return;
  432. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  433. if ( !aDetails )
  434. return;
  435. for ( int i = 0; i < m_nChannelCount; i++ )
  436. {
  437. aDetails[i].dwValue = dwValue;
  438. }
  439. MIXERCONTROLDETAILS ControlDetails;
  440. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  441. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  442. ControlDetails.dwControlID = m_dwVolumeControlID;
  443. ControlDetails.cChannels = m_nChannelCount;
  444. ControlDetails.cMultipleItems = 0;
  445. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  446. ControlDetails.paDetails = &aDetails[0];
  447. MMRESULT mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_SETCONTROLDETAILSF_VALUE );
  448. free( aDetails );
  449. if ( mmResult != MMSYSERR_NOERROR )
  450. {
  451. TRACE(".InputXxxVolume: FAILURE: Could not set volume(%d) mmResult=%dn", dwValue, mmResult );
  452. }
  453. }
  454. //////////////
  455. void CVolumeInXXX::RegisterNotificationSink( PONMICVOULUMECHANGE pfUserSink, DWORD dwUserValue )
  456. {
  457. m_pfUserSink = pfUserSink;
  458. m_dwUserValue = dwUserValue;
  459. }
  460. ////////////////////////////////////////////////////////////////////////
  461. LRESULT CALLBACK CVolumeInXXX::MixerWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  462. {
  463. if ( uMsg == MM_MIXM_CONTROL_CHANGE )
  464. {
  465. if ( g_pThis )
  466. {
  467. g_pThis->OnControlChanged( (DWORD)lParam );
  468. }
  469. }
  470. return ::DefWindowProc( hwnd, uMsg, wParam, lParam);
  471. }
  472. ////////////////////////////////////////////////////////////////////////
  473. bool CVolumeInXXX::EnumerateInputLines( PINPUTLINEPROC pUserCallback, DWORD dwUserValue )
  474. {
  475. if ( !pUserCallback )
  476. return false;
  477. MMRESULT mmResult;
  478. HWAVEIN hwaveIn;
  479. WAVEFORMATEX WaveFmt;
  480. SetDeviceType( &WaveFmt );
  481. mmResult = waveInOpen( &hwaveIn, WAVE_MAPPER, &WaveFmt, 0L, 0L, CALLBACK_NULL );
  482. if ( mmResult != MMSYSERR_NOERROR )
  483. {
  484. TRACE(".InputXxxVolume: FAILURE: Could not open WaveIn Mapper. mmResult=%dn", mmResult );
  485. return false;
  486. }
  487. UINT uMixerID;
  488. DWORD dwMixerHandle;
  489. mmResult = mixerGetID( (HMIXEROBJ)hwaveIn, &uMixerID, MIXER_OBJECTF_HWAVEIN );
  490. waveInClose( hwaveIn );
  491. if ( mmResult != MMSYSERR_NOERROR )
  492. {
  493. TRACE(".InputXxxVolume: FAILURE: WaveIn Mapper in Mixer is not available. mmResult=%dn", mmResult );
  494. return false;
  495. }
  496. mmResult = mixerOpen( (LPHMIXER)&dwMixerHandle, uMixerID, 0L, 0L, 0L );
  497. if ( mmResult != MMSYSERR_NOERROR )
  498. {
  499. mixerClose( (HMIXER)dwMixerHandle );
  500. TRACE(".InputXxxVolume: FAILURE: Could not open Mixer. mmResult=%dn", mmResult );
  501. return false;
  502. }
  503. MIXERLINE MixerLine;
  504. memset( &MixerLine, 0, sizeof(MIXERLINE) );
  505. MixerLine.cbStruct = sizeof(MIXERLINE);
  506. MixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
  507. mmResult = mixerGetLineInfo( (HMIXEROBJ)dwMixerHandle, &MixerLine, MIXER_GETLINEINFOF_COMPONENTTYPE );
  508. if ( mmResult != MMSYSERR_NOERROR )
  509. {
  510. mixerClose( (HMIXER)dwMixerHandle );
  511. TRACE(".InputXxxVolume: FAILURE: Could not get WaveIn Destionation Line for the requested source while enumerating. mmResult=%dn", mmResult );
  512. return false;
  513. }
  514. MIXERLINE Line;
  515. for ( UINT uLineIndex = 0; uLineIndex < MixerLine.cConnections; uLineIndex++ )
  516. {
  517. memset( &Line, 0, sizeof(MIXERLINE) );
  518. Line.cbStruct = sizeof(MIXERLINE);
  519. Line.dwDestination = MixerLine.dwDestination;
  520. Line.dwSource = uLineIndex;
  521. mmResult = mixerGetLineInfo( (HMIXEROBJ)dwMixerHandle, &Line, MIXER_GETLINEINFOF_SOURCE );
  522. if ( mmResult != MMSYSERR_NOERROR )
  523. {
  524. mixerClose( (HMIXER)dwMixerHandle );
  525. TRACE(".InputXxxVolume: FAILURE: Could not get the interated Source Line while enumerating. mmResult=%dn", mmResult );
  526. return false;
  527. }
  528. if ( !((*pUserCallback)( uLineIndex, &Line, dwUserValue )) )
  529. {
  530. break;
  531. }
  532. }
  533. mixerClose( (HMIXER)dwMixerHandle );
  534. return true;
  535. }